[Init] Initial commit - NetMesh terminal manager

electron/bridges/aiBridge/sdk/codebuddyDriver.test.cjs

@@ -0,0 +1,881 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { getEventListeners } = require("node:events");
+const {
+  buildCodebuddyQueryOptions,
+  buildCodebuddyCanUseTool,
+  buildCodebuddyPromptInput,
+  codebuddyBuiltinTools,
+  mapCodebuddyModels,
+  runCodebuddyTurn,
+  translateCodebuddyMessage,
+  buildCodebuddyHooks,
+  buildCodebuddyElicitation,
+  toSdkMcpServers,
+} = require("./codebuddyDriver.cjs");
+
+function collector() {
+  const events = [];
+  const emitter = {
+    text: (t) => events.push({ k: "text", t }),
+    reasoning: (d) => events.push({ k: "reasoning", d }),
+    toolCall: (name, args, id) => events.push({ k: "toolCall", name, args, id }),
+    toolResult: (id, out, name) => events.push({ k: "toolResult", id, out, name }),
+    usage: (usage) => events.push({ k: "usage", usage }),
+    status: (m) => events.push({ k: "status", m }),
+    sessionId: (s) => events.push({ k: "sessionId", s }),
+    emitDone: () => events.push({ k: "done" }),
+    emitError: (m) => events.push({ k: "error", m }),
+  };
+  return { events, emitter };
+}
+
+test("buildCodebuddyQueryOptions wires SDK options in isolated mode", () => {
+  const ac = new AbortController();
+  const opts = buildCodebuddyQueryOptions({
+    cwd: "/tmp",
+    model: "codebuddy-1",
+    env: { PATH: "/usr/bin", CODEBUDDY_INTERNET_ENVIRONMENT: "ioa" },
+    pathToCodebuddyCode: "/opt/codebuddy/bin/codebuddy",
+    abortController: ac,
+    resume: "sess-1",
+    injectedMcpServers: [{
+      name: "netcatty-remote-hosts",
+      command: "/abs/electron",
+      args: ["/abs/server.cjs"],
+      env: [{ name: "NETCATTY_MCP_PORT", value: "1" }],
+    }],
+  });
+
+  assert.equal(opts.cwd, "/tmp");
+  assert.equal(opts.model, "codebuddy-1");
+  assert.equal(opts.includePartialMessages, true);
+  assert.equal(opts.permissionMode, "bypassPermissions");
+  assert.equal(opts.allowDangerouslySkipPermissions, true);
+  assert.deepEqual(opts.extraArgs, { "dangerously-skip-permissions": null });
+  assert.deepEqual(opts.settingSources, []);
+  assert.equal(opts.env.CODEBUDDY_INTERNET_ENVIRONMENT, "ioa");
+  assert.equal(opts.pathToCodebuddyCode, "/opt/codebuddy/bin/codebuddy");
+  assert.equal(opts.abortController, ac);
+  assert.equal(opts.resume, "sess-1");
+  assert.deepEqual(opts.tools, []);
+  // allowedTools must stay unset in mcp mode: tools:[] disables built-ins, while
+  // allowedTools:[] would prevent injected Netcatty MCP tools from running.
+  assert.ok(!("allowedTools" in opts));
+  assert.ok(opts.disallowedTools.includes("AskUserQuestion"));
+  assert.equal(opts.mcpServers["netcatty-remote-hosts"].type, "stdio");
+  assert.deepEqual(opts.mcpServers["netcatty-remote-hosts"].env, { NETCATTY_MCP_PORT: "1" });
+});
+
+test("built-in tools are mode-aware", () => {
+  assert.deepEqual(codebuddyBuiltinTools("mcp"), []);
+  assert.deepEqual(codebuddyBuiltinTools(undefined), []);
+  assert.deepEqual(codebuddyBuiltinTools("skills"), ["Bash"]);
+});
+
+test("translateCodebuddyMessage emits assistant text fallback", () => {
+  const { events, emitter } = collector();
+  translateCodebuddyMessage(
+    { type: "assistant", message: { content: [{ type: "text", text: "hello" }] } },
+    emitter,
+  );
+  assert.deepEqual(events, [{ k: "text", t: "hello" }]);
+});
+
+test("translateCodebuddyMessage can skip consolidated assistant text after stream deltas", () => {
+  const { events, emitter } = collector();
+  translateCodebuddyMessage(
+    { type: "assistant", message: { content: [{ type: "text", text: "consolidated" }] } },
+    emitter,
+    { skipAssistantText: true },
+  );
+  assert.deepEqual(events, []);
+});
+
+test("translateCodebuddyMessage preserves consolidated reasoning without deltas", () => {
+  const { events, emitter } = collector();
+  translateCodebuddyMessage(
+    {
+      type: "assistant",
+      message: { content: [{ type: "thinking", thinking: "check the fallback" }] },
+    },
+    emitter,
+  );
+  assert.deepEqual(events, [{ k: "reasoning", d: "check the fallback" }]);
+});
+
+test("translateCodebuddyMessage maps stream deltas, tool calls, and tool results", () => {
+  const { events, emitter } = collector();
+  translateCodebuddyMessage(
+    { type: "stream_event", event: { type: "content_block_delta", delta: { type: "text_delta", text: "hi" } } },
+    emitter,
+  );
+  translateCodebuddyMessage(
+    { type: "stream_event", event: { type: "content_block_delta", delta: { type: "thinking_delta", thinking: "why" } } },
+    emitter,
+  );
+  translateCodebuddyMessage(
+    { type: "assistant", message: { content: [{ type: "tool_use", id: "tu-1", name: "Bash", input: { command: "ls" } }] } },
+    emitter,
+  );
+  translateCodebuddyMessage(
+    { type: "user", message: { content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }] } },
+    emitter,
+  );
+  assert.deepEqual(events, [
+    { k: "text", t: "hi" },
+    { k: "reasoning", d: "why" },
+    { k: "toolCall", name: "Bash", args: { command: "ls" }, id: "tu-1" },
+    { k: "toolResult", id: "tu-1", out: "ok", name: undefined },
+  ]);
+});
+
+test("translateCodebuddyMessage emits system session id and status text", () => {
+  const { events, emitter } = collector();
+  translateCodebuddyMessage(
+    { type: "system", session_id: "sess-1", message: "initializing" },
+    emitter,
+  );
+  assert.deepEqual(events, [
+    { k: "sessionId", s: "sess-1" },
+    { k: "status", m: "initializing" },
+  ]);
+});
+
+test("runCodebuddyTurn preserves explicit SDK error messages", async () => {
+  const { events, emitter } = collector();
+  async function* fakeQuery() {
+    yield {
+      type: "error",
+      session_id: "sess-error",
+      error: "Provider quota exceeded",
+    };
+  }
+
+  const result = await runCodebuddyTurn({
+    prompt: "hello",
+    options: { abortController: new AbortController() },
+    emitter,
+    queryFn: fakeQuery,
+  });
+
+  assert.deepEqual(result, { sessionId: "sess-error" });
+  assert.deepEqual(events, [{ k: "error", m: "Provider quota exceeded" }]);
+});
+
+test("translateCodebuddyMessage emits actual result usage", () => {
+  const { events, emitter } = collector();
+  const result = translateCodebuddyMessage({
+    type: "result",
+    subtype: "success",
+    is_error: false,
+    num_turns: 1,
+    total_cost_usd: 0,
+    usage: {
+      input_tokens: 321,
+      output_tokens: 45,
+      cache_read_input_tokens: 100,
+      cache_creation_input_tokens: 20,
+    },
+  }, emitter);
+
+  assert.deepEqual(result, { terminalError: false });
+  assert.deepEqual(events, [
+    {
+      k: "usage",
+      usage: {
+        inputTokens: 441,
+        cachedInputTokens: 100,
+        outputTokens: 45,
+        totalTokens: 486,
+      },
+    },
+    { k: "status", m: "CodeBuddy: 1 turns" },
+  ]);
+});
+
+test("runCodebuddyTurn reports terminal result subtypes instead of an auth error", async () => {
+  const { events, emitter } = collector();
+  async function* fakeQuery() {
+    yield {
+      type: "result",
+      subtype: "error_max_budget_usd",
+      is_error: true,
+      num_turns: 2,
+      total_cost_usd: 1,
+      usage: { input_tokens: 10, output_tokens: 2 },
+      permission_denials: [],
+    };
+  }
+
+  await runCodebuddyTurn({
+    prompt: "spend",
+    options: { abortController: new AbortController() },
+    emitter,
+    queryFn: () => fakeQuery(),
+  });
+
+  assert.deepEqual(events, [
+    {
+      k: "usage",
+      usage: {
+        inputTokens: 10,
+        cachedInputTokens: 0,
+        outputTokens: 2,
+        totalTokens: 12,
+      },
+    },
+    { k: "status", m: "CodeBuddy: 2 turns, $1.0000" },
+    { k: "error", m: "CodeBuddy stopped after reaching the configured budget limit." },
+  ]);
+});
+
+test("runCodebuddyTurn renders a successful result fallback when no text delta arrives", async () => {
+  const { events, emitter } = collector();
+  async function* fakeQuery() {
+    yield {
+      type: "stream_event",
+      event: { type: "message_start", message: { content: [] } },
+    };
+    yield {
+      type: "result",
+      subtype: "success",
+      is_error: false,
+      num_turns: 1,
+      result: "fallback answer",
+      total_cost_usd: 0,
+      usage: { input_tokens: 4, output_tokens: 2 },
+      permission_denials: [],
+    };
+  }
+
+  await runCodebuddyTurn({
+    prompt: "answer",
+    options: { abortController: new AbortController() },
+    emitter,
+    queryFn: () => fakeQuery(),
+  });
+
+  assert.deepEqual(events, [
+    {
+      k: "usage",
+      usage: {
+        inputTokens: 4,
+        cachedInputTokens: 0,
+        outputTokens: 2,
+        totalTokens: 6,
+      },
+    },
+    { k: "status", m: "CodeBuddy: 1 turns" },
+    { k: "text", t: "fallback answer" },
+    { k: "done" },
+  ]);
+});
+
+test("runCodebuddyTurn does not duplicate assistant text after streamed text", async () => {
+  const { events, emitter } = collector();
+  async function* fakeQuery() {
+    yield { type: "system", session_id: "sess-1" };
+    yield { type: "stream_event", event: { type: "content_block_delta", delta: { type: "text_delta", text: "hello" } } };
+    yield { type: "assistant", message: { content: [{ type: "text", text: "hello" }] } };
+  }
+
+  const result = await runCodebuddyTurn({
+    prompt: "say hi",
+    options: { abortController: new AbortController() },
+    emitter,
+    queryFn: () => fakeQuery(),
+  });
+
+  assert.deepEqual(result, { sessionId: "sess-1" });
+  assert.deepEqual(events, [
+    { k: "sessionId", s: "sess-1" },
+    { k: "text", t: "hello" },
+    { k: "done" },
+  ]);
+});
+
+test("runCodebuddyTurn interrupts the SDK query as soon as abort is signaled", async () => {
+  const events = [];
+  let sawSession;
+  const sessionSeen = new Promise((resolve) => { sawSession = resolve; });
+  const emitter = {
+    text: (t) => events.push({ k: "text", t }),
+    reasoning: (d) => events.push({ k: "reasoning", d }),
+    toolCall: (name, args, id) => events.push({ k: "toolCall", name, args, id }),
+    toolResult: (id, out, name) => events.push({ k: "toolResult", id, out, name }),
+    status: (m) => events.push({ k: "status", m }),
+    sessionId: (s) => { events.push({ k: "sessionId", s }); sawSession(); },
+    emitDone: () => events.push({ k: "done" }),
+    emitError: (m) => events.push({ k: "error", m }),
+  };
+  const ac = new AbortController();
+  let interruptCount = 0;
+  let release;
+
+  const fakeQuery = () => ({
+    interrupt: async () => { interruptCount += 1; release?.(); },
+    async *[Symbol.asyncIterator]() {
+      yield { type: "system", session_id: "sess-1" };
+      await new Promise((resolve) => { release = resolve; });
+    },
+  });
+
+  const turn = runCodebuddyTurn({
+    prompt: "wait",
+    options: { abortController: ac },
+    emitter,
+    queryFn: fakeQuery,
+  });
+
+  await sessionSeen;
+  ac.abort();
+  const result = await turn;
+
+  assert.deepEqual(result, { sessionId: "sess-1" });
+  assert.ok(interruptCount >= 1);
+  assert.deepEqual(events, [
+    { k: "sessionId", s: "sess-1" },
+    { k: "done" },
+  ]);
+});
+
+test("runCodebuddyTurn treats an abort rejection as normal completion", async () => {
+  const ac = new AbortController();
+  let rejectStream;
+  const fakeQuery = () => ({
+    async *[Symbol.asyncIterator]() {
+      yield { type: "system", session_id: "sess-abort" };
+      await new Promise((_resolve, reject) => {
+        rejectStream = reject;
+      });
+    },
+    async interrupt() {
+      rejectStream?.(new Error("interrupted"));
+    },
+  });
+  const { events, emitter } = collector();
+
+  const turn = runCodebuddyTurn({
+    prompt: "wait",
+    options: { abortController: ac },
+    emitter,
+    queryFn: fakeQuery,
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  ac.abort();
+
+  assert.deepEqual(await turn, { sessionId: "sess-abort" });
+  assert.deepEqual(events, [
+    { k: "sessionId", s: "sess-abort" },
+    { k: "done" },
+  ]);
+});
+
+test("runCodebuddyTurn does not start the legacy CLI after an early abort", async () => {
+  const { events, emitter } = collector();
+  const abortController = new AbortController();
+  abortController.abort();
+  let queryCalls = 0;
+
+  const result = await runCodebuddyTurn({
+    prompt: "hello",
+    attachments: [],
+    options: { abortController },
+    emitter,
+    queryFn() {
+      queryCalls += 1;
+      throw new Error("must not start");
+    },
+  });
+
+  assert.equal(queryCalls, 0);
+  assert.deepEqual(result, { sessionId: null });
+  assert.deepEqual(events, [{ k: "done" }]);
+});
+
+test("buildCodebuddyPromptInput sends supported images as native image blocks", async () => {
+  const input = buildCodebuddyPromptInput("describe this", [
+    { filename: "shot.png", mediaType: "image/png", filePath: "/tmp/shot.png", base64Data: "abc" },
+    { filename: "bad.svg", mediaType: "image/svg+xml", filePath: "/tmp/bad.svg", base64Data: "def" },
+  ]);
+  const messages = [];
+  for await (const message of input) messages.push(message);
+  assert.deepEqual(messages, [{
+    type: "user",
+    message: {
+      role: "user",
+      content: [
+        { type: "text", text: "describe this" },
+        { type: "image", source: { type: "base64", media_type: "image/png", data: "abc" } },
+      ],
+    },
+    parent_tool_use_id: null,
+  }]);
+});
+
+test("mapCodebuddyModels maps model ids and drops invalid entries", () => {
+  assert.deepEqual(mapCodebuddyModels([
+    // Real CLI wire shape ({id,name}) — must NOT be dropped.
+    { id: "glm-5.1", name: "GLM-5.1" },
+    { modelId: "cb-1", name: "CodeBuddy 1", description: "default" },
+    { value: "cb-2", displayName: "CodeBuddy 2" },
+    { name: "missing id" },
+  ]), [
+    {
+      id: "glm-5.1",
+      name: "GLM-5.1",
+      description: undefined,
+      thinkingLevels: ["low", "medium", "high", "xhigh"],
+      defaultThinkingLevel: "medium",
+      encodeDefaultThinking: false,
+    },
+    {
+      id: "cb-1",
+      name: "CodeBuddy 1",
+      description: "default",
+      thinkingLevels: ["low", "medium", "high", "xhigh"],
+      defaultThinkingLevel: "medium",
+      encodeDefaultThinking: false,
+    },
+    {
+      id: "cb-2",
+      name: "CodeBuddy 2",
+      description: undefined,
+      thinkingLevels: ["low", "medium", "high", "xhigh"],
+      defaultThinkingLevel: "medium",
+      encodeDefaultThinking: false,
+    },
+  ]);
+  assert.deepEqual(mapCodebuddyModels(null), []);
+});
+
+// ---------------------------------------------------------------------------
+// SDK 0.3.230 options
+// ---------------------------------------------------------------------------
+
+test("buildCodebuddyQueryOptions passes SDK 0.3.230 options", () => {
+  const opts = buildCodebuddyQueryOptions({
+    cwd: "/tmp",
+    env: {},
+    systemPrompt: "You are a server admin assistant.",
+    effort: "high",
+    maxTurns: 10,
+    maxBudgetUsd: 0.5,
+    fallbackModel: "glm-4",
+    sandbox: { enabled: true, autoAllowBashIfSandboxed: true },
+    agents: { auditor: { description: "Security auditor", prompt: "Audit", tools: ["Bash"] } },
+    outputFormat: { type: "json_schema", schema: { type: "object" } },
+    enableFileCheckpointing: true,
+    traceId: "trace-123",
+    parentSpanId: "span-456",
+    persistSession: false,
+    sessionId: "custom-sess",
+  });
+
+  assert.deepEqual(opts.systemPrompt, { append: "You are a server admin assistant." });
+  assert.equal(opts.effort, "high");
+  assert.equal(opts.maxTurns, 10);
+  assert.equal(opts.maxBudgetUsd, 0.5);
+  assert.equal(opts.fallbackModel, "glm-4");
+  assert.deepEqual(opts.sandbox, { enabled: true, autoAllowBashIfSandboxed: true });
+  assert.deepEqual(opts.agents, { auditor: { description: "Security auditor", prompt: "Audit", tools: ["Bash"] } });
+  assert.deepEqual(opts.outputFormat, { type: "json_schema", schema: { type: "object" } });
+  assert.equal(opts.enableFileCheckpointing, true);
+  assert.equal(opts.traceId, "trace-123");
+  assert.equal(opts.parentSpanId, "span-456");
+  assert.equal(opts.persistSession, false);
+  assert.equal(opts.sessionId, "custom-sess");
+});
+
+test("buildCodebuddyQueryOptions does not set maxThinkingTokens (deprecated removed)", () => {
+  const opts = buildCodebuddyQueryOptions({
+    cwd: "/tmp",
+    env: { NETCATTY_CODEBUDDY_THINKING: "enabled:8000" },
+  });
+  assert.deepEqual(opts.thinking, { type: "enabled", budgetTokens: 8000 });
+  assert.ok(!("maxThinkingTokens" in opts));
+});
+
+test("buildCodebuddyQueryOptions splits model/effort and prefers it over settings effort", () => {
+  const fromModel = buildCodebuddyQueryOptions({
+    cwd: "/tmp",
+    model: "glm-5.1/high",
+    effort: "low",
+  });
+  assert.equal(fromModel.model, "glm-5.1");
+  assert.equal(fromModel.effort, "high");
+
+  const fromSettings = buildCodebuddyQueryOptions({
+    cwd: "/tmp",
+    model: "glm-5.1",
+    effort: "low",
+  });
+  assert.equal(fromSettings.model, "glm-5.1");
+  assert.equal(fromSettings.effort, "low");
+});
+
+test("buildCodebuddyQueryOptions drops invalid numeric guardrails", () => {
+  const fractionalTurns = buildCodebuddyQueryOptions({
+    maxTurns: 1.5,
+    maxBudgetUsd: Number.POSITIVE_INFINITY,
+  });
+  assert.equal(fractionalTurns.maxTurns, undefined);
+  assert.equal(fractionalTurns.maxBudgetUsd, undefined);
+
+  const valid = buildCodebuddyQueryOptions({
+    maxTurns: 2,
+    maxBudgetUsd: 0.25,
+  });
+  assert.equal(valid.maxTurns, 2);
+  assert.equal(valid.maxBudgetUsd, 0.25);
+});
+
+test("buildCodebuddyQueryOptions drops disabled or malformed advanced options", () => {
+  const opts = buildCodebuddyQueryOptions({
+    cwd: "/tmp",
+    effort: "ultra",
+    fallbackModel: { id: "fallback" },
+    sandbox: { enabled: false },
+    enableFileCheckpointing: false,
+  });
+
+  assert.equal(opts.effort, undefined);
+  assert.equal(opts.fallbackModel, undefined);
+  assert.equal(opts.sandbox, undefined);
+  assert.equal(opts.enableFileCheckpointing, undefined);
+});
+
+test("buildCodebuddyQueryOptions accepts object systemPrompt directly", () => {
+  const opts = buildCodebuddyQueryOptions({
+    cwd: "/tmp",
+    env: {},
+    systemPrompt: { append: "custom append" },
+  });
+  assert.deepEqual(opts.systemPrompt, { append: "custom append" });
+});
+
+// ---------------------------------------------------------------------------
+// Hooks
+// ---------------------------------------------------------------------------
+
+test("buildCodebuddyHooks returns hook matchers that emit events", async () => {
+  const { events, emitter } = collector();
+  emitter.emitEvent = (ev) => events.push({ k: "event", ev });
+  const hooks = buildCodebuddyHooks(emitter);
+
+  assert.ok(Array.isArray(hooks.PreToolUse));
+  assert.ok(Array.isArray(hooks.PostToolUse));
+  assert.ok(Array.isArray(hooks.PostToolUseFailure));
+  assert.ok(Array.isArray(hooks.SessionEnd));
+  assert.ok(Array.isArray(hooks.Notification));
+
+  // Invoke PreToolUse hook callback
+  const preHook = hooks.PreToolUse[0].hooks[0];
+  const result = await preHook(
+    { tool_name: "Bash", tool_input: { command: "ls" }, tool_use_id: "tu-1" },
+    "tu-1",
+    { signal: new AbortController().signal },
+  );
+  assert.deepEqual(result, { continue: true });
+  assert.equal(events.length, 1);
+  assert.equal(events[0].ev.hookEvent, "PreToolUse");
+  assert.equal(events[0].ev.toolName, "Bash");
+});
+
+test("buildCodebuddyHooks blocks non-Netcatty Bash commands in skills mode", async () => {
+  const { emitter } = collector();
+  emitter.emitEvent = () => {};
+  const hooks = buildCodebuddyHooks(emitter, {
+    toolIntegrationMode: "skills",
+    allowedCliCommandPrefix: "netcatty-tool-cli",
+  });
+  const preHook = hooks.PreToolUse[0].hooks[0];
+
+  assert.deepEqual(
+    await preHook(
+      { tool_name: "Bash", tool_input: { command: "ls -la" }, tool_use_id: "tu-local" },
+      "tu-local",
+      { signal: new AbortController().signal },
+    ),
+    {
+      continue: true,
+      decision: "block",
+      reason:
+        "Only Netcatty CLI commands are allowed in Skills mode. " +
+        "Use the netcatty-tool-cli command prefix provided by the host.",
+    },
+  );
+  assert.deepEqual(
+    await preHook(
+      {
+        tool_name: "Bash",
+        tool_input: {
+          command: "netcatty-tool-cli session --session s1 --chat-session c1 --json",
+        },
+        tool_use_id: "tu-cli",
+      },
+      "tu-cli",
+      { signal: new AbortController().signal },
+    ),
+    { continue: true },
+  );
+  assert.equal(
+    (await preHook(
+      {
+        tool_name: "Bash",
+        tool_input: {
+          command: "/tmp/netcatty-tool-cli status --json",
+        },
+        tool_use_id: "tu-impostor",
+      },
+      "tu-impostor",
+      { signal: new AbortController().signal },
+    )).decision,
+    "block",
+  );
+  assert.equal(
+    (await preHook(
+      {
+        tool_name: "Bash",
+        tool_input: {
+          command: "netcatty-tool-cli status --json",
+          run_in_background: true,
+        },
+        tool_use_id: "tu-background",
+      },
+      "tu-background",
+      { signal: new AbortController().signal },
+    )).decision,
+    "block",
+  );
+});
+
+test("buildCodebuddyHooks retains caller-provided lifecycle hooks", () => {
+  const { emitter } = collector();
+  emitter.emitEvent = () => {};
+  const custom = { hooks: [async () => ({ continue: true })] };
+  const hooks = buildCodebuddyHooks(emitter, {
+    toolIntegrationMode: "skills",
+    additionalHooks: { PreToolUse: [custom] },
+  });
+
+  assert.equal(hooks.PreToolUse.length, 2);
+  assert.equal(hooks.PreToolUse[1], custom);
+});
+
+// ---------------------------------------------------------------------------
+// Elicitation
+// ---------------------------------------------------------------------------
+
+test("buildCodebuddyElicitation forwards create and resolves on response", async () => {
+  const { events, emitter } = collector();
+  emitter.emitEvent = (ev) => events.push({ k: "event", ev });
+  const pendingMap = new Map();
+  const handler = buildCodebuddyElicitation(emitter, pendingMap);
+  const controller = new AbortController();
+
+  const createPromise = handler.create(
+    { _meta: { "codebuddy.ai": { elicitationId: "el-1" } }, message: "Confirm?" },
+    { signal: controller.signal },
+  );
+
+  // Should have emitted elicitation-create event
+  assert.equal(events.length, 1);
+  assert.equal(events[0].ev.type, "elicitation-create");
+  assert.equal(events[0].ev.elicitationId, "el-1");
+
+  // Resolve the pending elicitation
+  assert.ok(pendingMap.has("el-1"));
+  pendingMap.get("el-1").resolve({ action: "accept", content: { confirmed: true } });
+  const response = await createPromise;
+  assert.deepEqual(response, { action: "accept", content: { confirmed: true } });
+  assert.equal(pendingMap.size, 0);
+  assert.equal(getEventListeners(controller.signal, "abort").length, 0);
+});
+
+test("buildCodebuddyElicitation cancels immediately for an aborted signal", async () => {
+  const { events, emitter } = collector();
+  emitter.emitEvent = (ev) => events.push({ k: "event", ev });
+  const pendingMap = new Map();
+  const handler = buildCodebuddyElicitation(emitter, pendingMap);
+  const controller = new AbortController();
+  controller.abort();
+
+  const response = await handler.create(
+    { _meta: { "codebuddy.ai": { elicitationId: "el-aborted" } } },
+    { signal: controller.signal },
+  );
+
+  assert.deepEqual(response, { action: "cancel" });
+  assert.equal(pendingMap.size, 0);
+  assert.equal(events.length, 0);
+});
+
+test("buildCodebuddyElicitation tags pendings with chatSessionId and uses UUID fallback ids", async () => {
+  const { events, emitter } = collector();
+  emitter.emitEvent = (ev) => events.push({ k: "event", ev });
+  const pendingMap = new Map();
+  const handler = buildCodebuddyElicitation(emitter, pendingMap, { chatSessionId: "chat-1" });
+
+  // No _meta id — the fallback must be a UUID, distinct across creates so a
+  // same-millisecond collision cannot cancel the earlier pending.
+  const first = handler.create({ message: "one" }, {});
+  const second = handler.create({ message: "two" }, {});
+  const ids = [...pendingMap.keys()];
+  assert.equal(ids.length, 2);
+  assert.notEqual(ids[0], ids[1]);
+  for (const id of ids) {
+    assert.match(
+      id,
+      /^codebuddy:chat-1:elicitation_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
+    );
+    assert.equal(pendingMap.get(id).chatSessionId, "chat-1");
+  }
+
+  pendingMap.get(ids[0]).resolve({ action: "accept" });
+  pendingMap.get(ids[1]).resolve({ action: "cancel" });
+  assert.deepEqual(await first, { action: "accept" });
+  assert.deepEqual(await second, { action: "cancel" });
+  assert.equal(pendingMap.size, 0);
+});
+
+test("buildCodebuddyElicitation complete cancels and removes a pending create", async () => {
+  const { events, emitter } = collector();
+  emitter.emitEvent = (ev) => events.push({ k: "event", ev });
+  const pendingMap = new Map();
+  const handler = buildCodebuddyElicitation(emitter, pendingMap);
+  const controller = new AbortController();
+
+  const createPromise = handler.create(
+    { _meta: { "codebuddy.ai": { elicitationId: "el-complete" } } },
+    { signal: controller.signal },
+  );
+  handler.complete({ elicitationId: "el-complete" });
+
+  assert.deepEqual(await createPromise, { action: "cancel" });
+  assert.equal(pendingMap.size, 0);
+  assert.equal(getEventListeners(controller.signal, "abort").length, 0);
+  assert.deepEqual(events.map(({ ev }) => ev.type), [
+    "elicitation-create",
+    "elicitation-complete",
+  ]);
+});
+
+test("buildCodebuddyElicitation scopes identical protocol ids to their chat", async () => {
+  const pendingMap = new Map();
+  const firstEvents = [];
+  const secondEvents = [];
+  const firstHandler = buildCodebuddyElicitation(
+    { emitEvent: (event) => firstEvents.push(event) },
+    pendingMap,
+    { chatSessionId: "chat/one" },
+  );
+  const secondHandler = buildCodebuddyElicitation(
+    { emitEvent: (event) => secondEvents.push(event) },
+    pendingMap,
+    { chatSessionId: "chat/two" },
+  );
+
+  const first = firstHandler.create({
+    _meta: { "codebuddy.ai": { elicitationId: "confirm:1" } },
+  });
+  const second = secondHandler.create({
+    _meta: { "codebuddy.ai": { elicitationId: "confirm:1" } },
+  });
+  const firstId = firstEvents[0].elicitationId;
+  const secondId = secondEvents[0].elicitationId;
+
+  assert.equal(firstId, "codebuddy:chat%2Fone:confirm%3A1");
+  assert.equal(secondId, "codebuddy:chat%2Ftwo:confirm%3A1");
+  assert.equal(pendingMap.size, 2);
+  pendingMap.get(firstId).resolve({ action: "accept", content: { chat: "one" } });
+  pendingMap.get(secondId).resolve({ action: "decline" });
+
+  assert.deepEqual(await first, { action: "accept", content: { chat: "one" } });
+  assert.deepEqual(await second, { action: "decline" });
+});
+
+// ---------------------------------------------------------------------------
+// MCP SSE/HTTP support
+// ---------------------------------------------------------------------------
+
+test("toSdkMcpServers supports sse, http, and sdk transport types", () => {
+  const fakeInstance = { __brand: "sdk-mcp" };
+  const map = toSdkMcpServers([
+    { name: "stdio-server", command: "/bin/server", args: ["--port", "0"], env: [] },
+    { name: "sse-server", type: "sse", url: "http://localhost:3000/sse", headers: { Authorization: "Bearer x" } },
+    { name: "http-server", type: "http", url: "http://localhost:4000/mcp" },
+    { name: "sdk-server", type: "sdk", instance: fakeInstance },
+  ]);
+  assert.equal(map["stdio-server"].type, "stdio");
+  assert.equal(map["stdio-server"].command, "/bin/server");
+  assert.equal(map["sse-server"].type, "sse");
+  assert.equal(map["sse-server"].url, "http://localhost:3000/sse");
+  assert.deepEqual(map["sse-server"].headers, { Authorization: "Bearer x" });
+  assert.equal(map["http-server"].type, "http");
+  assert.equal(map["http-server"].url, "http://localhost:4000/mcp");
+  assert.equal(map["sdk-server"].type, "sdk");
+  assert.equal(map["sdk-server"].name, "sdk-server");
+  assert.equal(map["sdk-server"].instance, fakeInstance);
+});
+
+// ---------------------------------------------------------------------------
+// Permission handler (canUseTool)
+// ---------------------------------------------------------------------------
+
+test("buildCodebuddyCanUseTool auto mode allows without prompting", async () => {
+  const handler = buildCodebuddyCanUseTool({ permissionMode: "auto" });
+  const result = await handler("Bash", { command: "rm -rf /tmp/x" }, {});
+  assert.deepEqual(result, { behavior: "allow" });
+});
+
+test("buildCodebuddyCanUseTool observer mode denies with message", async () => {
+  const handler = buildCodebuddyCanUseTool({ permissionMode: "observer" });
+  const result = await handler("Bash", { command: "ls" }, {});
+  assert.equal(result.behavior, "deny");
+  assert.ok(result.message.includes("Observer mode"));
+});
+
+test("buildCodebuddyCanUseTool confirm mode forwards to approval UI and allows on approve", async () => {
+  const calls = [];
+  const requestApproval = async (toolName, args, chatSessionId) => {
+    calls.push({ toolName, args, chatSessionId });
+    return true;
+  };
+  const handler = buildCodebuddyCanUseTool({
+    permissionMode: "confirm",
+    chatSessionId: "chat-1",
+    requestApproval,
+  });
+  const result = await handler("Bash", { command: "apt install nginx" }, {});
+  assert.deepEqual(result, { behavior: "allow" });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].toolName, "Bash");
+  assert.deepEqual(calls[0].args, { command: "apt install nginx" });
+  assert.equal(calls[0].chatSessionId, "chat-1");
+});
+
+test("buildCodebuddyCanUseTool confirm mode denies on user rejection", async () => {
+  const handler = buildCodebuddyCanUseTool({
+    permissionMode: "confirm",
+    chatSessionId: "chat-1",
+    requestApproval: async () => false,
+  });
+  const result = await handler("Bash", { command: "reboot" }, {});
+  assert.equal(result.behavior, "deny");
+  assert.ok(result.message.includes("User denied"));
+});
+
+test("buildCodebuddyCanUseTool confirm mode denies when no approval channel", async () => {
+  const handler = buildCodebuddyCanUseTool({ permissionMode: "confirm" });
+  const result = await handler("Bash", {}, {});
+  assert.equal(result.behavior, "deny");
+  assert.ok(result.message.includes("no approval channel"));
+});
+
+test("buildCodebuddyQueryOptions attaches canUseTool handler", () => {
+  const handler = async () => ({ behavior: "allow" });
+  const opts = buildCodebuddyQueryOptions({ cwd: "/tmp", env: {}, canUseTool: handler });
+  assert.equal(opts.canUseTool, handler);
+});