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").signature

expect(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] = events

expect(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 caught

try { 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"])

})

})