openAgent
gitlabThe open source UNIVERSAL agent.
clone
https://gitlab.com/bitzzdev/openAgent.gitAIagentautomationopen-sourceuniversal-agent
import { describe, expect, test } from "bun:test"import { CODE_MODE_TOOL, CodeModeTool, Parameters, describeCatalog } from "@/tool/code-mode"import type { Tool as MCPToolDef } from "@modelcontextprotocol/sdk/types.js"import type { PermissionV1 } from "@opencode-ai/core/v1/permission"import { Agent } from "@/agent/agent"import { MCP } from "@/mcp"import { Permission } from "@/permission"import { Plugin } from "@/plugin"import { Session } from "@/session/session"import { Tool } from "@/tool/tool"import * as Truncate from "@/tool/truncate"import { MessageID, SessionID } from "@/session/schema"import { Cause, Effect, Exit, Layer, Schema } from "effect"const ctx: Tool.Context = {sessionID: SessionID.make("ses_code-mode"),messageID: MessageID.make("msg_code-mode"),agent: "build",abort: new AbortController().signal,callID: "call_code_mode",messages: [],metadata: () => Effect.void,ask: () => Effect.void,}function mcpTool(name: string,handler: (args: Record<string, unknown>) => unknown,inputSchema: Record<string, unknown> = { type: "object", properties: {} },outputSchema?: Record<string, unknown>,): MCP.McpTool {return {def: { name, description: name, inputSchema, ...(outputSchema ? { outputSchema } : {}) } as MCPToolDef,client: {callTool: async (params: { arguments?: Record<string, unknown> }) => handler(params.arguments ?? {}),} as unknown as MCP.McpTool["client"],}}function harness(input: {mcpTools: Record<string, MCP.McpTool>servers: string[]permission?: PermissionV1.Rule[]trigger?: Plugin.Interface["trigger"]}) {return Layer.mergeAll(Layer.mock(Plugin.Service, {trigger: input.trigger ?? (((_name, _input, output) => Effect.succeed(output)) as Plugin.Interface["trigger"]),}),Layer.mock(Truncate.Service, {output: (text: string) => Effect.succeed({ content: text, truncated: false as const }),}),Layer.mock(Agent.Service, {get: () => Effect.succeed({ name: "build", permission: input.permission ?? [] } as any),}),Layer.mock(Session.Service, {get: () => Effect.succeed({ permission: [] } as any),}),Layer.mock(MCP.Service, {tools: () => Effect.succeed(input.mcpTools),clients: () => Effect.succeed(Object.fromEntries(input.servers.map((name) => [name, {} as any]))),}),)}function serverNames(mcpTools: Record<string, MCP.McpTool>, servers?: string[]) {return servers ?? [...new Set(Object.keys(mcpTools).map((key) => key.split("_")[0]!))]}function build(mcpTools: Record<string, MCP.McpTool>,servers?: string[],permission?: PermissionV1.Rule[],trigger?: Plugin.Interface["trigger"],) {const names = serverNames(mcpTools, servers)return Effect.runPromise(CodeModeTool.pipe(Effect.flatMap(Tool.init),Effect.provide(harness({ mcpTools, servers: names, permission, trigger })),),)}function describeFor(mcpTools: Record<string, MCP.McpTool>, servers?: string[], permission: PermissionV1.Rule[] = []) {return describeCatalog(Permission.visibleTools(mcpTools, permission), serverNames(mcpTools, servers))}// Program failures die at the tool boundary; recover the defect for message assertions.async function failure(effect: Effect.Effect<unknown>) {const exit = await Effect.runPromise(effect.pipe(Effect.exit))if (Exit.isSuccess(exit)) throw new Error("expected the tool to fail")return Cause.squash(exit.cause) as Error}describe("code mode execute", () => {test("defines execute input with an Effect schema", async () => {const decode = Schema.decodeUnknownEffect(Parameters)await expect(Effect.runPromise(decode({ code: "return 1" }))).resolves.toEqual({ code: "return 1" })await expect(Effect.runPromise(decode({}))).rejects.toThrow()expect(Schema.toJsonSchemaDocument(Parameters).schema).toMatchObject({properties: {code: {description: "Script body executed by the confined interpreter.",},},})})test("groups multi-underscore server names by longest matching prefix", () => {const description = describeFor({ my_server_do_thing: mcpTool("do_thing", () => "") }, ["my_server"])expect(description).toContain("- my_server (1 tool)")expect(description).toContain("tools.my_server.do_thing(")})test("groupByServer uses the whole key as the server name when it has no underscore", () => {const description = describeFor({ standalone: mcpTool("standalone", () => "") }, [])expect(description).toContain("- standalone (1 tool)")expect(description).toContain("tools.standalone.standalone(")})test("describeCatalog carries the raw MCP schemas for rendering", () => {const description = describeFor({weather_current: mcpTool("current",() => "",{ type: "object", properties: { city: { type: "string" } }, required: ["city"] },{ type: "object", properties: { tempC: { type: "number" } }, required: ["tempC"] },),},["weather"],)expect(description).toContain("tools.weather.current(input: {\n city: string,\n}): Promise<{\n tempC: number,\n}>",)})test("the static base description carries no catalog; the registry appends it", async () => {const tool = await build({ github_list_issues: mcpTool("list_issues", () => "") })expect(tool.id).toBe(CODE_MODE_TOOL)expect(tool.description).toBe("Run a confined orchestration script with access to connected MCP tools.")expect(tool.description).not.toContain("Available tools")expect(tool.description).not.toContain("list_issues")})test("small catalogs inline every full signature in the appended catalog", () => {const description = describeFor({github_create_issue: mcpTool("create_issue", () => "", {type: "object",properties: { title: { type: "string" }, body: { type: "string" } },required: ["title"],}),github_list_issues: mcpTool("list_issues", () => ""),linear_search: mcpTool("search", () => ""),})expect(description).toContain("Available tools (COMPLETE list")expect(description).toContain("- github (2 tools)")expect(description).toContain("- linear (1 tool)")expect(description).toContain("tools.github.create_issue(input: {\n title: string,\n body?: string,\n}): Promise<unknown>",)expect(description).toContain("tools.github.list_issues(")expect(description).toContain("tools.linear.search(")expect(description).toContain("tools.linear.search(input: {}): Promise<unknown>")expect(description).not.toContain("$codemode")expect(description).not.toContain("Browse one namespace")expect(description).toContain("## Workflow")expect(description).toContain("1. Pick a tool from the list under `## Available tools`")expect(description).not.toContain("JSON.parse(res)")expect(description).toContain("check that it is a non-null object and not an array")expect(description).toContain("Return only the fields you need")expect(description).not.toContain("total_count")})test("signatures render the declared outputSchema as the return type", () => {const description = describeFor({weather_current: mcpTool("current",() => "",{ type: "object", properties: { city: { type: "string" } }, required: ["city"] },{type: "object",properties: { tempC: { type: "number" }, summary: { type: "string" } },required: ["tempC"],},),})expect(description).toContain("tools.weather.current(input: {\n city: string,\n}): Promise<{\n tempC: number,\n summary?: string,\n}>",)})test("large catalogs inline a budgeted PARTIAL list plus runtime search", async () => {const tools: Record<string, MCP.McpTool> = {}const filler = "a searchable description of this operation that consumes catalog budget ".repeat(3)for (let i = 0; i < 150; i++) {tools[`alpha_op_${i}`] = {def: {name: `op_${i}`,description: `${filler}${i}`,inputSchema: { type: "object", properties: { value: { type: "string" }, count: { type: "number" } } },} as MCPToolDef,client: { callTool: async () => ({ content: [] }) } as unknown as MCP.McpTool["client"],}}tools["zeta_only_tool"] = mcpTool("only_tool", () => "", {type: "object",properties: { topic: { type: "string", description: "Subject to look up" } },required: ["topic"],})const description = describeFor(tools, ["alpha", "zeta"])expect(description).toContain("Available tools (PARTIAL - ")expect(description).toMatch(/- alpha \(150 tools, \d+ shown\)/)expect(description).toContain("- zeta (1 tool)\n")expect(description).toContain("tools.zeta.only_tool(input: {\n /** Subject to look up */\n topic: string,\n}): Promise<unknown>",)expect(description).toContain("tools.$codemode.search(")expect(description).toContain(" limit?: number,\n offset?: number,")expect(description).toContain(" remaining: number,\n next: {")expect(description).toContain(" offset: number,\n } | null,")expect(description).toContain('1. If needed, discover tools: `return await tools.$codemode.search({ query: "<intent + key nouns>" })`.',)expect(description).toContain('- Browse one namespace: `await tools.$codemode.search({ query: "", namespace: "<name>" })`.',)expect(description).not.toContain("total_count")expect(description).toContain("tools.alpha.op_0(")expect(description).not.toContain("tools.alpha.op_99(")const tool = await build(tools, ["alpha", "zeta"])const out = await Effect.runPromise(tool.execute({ code: "return await tools.$codemode.search({ query: 'only tool', limit: 3, offset: 0 })" }, ctx),)const result = JSON.parse(out.output)expect(result.items.map((i: any) => i.path)).toContain("tools.zeta.only_tool")expect(result).toMatchObject({ remaining: 0, next: null })expect(result.items[0].signature).toContain("tools.")const signature = result.items.find((i: any) => i.path === "tools.zeta.only_tool").signatureexpect(signature).toContain("tools.zeta.only_tool(input: {\n")expect(signature).toContain(" /** Subject to look up */\n topic: string")expect(description).toContain("/** Subject to look up */")expect(out.metadata.toolCalls).toEqual([{ tool: "$codemode.search", status: "completed", input: { query: "only tool", limit: 3, offset: 0 } },])})test("runs plain JavaScript and returns the value as text", async () => {const tool = await build({})const output = await Effect.runPromise(tool.execute({ code: "return 1 + 2" }, ctx))expect(output.output).toBe("3")expect(output.metadata.toolCalls).toEqual([])})test("Object.keys(tools) enumerates the MCP server and CodeMode namespaces", async () => {const tool = await build({github_list_issues: mcpTool("list_issues", () => ""),linear_search: mcpTool("search", () => ""),})const output = await Effect.runPromise(tool.execute({ code: "const namespaces = Object.keys(tools); return { namespaces, count: namespaces.length }" },ctx,),)expect(JSON.parse(output.output)).toEqual({ namespaces: ["github", "linear", "$codemode"], count: 3 })})test("calls a namespaced MCP tool and flows its text result back into the program", async () => {const seen: Record<string, unknown>[] = []const tool = await build({greeter_hello: mcpTool("hello", (args) => {seen.push(args)return { content: [{ type: "text", text: `hello ${args.name}` }] }}),})const output = await Effect.runPromise(tool.execute({ code: "const r = await tools.greeter.hello({ name: 'world' }); return r.toUpperCase()" }, ctx),)expect(seen).toEqual([{ name: "world" }])expect(output.output).toBe("HELLO WORLD")expect(output.metadata.toolCalls).toEqual([{ tool: "greeter.hello", status: "completed", input: { name: "world" } },])})test("exposes structured content as native data and composes multiple calls", async () => {const tool = await build({math_add: mcpTool("add", (args) => ({content: [],structuredContent: { sum: (args.a as number) + (args.b as number) },})),})const output = await Effect.runPromise(tool.execute({code: `const first = await tools.math.add({ a: 1, b: 2 })const second = await tools.math.add({ a: first.sum, b: 10 })return { total: second.sum }`,},ctx,),)expect(JSON.parse(output.output)).toEqual({ total: 13 })expect(output.metadata.toolCalls).toEqual([{ tool: "math.add", status: "completed", input: { a: 1, b: 2 } },{ tool: "math.add", status: "completed", input: { a: 3, b: 10 } },])})test("runs tool calls in parallel with Promise.all", async () => {const tool = await build({echo_one: mcpTool("one", () => ({ content: [{ type: "text", text: "1" }] })),echo_two: mcpTool("two", () => ({ content: [{ type: "text", text: "2" }] })),})const output = await Effect.runPromise(tool.execute({ code: "const [a, b] = await Promise.all([tools.echo.one({}), tools.echo.two({})]); return a + b" },ctx,),)expect(output.output).toBe("12")expect(output.metadata.toolCalls.map((c) => c.tool).sort()).toEqual(["echo.one", "echo.two"])expect(output.metadata.toolCalls.every((c) => c.status === "completed")).toBe(true)})test("a program failure fails the tool with a readable error", async () => {const tool = await build({})const error = await failure(tool.execute({ code: "throw new Error('boom')" }, ctx))expect(error.message).toBe("Uncaught: boom")})test("reports an unknown tool as a failed execution", async () => {const tool = await build({ known_tool: mcpTool("tool", () => "ok") })const error = await failure(tool.execute({ code: "return await tools.known.missing({})" }, ctx))expect(error.message).toContain("Unknown tool 'known.missing'")})test("propagates an MCP tool error into the program as a catchable failure", async () => {const tool = await build({bad_tool: mcpTool("tool", () => ({ isError: true, content: [{ type: "text", text: "server exploded" }] })),})const output = await Effect.runPromise(tool.execute({ code: "try { await tools.bad.tool({}) } catch (e) { return 'caught: ' + e.message }" }, ctx),)expect(output.output).toBe("caught: server exploded")})test("asks permission before each child tool call", async () => {const asked: unknown[] = []const permissionCtx: Tool.Context = { ...ctx, ask: (req) => Effect.sync(() => void asked.push(req)) }const ok = () => ({ content: [{ type: "text", text: "ok" }] })const tool = await build({ a_tool: mcpTool("a", ok), b_tool: mcpTool("b", ok) })await Effect.runPromise(tool.execute({ code: "await tools.a.tool({}); await tools.b.tool({}); return 'done'" }, permissionCtx),)expect(asked.map((req: any) => req.permission)).toEqual(["a_tool", "b_tool"])})test("a denied permission fails the child call with a catchable message, not the whole execute", async () => {const denyCtx: Tool.Context = { ...ctx, ask: () => Effect.die(new Error("permission denied by user")) }const called: string[] = []const tool = await build({a_tool: mcpTool("a", () => {called.push("a")return { content: [{ type: "text", text: "ok" }] }}),})const output = await Effect.runPromise(tool.execute({ code: "try { await tools.a.tool({}) } catch (e) { return 'denied: ' + e.message }" }, denyCtx),)expect(output.output).toBe("denied: permission denied by user")expect(output.metadata.error).toBeUndefined()expect(called).toEqual([])expect(output.metadata.toolCalls).toEqual([{ tool: "a.tool", status: "error" }])})test("child calls fire plugin tool.execute hooks with the MCP key and synthetic parent/N call ids", async () => {const events: { name: string; input: any; output: any }[] = []const trigger = ((name: unknown, input: unknown, output: unknown) =>Effect.sync(() => {events.push({ name: name as string, input, output })return output})) as Plugin.Interface["trigger"]const tool = await build({a_tool: mcpTool("a", () => ({ content: [{ type: "text", text: "one" }] })),b_tool: mcpTool("b", () => ({ content: [{ type: "text", text: "two" }] })),},undefined,undefined,trigger,)const out = await Effect.runPromise(tool.execute({ code: "await tools.a.tool({ x: 1 }); await tools.b.tool({}); return 'done'" }, ctx),)expect(out.output).toBe("done")expect(events.map((e) => [e.name, e.input.tool, e.input.callID])).toEqual([["tool.execute.before", "a_tool", "call_code_mode/1"],["tool.execute.after", "a_tool", "call_code_mode/1"],["tool.execute.before", "b_tool", "call_code_mode/2"],["tool.execute.after", "b_tool", "call_code_mode/2"],])const [before, after] = eventsexpect(before!.input.sessionID).toBe(ctx.sessionID)expect(before!.output).toEqual({ args: { x: 1 } })expect(after!.input.args).toEqual({ x: 1 })expect(after!.output).toEqual({ content: [{ type: "text", text: "one" }] })})test("a failing before hook fails only that child call as a catchable in-program error", async () => {const trigger = ((name: unknown, input: any, output: unknown) => {if (name === "tool.execute.before" && input.tool === "a_tool") return Effect.die(new Error("hook exploded"))return Effect.succeed(output)}) as Plugin.Interface["trigger"]const called: string[] = []const record = (name: string) => () => {called.push(name)return { content: [{ type: "text", text: "ok" }] }}const tool = await build({ a_tool: mcpTool("a", record("a")), b_tool: mcpTool("b", record("b")) },undefined,undefined,trigger,)const out = await Effect.runPromise(tool.execute({code: `let caughttry { await tools.a.tool({}) } catch (e) { caught = e.message }const r = await tools.b.tool({})return caught + " / " + r`,},ctx,),)expect(out.metadata.error).toBeUndefined()expect(out.output).toBe("hook exploded / ok")expect(called).toEqual(["b"])})test("streams live per-call metadata as a call starts and finishes", async () => {const snapshots: Array<{ toolCalls: { tool: string; status: string; input?: Record<string, unknown> }[] }> = []const recordingCtx: Tool.Context = {...ctx,metadata: (val: any) => Effect.sync(() => void snapshots.push(val.metadata)),}const tool = await build({ greeter_hello: mcpTool("hello", () => ({ content: [{ type: "text", text: "hi" }] })) })await Effect.runPromise(tool.execute({ code: "await tools.greeter.hello({ name: 'Ada' }); return 'done'" }, recordingCtx),)expect(snapshots).toContainEqual({toolCalls: [{ tool: "greeter.hello", status: "running", input: { name: "Ada" } }],})expect(snapshots).toContainEqual({toolCalls: [{ tool: "greeter.hello", status: "completed", input: { name: "Ada" } }],})})test("marks a failed child call as error in the live metadata", async () => {const snapshots: Array<{ toolCalls: { tool: string; status: string; input?: Record<string, unknown> }[] }> = []const recordingCtx: Tool.Context = {...ctx,metadata: (val: any) => Effect.sync(() => void snapshots.push(val.metadata)),}const tool = await build({bad_tool: mcpTool("tool", () => ({ isError: true, content: [{ type: "text", text: "boom" }] })),})await Effect.runPromise(tool.execute({ code: "try { await tools.bad.tool({ reason: 'test' }) } catch (e) { return 'caught' }" },recordingCtx,),)expect(snapshots).toContainEqual({ toolCalls: [{ tool: "bad.tool", status: "error", input: { reason: "test" } }] })})test("accumulates stripped media as execute attachments the sandbox never sees", async () => {const tool = await build({shot_take: mcpTool("take", () => ({content: [{ type: "image", data: "PNGDATA", mimeType: "image/png" }],structuredContent: { name: "shot.png" },})),})const out = await Effect.runPromise(tool.execute({ code: "return await tools.shot.take({})" }, ctx))expect(JSON.parse(out.output)).toEqual({ name: "shot.png" })expect(out.attachments).toEqual([{ type: "file", mime: "image/png", url: "data:image/png;base64,PNGDATA" }])expect(out.output).not.toContain("PNGDATA")})test("a media-only result returns a text marker so the program knows it succeeded", async () => {const tool = await build({shot_take: mcpTool("take", () => ({ content: [{ type: "image", data: "PNGDATA", mimeType: "image/png" }] })),})const out = await Effect.runPromise(tool.execute({ code: "return await tools.shot.take({})" }, ctx))expect(out.output).toBe("[1 image attached to the result]")expect(out.attachments).toEqual([{ type: "file", mime: "image/png", url: "data:image/png;base64,PNGDATA" }])})test("media-only markers distinguish all-image from mixed attachments", async () => {const tool = await build({media_images: mcpTool("images", () => ({content: [{ type: "image", data: "PNG1", mimeType: "image/png" },{ type: "image", data: "PNG2", mimeType: "image/png" },],})),media_mixed: mcpTool("mixed", () => ({content: [{ type: "image", data: "PNG3", mimeType: "image/png" },{ type: "resource", resource: { uri: "file:///tmp/report.pdf", mimeType: "application/pdf", blob: "PDF1" } },],})),})const out = await Effect.runPromise(tool.execute({code: `const images = await tools.media.images({})const mixed = await tools.media.mixed({})return { images, mixed }`,},ctx,),)expect(JSON.parse(out.output)).toEqual({images: "[2 images attached to the result]",mixed: "[2 files attached to the result]",})expect(out.output).not.toContain("PNG")expect(out.attachments).toEqual([{ type: "file", mime: "image/png", url: "data:image/png;base64,PNG1" },{ type: "file", mime: "image/png", url: "data:image/png;base64,PNG2" },{ type: "file", mime: "image/png", url: "data:image/png;base64,PNG3" },{ type: "file", mime: "application/pdf", url: "data:application/pdf;base64,PDF1", filename: "report.pdf" },])})test("resource links flow to the program as text, never as attachments", async () => {const tool = await build({docs_find: mcpTool("find", () => ({content: [{type: "resource_link",uri: "https://example.com/guide.pdf",name: "guide.pdf",mimeType: "application/pdf",},{ type: "resource_link", uri: "file:///tmp/notes.md", name: "notes.md" },],})),})const out = await Effect.runPromise(tool.execute({ code: "return await tools.docs.find({})" }, ctx))expect(out.output).toBe("guide.pdf: https://example.com/guide.pdf\nnotes.md: file:///tmp/notes.md")expect(out.attachments).toBeUndefined()})test("attachments still flow when the program returns something else entirely", async () => {const tool = await build({shot_take: mcpTool("take", () => ({ content: [{ type: "image", data: "PNGDATA", mimeType: "image/png" }] })),})const out = await Effect.runPromise(tool.execute({ code: "await tools.shot.take({}); return 'captured'" }, ctx))expect(out.output).toBe("captured")expect(out.attachments).toHaveLength(1)})test("isolates the sandbox from host globals", async () => {const tool = await build({})const error = await failure(tool.execute({ code: "return process.env" }, ctx))expect(error.message).toContain("process")})test("cancelling via ctx.abort interrupts the running program", async () => {const controller = new AbortController()const tool = await build({host_trigger: mcpTool("trigger", () => {controller.abort()return new Promise(() => {})}),})const output = await Effect.runPromise(tool.execute({ code: "try { await tools.host.trigger({}) } catch {} while (true) {}" },{ ...ctx, abort: controller.signal },),)expect(output.output).toBe("Execution cancelled.")expect(output.metadata.error).toBe(true)expect(output.metadata.toolCalls).toEqual([{ tool: "host.trigger", status: "running" }])})test("a pre-aborted signal cancels before the program runs", async () => {const controller = new AbortController()controller.abort()const ran: string[] = []const tool = await build({ host_touch: mcpTool("touch", () => (ran.push("called"), "ok")) })const output = await Effect.runPromise(tool.execute({ code: "return await tools.host.touch({})" }, { ...ctx, abort: controller.signal }),)expect(output.output).toBe("Execution cancelled.")expect(ran).toEqual([])})test("leaves oversized results to OpenCode's native tool-output truncation", async () => {const tool = await build({})const output = await Effect.runPromise(tool.execute({ code: "return 'x'.repeat(40000)" }, ctx))expect(output.metadata.error).toBeUndefined()expect(output.output).not.toContain("[result truncated:")expect(output.output.length).toBeGreaterThanOrEqual(40_000)})test("appends logs after the result on success and after the message on error", async () => {const tool = await build({})const ok = await Effect.runPromise(tool.execute({ code: "console.log('step one'); console.warn('careful'); return 'done'" }, ctx),)expect(ok.output).toBe("done\n\nLogs:\nstep one\n[warn] careful")const error = await failure(tool.execute({ code: "console.log('before the throw'); throw new Error('boom')" }, ctx))expect(error.message).toContain("Uncaught: boom")expect(error.message).toContain("Logs:\nbefore the throw")})})describe("code mode permission visibility", () => {const deny = (permission: string): PermissionV1.Rule => ({ permission, pattern: "*", action: "deny" })const askRule = (permission: string): PermissionV1.Rule => ({ permission, pattern: "*", action: "ask" })const ok = () => ({ content: [{ type: "text", text: "ok" }] })test("a hard-denied tool never enters the catalog or its search index", () => {const mcpTools = {github_create_issue: mcpTool("create_issue", ok),github_list_issues: mcpTool("list_issues", ok),}const description = describeFor(mcpTools, ["github"], [deny("github_create_issue")])expect(description).toContain("tools.github.list_issues(")expect(description).not.toContain("create_issue")expect(description).toContain("- github (1 tool)")})test("an ask-level tool stays fully visible in the catalog", () => {const mcpTools = {github_create_issue: mcpTool("create_issue", ok),github_list_issues: mcpTool("list_issues", ok),}const description = describeFor(mcpTools, ["github"], [askRule("github_create_issue")])expect(description).toContain("tools.github.create_issue(")expect(description).toContain("tools.github.list_issues(")expect(description).toContain("- github (2 tools)")})test("a hard-denied tool is not dispatchable: the program gets the unknown-tool diagnostic", async () => {const called: string[] = []const tool = await build({github_create_issue: mcpTool("create_issue", () => {called.push("create_issue")return ok()}),github_list_issues: mcpTool("list_issues", ok),},["github"],[deny("github_create_issue")],)const denied = await failure(tool.execute({ code: "return await tools.github.create_issue({ title: 'x' })" }, ctx))expect(denied.message).toContain("Unknown tool 'github.create_issue'")expect(denied.message).not.toContain("permission")expect(called).toEqual([])const allowed = await Effect.runPromise(tool.execute({ code: "return await tools.github.list_issues({})" }, ctx))expect(allowed.metadata.error).toBeUndefined()expect(allowed.output).toBe("ok")})test("an ask-level tool remains callable and still prompts via ctx.ask", async () => {const asked: string[] = []const askCtx: Tool.Context = { ...ctx, ask: (req) => Effect.sync(() => void asked.push(req.permission)) }const tool = await build({ github_list_issues: mcpTool("list_issues", ok) },["github"],[askRule("github_list_issues")],)const out = await Effect.runPromise(tool.execute({ code: "return await tools.github.list_issues({})" }, askCtx))expect(out.output).toBe("ok")expect(asked).toEqual(["github_list_issues"])})test("Permission.visibleTools hides only hard denies, matching Permission.disabled", () => {const tools = { a_tool: 1, b_tool: 2, c_tool: 3 }const visible = Permission.visibleTools(tools, [deny("a_tool"),askRule("b_tool"),{ permission: "c_tool", pattern: "something", action: "deny" },])expect(Object.keys(visible)).toEqual(["b_tool", "c_tool"])})})