@runfusion/fusion 0.18.1 → 0.20.0

package/dist/droid-cli/src/__tests__/provider.test.ts

@@ -1,1930 +1,9 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
+import { describe, expect, it } from "vitest";
+import { streamViaCli as shimStreamViaCli } from "../provider";
+import { streamViaCli as pluginStreamViaCli } from "../../../../plugins/fusion-plugin-droid-runtime/src/provider.js";
 
-// Mock child_process.spawn with PassThrough streams for readline compatibility
-vi.mock("node:child_process", () => ({
-  spawn: vi.fn(() => {
-    const proc = new EventEmitter();
-    const stdin = { write: vi.fn(), end: vi.fn() };
-    const stdout = new PassThrough();
-    const stderr = new EventEmitter();
-    (proc as any).stdin = stdin;
-    (proc as any).stdout = stdout;
-    (proc as any).stderr = stderr;
-    (proc as any).killed = false;
-    (proc as any).exitCode = null;
-    (proc as any).kill = vi.fn(() => {
-      (proc as any).killed = true;
-    });
-    (proc as any).pid = 99999;
-    return proc;
-  }),
-  execSync: vi.fn(() => Buffer.from("1.0.0")),
-}));
-
-// Mock @mariozechner/pi-ai
-const mockModels = [
-  {
-    id: "droid-pro",
-    name: "Droid Pro",
-    api: "droid-cli",
-    provider: "droid-cli",
-    reasoning: false,
-    input: "text",
-    cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-    contextWindow: 200000,
-    maxTokens: 8192,
-  },
-  {
-    id: "droid-opus-max",
-    name: "Droid Max",
-    api: "droid-cli",
-    provider: "droid-cli",
-    reasoning: true,
-    input: "text",
-    cost: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
-    contextWindow: 200000,
-    maxTokens: 16384,
-  },
-];
-
-const { MockAssistantMessageEventStream } = vi.hoisted(() => {
-  const MockAssistantMessageEventStream: any = vi.fn(function (this: any) {
-    const events: any[] = [];
-    this.push = vi.fn((event: any) => events.push(event));
-    this.end = vi.fn();
-    this._events = events;
-  });
-  return { MockAssistantMessageEventStream };
-});
-
-vi.mock("@mariozechner/pi-ai", () => ({
-  getModels: vi.fn(() => mockModels),
-  AssistantMessageEventStream: MockAssistantMessageEventStream,
-  calculateCost: vi.fn(),
-}));
-
-import { spawn } from "node:child_process";
-import { streamViaCli } from "../provider";
-
-describe("provider registration (default export)", () => {
-  it("registers provider id droid-cli with deduped discovered models", async () => {
-    vi.resetModules();
-    vi.doMock("../../../../plugins/fusion-plugin-droid-runtime/src/provider.js", () => ({
-      streamViaCli: vi.fn(() => ({ mocked: true })),
-    }));
-    vi.doMock("../../../../plugins/fusion-plugin-droid-runtime/src/process-manager.js", () => ({
-      validateCliPresenceAsync: vi.fn(async () => ({ ok: true })),
-      validateCliAuthAsync: vi.fn(async () => true),
-      killAllProcesses: vi.fn(),
-      discoverDroidModels: vi.fn(async () => ["droid-pro", "droid-max", "droid-pro"]),
-    }));
-    vi.doMock("../../../../plugins/fusion-plugin-droid-runtime/src/mcp-config.js", () => ({
-      getCustomToolDefs: vi.fn(() => []),
-      toolsFromContext: vi.fn(() => []),
-      writeMcpConfig: vi.fn(() => "/tmp/droid-mcp.json"),
-    }));
-
-    const registerProvider = vi.fn();
-    const on = vi.fn();
-    const getAllTools = vi.fn(() => []);
-    const setActiveTools = vi.fn();
-
-    const mod = await import("../../index");
-    mod.default({ registerProvider, on, getAllTools, setActiveTools } as any);
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(registerProvider).toHaveBeenCalledTimes(1);
-    const [providerId, config] = registerProvider.mock.calls[0];
-    expect(providerId).toBe("droid-cli");
-    expect(config.baseUrl).toBe("droid-cli");
-    expect(config.apiKey).toBe("unused");
-    expect(config.api).toBe("droid-cli");
-    expect(config.models.map((m: { id: string }) => m.id)).toEqual([
-      "droid-pro",
-      "droid-max",
-    ]);
-    vi.doUnmock("../../../../plugins/fusion-plugin-droid-runtime/src/provider.js");
-    vi.doUnmock("../../../../plugins/fusion-plugin-droid-runtime/src/process-manager.js");
-    vi.doUnmock("../../../../plugins/fusion-plugin-droid-runtime/src/mcp-config.js");
-  });
-
-  it("delegates streamSimple execution to plugin-owned streamViaCli", async () => {
-    vi.resetModules();
-    const pluginStreamViaCli = vi.fn(() => ({ delegated: true }));
-    vi.doMock("../../../../plugins/fusion-plugin-droid-runtime/src/provider.js", () => ({
-      streamViaCli: pluginStreamViaCli,
-    }));
-    vi.doMock("../../../../plugins/fusion-plugin-droid-runtime/src/process-manager.js", () => ({
-      validateCliPresenceAsync: vi.fn(async () => ({ ok: true })),
-      validateCliAuthAsync: vi.fn(async () => true),
-      killAllProcesses: vi.fn(),
-      discoverDroidModels: vi.fn(async () => ["droid-pro"]),
-    }));
-    vi.doMock("../../../../plugins/fusion-plugin-droid-runtime/src/mcp-config.js", () => ({
-      getCustomToolDefs: vi.fn(() => []),
-      toolsFromContext: vi.fn(() => []),
-      writeMcpConfig: vi.fn(() => undefined),
-    }));
-
-    const registerProvider = vi.fn();
-    const on = vi.fn();
-    const getAllTools = vi.fn(() => []);
-    const setActiveTools = vi.fn();
-
-    const mod = await import("../../index");
-    mod.default({ registerProvider, on, getAllTools, setActiveTools } as any);
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    const [, config] = registerProvider.mock.calls[0];
-    config.streamSimple({ id: "droid-pro", provider: "droid-cli" }, { messages: [] }, {});
-    expect(pluginStreamViaCli).toHaveBeenCalled();
-
-    vi.doUnmock("../../../../plugins/fusion-plugin-droid-runtime/src/provider.js");
-    vi.doUnmock("../../../../plugins/fusion-plugin-droid-runtime/src/process-manager.js");
-    vi.doUnmock("../../../../plugins/fusion-plugin-droid-runtime/src/mcp-config.js");
-  });
-});
-
-describe("streamViaCli", { timeout: 90_000 }, () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-    vi.spyOn(console, "warn").mockImplementation(() => {});
-    vi.spyOn(console, "error").mockImplementation(() => {});
-    delete process.env.PI_DROID_CLI_DEBUG;
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-    delete process.env.PI_DROID_CLI_DEBUG;
-  });
-
-  it("returns an AssistantMessageEventStream", async () => {
-    const model = mockModels[0] as any;
-    const context = {
-      messages: [{ role: "user", content: "Hello" }],
-      systemPrompt: "Be helpful",
-    };
-
-    const result = streamViaCli(model, context);
-    expect(result).toBeDefined();
-    expect(result.push).toBeDefined();
-    expect(result.end).toBeDefined();
-
-    // Ensure the spawned process/readline lifecycle completes so fake timers
-    // don't leave the test hanging on the inactivity timeout.
-    await vi.advanceTimersByTimeAsync(0);
-    const proc = (spawn as any).mock.results[0].value;
-    proc.stdout.write(
-      `${JSON.stringify({ type: "result", subtype: "success", result: "ok" })}\n`,
-    );
-    proc.stdout.end();
-    await vi.advanceTimersByTimeAsync(0);
-  });
-
-  it("logs PID and spawn args when debug mode is enabled", async () => {
-    process.env.PI_DROID_CLI_DEBUG = "1";
-
-    const model = mockModels[0] as any;
-    const context = {
-      messages: [{ role: "user", content: "Hello" }],
-    };
-
-    const errorSpy = vi.spyOn(console, "error");
-
-    streamViaCli(model, context);
-    await vi.advanceTimersByTimeAsync(0);
-
-    expect(errorSpy).toHaveBeenCalledWith(
-      expect.stringContaining("spawned droid subprocess pid=99999 args="),
-    );
-  });
-
-  it("spawns subprocess and writes user message to stdin", async () => {
-    const model = mockModels[0] as any;
-    const context = {
-      messages: [{ role: "user", content: "Hello" }],
-    };
-
-    streamViaCli(model, context);
-
-    // Allow async IIFE to start
-    await vi.advanceTimersByTimeAsync(0);
-
-    // Verify spawn was called
-    expect(spawn).toHaveBeenCalled();
-
-    // Verify user message was written to stdin
-    const proc = (spawn as any).mock.results[0].value;
-    expect(proc.stdin.write).toHaveBeenCalledTimes(1);
-
-    const written = proc.stdin.write.mock.calls[0][0] as string;
-    const parsed = JSON.parse(written.trim());
-    expect(parsed.type).toBe("user");
-    expect(parsed.message.role).toBe("user");
-  });
-
-  describe("stdin close behavior", () => {
-    it("stdin.end() is called after writeUserMessage", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-      expect(proc.stdin.end).toHaveBeenCalledTimes(1);
-      expect(proc.stdin.write.mock.invocationCallOrder[0]).toBeLessThan(
-        proc.stdin.end.mock.invocationCallOrder[0],
-      );
-    });
-
-    it("unexpected control_request on stdout is logged and ignored", async () => {
-      process.env.PI_DROID_CLI_DEBUG = "1";
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-      const errorSpy = vi.spyOn(console, "error");
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      const lines = [
-        JSON.stringify({
-          type: "control_request",
-          request_id: "req_123",
-          request: {
-            subtype: "can_use_tool",
-            tool_name: "Read",
-            input: { file_path: "/foo.ts" },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({
-          type: "result",
-          subtype: "success",
-          result: "ok",
-        }),
-      ];
-
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      expect(mockStream._events.some((e: any) => e.type === "done")).toBe(true);
-      expect(proc.stdin.write).toHaveBeenCalledTimes(1);
-      expect(errorSpy).toHaveBeenCalledWith(
-        expect.stringContaining("unexpected control_request received"),
-      );
-    });
-  });
-
-  it("handles full text streaming sequence via NDJSON", async () => {
-    const model = mockModels[0] as any;
-    const context = {
-      messages: [{ role: "user", content: "Hello" }],
-    };
-
-    streamViaCli(model, context);
-    await vi.advanceTimersByTimeAsync(0);
-
-    // Get the mock process
-    const proc = (spawn as any).mock.results[0].value;
-
-    // Simulate NDJSON output on stdout
-    const lines = [
-      JSON.stringify({ type: "system", subtype: "init", session_id: "test" }),
-      JSON.stringify({
-        type: "stream_event",
-        event: {
-          type: "message_start",
-          message: { usage: { input_tokens: 10, output_tokens: 0 } },
-        },
-      }),
-      JSON.stringify({
-        type: "stream_event",
-        event: {
-          type: "content_block_start",
-          index: 0,
-          content_block: { type: "text", text: "" },
-        },
-      }),
-      JSON.stringify({
-        type: "stream_event",
-        event: {
-          type: "content_block_delta",
-          index: 0,
-          delta: { type: "text_delta", text: "Hello" },
-        },
-      }),
-      JSON.stringify({
-        type: "stream_event",
-        event: {
-          type: "content_block_delta",
-          index: 0,
-          delta: { type: "text_delta", text: " world" },
-        },
-      }),
-      JSON.stringify({
-        type: "stream_event",
-        event: { type: "content_block_stop", index: 0 },
-      }),
-      JSON.stringify({
-        type: "stream_event",
-        event: {
-          type: "message_delta",
-          delta: { stop_reason: "end_turn" },
-          usage: { output_tokens: 5 },
-        },
-      }),
-      JSON.stringify({
-        type: "stream_event",
-        event: { type: "message_stop" },
-      }),
-      JSON.stringify({
-        type: "result",
-        subtype: "success",
-        result: "Hello world",
-      }),
-    ];
-
-    // Write each line to stdout PassThrough stream (readline reads from it)
-    for (const line of lines) {
-      proc.stdout.write(line + "\n");
-    }
-    // End the stream so readline finishes
-    proc.stdout.end();
-
-    // Allow async processing
-    await vi.advanceTimersByTimeAsync(100);
-
-    // The stream should have received events from the event bridge
-    const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-    const events = mockStream._events;
-
-    // Verify we got the expected event types
-    const eventTypes = events.map((e: any) => e.type);
-    expect(eventTypes).toContain("text_start");
-    expect(eventTypes).toContain("text_delta");
-    expect(eventTypes).toContain("text_end");
-    expect(eventTypes).toContain("done");
-  });
-
-  it("handles result error by pushing error event", async () => {
-    const model = mockModels[0] as any;
-    const context = {
-      messages: [{ role: "user", content: "Hello" }],
-    };
-
-    streamViaCli(model, context);
-    await vi.advanceTimersByTimeAsync(0);
-
-    const proc = (spawn as any).mock.results[0].value;
-
-    // Write error result to stdout
-    const errorLine = JSON.stringify({
-      type: "result",
-      subtype: "error",
-      error: "Rate limit exceeded",
-    });
-    proc.stdout.write(errorLine + "\n");
-    proc.stdout.end();
-    await vi.advanceTimersByTimeAsync(100);
-
-    const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-    const doneEvent = mockStream._events.find(
-      (e: any) => e.type === "done" && e.message,
-    );
-    expect(doneEvent).toBeDefined();
-    expect(doneEvent.message.content).toBeDefined();
-    expect(mockStream.end).toHaveBeenCalled();
-  });
-
-  it("calls cleanupProcess after receiving result", async () => {
-    const model = mockModels[0] as any;
-    const context = {
-      messages: [{ role: "user", content: "Hello" }],
-    };
-
-    streamViaCli(model, context);
-    await vi.advanceTimersByTimeAsync(0);
-
-    const proc = (spawn as any).mock.results[0].value;
-
-    // Write result to stdout
-    proc.stdout.write(
-      JSON.stringify({ type: "result", subtype: "success", result: "ok" }) +
-        "\n",
-    );
-    proc.stdout.end();
-    await vi.advanceTimersByTimeAsync(100);
-
-    // Advance timer past cleanup grace period (500ms after Phase 5 hardening)
-    vi.advanceTimersByTime(500);
-    expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-  });
-
-  it("kills subprocess when abort signal fires", async () => {
-    const model = mockModels[0] as any;
-    const context = {
-      messages: [{ role: "user", content: "Hello" }],
-    };
-    const controller = new AbortController();
-
-    streamViaCli(model, context, { signal: controller.signal });
-    await vi.advanceTimersByTimeAsync(0);
-
-    const proc = (spawn as any).mock.results[0].value;
-
-    // Trigger abort -- this should call kill on the process
-    controller.abort();
-    await vi.advanceTimersByTimeAsync(0);
-
-    expect(proc.kill).toHaveBeenCalled();
-
-    // End stdout to allow readline loop to finish and prevent hanging
-    proc.stdout.end();
-    await vi.advanceTimersByTimeAsync(100);
-  });
-
-
-
-  describe("thinking effort wiring", () => {
-    it("passes effort to spawnDroid when options.reasoning is provided on non-Opus model", async () => {
-      const model = mockModels[0] as any; // sonnet (non-Opus)
-      const context = {
-        messages: [{ role: "user", content: "Think about this" }],
-      };
-
-      streamViaCli(model, context, { reasoning: "high" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      // Verify spawn was called with effort arg
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).toContain("--effort");
-      const idx = args.indexOf("--effort");
-      expect(args[idx + 1]).toBe("high");
-    });
-
-    it("passes elevated effort to spawnDroid when options.reasoning is provided on Opus model", async () => {
-      const model = mockModels[1] as any; // opus
-      const context = {
-        messages: [{ role: "user", content: "Think about this" }],
-      };
-
-      streamViaCli(model, context, { reasoning: "high" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      // Opus "high" should map to "max"
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).toContain("--effort");
-      const idx = args.indexOf("--effort");
-      expect(args[idx + 1]).toBe("max");
-    });
-
-    it("does not pass effort when reasoning is undefined", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).not.toContain("--effort");
-    });
-
-    it("passes medium effort for medium reasoning on non-Opus", async () => {
-      const model = mockModels[0] as any; // sonnet
-      const context = {
-        messages: [{ role: "user", content: "Think" }],
-      };
-
-      streamViaCli(model, context, { reasoning: "medium" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      const idx = args.indexOf("--effort");
-      expect(args[idx + 1]).toBe("medium");
-    });
-
-    it("passes high effort for medium reasoning on Opus (elevated)", async () => {
-      const model = mockModels[1] as any; // opus
-      const context = {
-        messages: [{ role: "user", content: "Think" }],
-      };
-
-      streamViaCli(model, context, { reasoning: "medium" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      const idx = args.indexOf("--effort");
-      expect(args[idx + 1]).toBe("high");
-    });
-  });
-
-
-
-  describe("mcpConfigPath passthrough", () => {
-    it("passes mcpConfigPath to spawnDroid options", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context, {
-        mcpConfigPath: "/tmp/mcp-config.json",
-      } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).toContain("--mcp-config");
-      const idx = args.indexOf("--mcp-config");
-      expect(args[idx + 1]).toBe("/tmp/mcp-config.json");
-
-      // End stdout to prevent hanging
-      const proc = (spawn as any).mock.results[0].value;
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-  });
-
-  describe("break-early logic", () => {
-    it("kills subprocess at message_stop when built-in tool_use seen and emits done event", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Read a file" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Simulate tool_use stream: message_start, content_block_start (tool_use Read),
-      // content_block_delta (input_json_delta), content_block_stop, message_delta, message_stop
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "tool_1",
-              name: "Read",
-              input: "",
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_delta",
-            index: 0,
-            delta: {
-              type: "input_json_delta",
-              partial_json: '{"file_path":"/foo.ts"}',
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-      ];
-
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      // End stdout to let readline close
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Verify process was killed (break-early)
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-
-      // Verify the stream received a done event (from event bridge handleMessageStop)
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const events = mockStream._events;
-      const eventTypes = events.map((e: any) => e.type);
-      expect(eventTypes).toContain("done");
-      expect(eventTypes).toContain("toolcall_start");
-      expect(eventTypes).toContain("toolcall_end");
-    });
-
-    it("kills subprocess at message_stop when custom-tools MCP tool seen", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Search for something" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "tool_2",
-              name: "mcp__custom-tools__search",
-              input: "",
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-      ];
-
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Verify process was killed (break-early for custom-tools MCP)
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-    });
-
-    it("does NOT break-early when stream has no tool_use blocks", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Text-only stream
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: { type: "text", text: "" },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_delta",
-            index: 0,
-            delta: { type: "text_delta", text: "Hello!" },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "end_turn" },
-            usage: { output_tokens: 1 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({
-          type: "result",
-          subtype: "success",
-          result: "Hello!",
-        }),
-      ];
-
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Process should NOT have been killed with SIGKILL immediately
-      // It should only be killed via cleanupProcess after result (500ms grace)
-      const killCalls = proc.kill.mock.calls;
-      const sigkillBeforeResult = killCalls.filter(
-        (call: any[]) => call[0] === "SIGKILL",
-      );
-      // If killed, it was only after the cleanup grace period, not at message_stop
-      // The kill should only happen after we advance past the 500ms timer
-      expect(sigkillBeforeResult).toHaveLength(0);
-
-      // Now advance past cleanup timer
-      vi.advanceTimersByTime(500);
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-    });
-
-    it("does NOT break-early for internal Claude Code tools (ToolSearch, Task, etc.)", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Use weather tool" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "tool_ts",
-              name: "ToolSearch",
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({
-          type: "result",
-          subtype: "success",
-          result: "ok",
-        }),
-      ];
-
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Process should NOT have been killed at message_stop (ToolSearch is internal)
-      const killCalls = proc.kill.mock.calls;
-      const sigkillBeforeResult = killCalls.filter(
-        (call: any[]) => call[0] === "SIGKILL",
-      );
-      expect(sigkillBeforeResult).toHaveLength(0);
-
-      vi.advanceTimersByTime(500);
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-    });
-
-    it("does NOT break-early for pi-known tools inside sub-agents (parent_tool_use_id set)", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Run an agent" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Top-level: Agent tool_use (not pi-known, no break-early)
-      // Then sub-agent uses Read (pi-known, but parent_tool_use_id is set)
-      // Then sub-agent message_stop (should NOT trigger break-early)
-      // Then top-level text response and message_stop (no tool_use, no break-early)
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-          parent_tool_use_id: null,
-        }),
-        // Top-level: Agent tool call
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "agent_1",
-              name: "Agent",
-            },
-          },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-          parent_tool_use_id: null,
-        }),
-        // Sub-agent: Read tool (pi-known, but inside sub-agent)
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "read_1",
-              name: "Read",
-            },
-          },
-          parent_tool_use_id: "agent_1",
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-          parent_tool_use_id: "agent_1",
-        }),
-        // Top-level: final text response
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 20, output_tokens: 0 } },
-          },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: { type: "text", text: "" },
-          },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_delta",
-            index: 0,
-            delta: { type: "text_delta", text: "Agent found the code." },
-          },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "end_turn" },
-            usage: { output_tokens: 10 },
-          },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-          parent_tool_use_id: null,
-        }),
-        JSON.stringify({
-          type: "result",
-          subtype: "success",
-          result: "Agent found the code.",
-        }),
-      ];
-
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Should NOT have been killed at any message_stop (no top-level pi-known tools)
-      // The Read inside the sub-agent should be ignored for break-early
-      const killBeforeResult = proc.kill.mock.calls.filter(
-        (call: any[]) => call[0] === "SIGKILL",
-      );
-      expect(killBeforeResult).toHaveLength(0);
-
-      // Should have received the final text response
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const textEvents = mockStream._events.filter(
-        (e: any) => e.type === "text_delta",
-      );
-      expect(textEvents.length).toBeGreaterThan(0);
-
-      vi.advanceTimersByTime(500);
-    });
-
-    it("does NOT break-early when only user MCP tools are seen (not custom-tools)", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Use user MCP tool" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "tool_3",
-              name: "mcp__user-server__tool",
-              input: "",
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({
-          type: "result",
-          subtype: "success",
-          result: "ok",
-        }),
-      ];
-
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Process should NOT have been killed at message_stop (only user MCP tool)
-      const killCalls = proc.kill.mock.calls;
-      const sigkillBeforeResult = killCalls.filter(
-        (call: any[]) => call[0] === "SIGKILL",
-      );
-      expect(sigkillBeforeResult).toHaveLength(0);
-
-      // After cleanup grace period, process gets killed
-      vi.advanceTimersByTime(500);
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-    });
-  });
-
-  describe("subprocess error handling", () => {
-    it("pushes done event when subprocess emits error (e.g. spawn failure)", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Emit process error (e.g. ENOENT from failed spawn)
-      proc.emit("error", new Error("spawn ENOENT"));
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find(
-        (e: any) => e.type === "done" && e.message,
-      );
-      expect(doneEvent).toBeDefined();
-      expect(doneEvent.message.content).toBeDefined();
-      expect(mockStream.end).toHaveBeenCalled();
-    });
-
-    it("pushes error event when subprocess crashes with non-zero exit code", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Emit close with non-zero exit code (no result written first)
-      proc.emit("close", 1, null);
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find(
-        (e: any) => e.type === "done" && e.message,
-      );
-      expect(doneEvent).toBeDefined();
-      expect(doneEvent.message.content).toBeDefined();
-      expect(mockStream.end).toHaveBeenCalled();
-    });
-
-    it("includes stderr in error event on crash", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Emit stderr data, then close with non-zero exit
-      proc.stderr.emit("data", Buffer.from("segfault in libfoo.so"));
-      proc.emit("close", 139, null);
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find(
-        (e: any) => e.type === "done" && e.message,
-      );
-      expect(doneEvent).toBeDefined();
-      expect(doneEvent.message.content).toBeDefined();
-    });
-
-    it("logs stderr at warn level on close even with exit code 0", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      const warnSpy = vi.spyOn(console, "warn");
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      proc.stderr.emit("data", Buffer.from("minor warning from cli"));
-      proc.emit("close", 0, null);
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("minor warning from cli"),
-      );
-    });
-
-    it("warns when subprocess closes successfully with no content events", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      const warnSpy = vi.spyOn(console, "warn");
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-      proc.emit("close", 0, null);
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("closed without content events"),
-      );
-    });
-
-    it("does not push error on normal close (code 0)", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Write result to stdout then close with code 0
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({ type: "result", subtype: "success", result: "ok" }),
-      ];
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.emit("close", 0, null);
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const errorEvent = mockStream._events.find(
-        (e: any) => e.type === "error",
-      );
-      expect(errorEvent).toBeUndefined();
-    });
-
-    it("does not push error after break-early (broken flag)", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Read a file" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Simulate tool_use break-early sequence
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "tool_1",
-              name: "Read",
-              input: "",
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-      ];
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      await vi.advanceTimersByTimeAsync(50);
-
-      // Now emit close with non-zero code (from SIGKILL)
-      proc.emit("close", null, "SIGKILL");
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      // Should have done event but no error event
-      const eventTypes = mockStream._events.map((e: any) => e.type);
-      expect(eventTypes).toContain("done");
-      expect(eventTypes).not.toContain("error");
-    });
-  });
-
-  describe("inactivity timeout", () => {
-    it("kills subprocess and pushes error after 1800s of no output", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Advance timers by 1800 seconds without writing to stdout
-      await vi.advanceTimersByTimeAsync(1_800_000);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find(
-        (e: any) => e.type === "done" && e.message,
-      );
-      expect(doneEvent).toBeDefined();
-      expect(doneEvent.message.content).toBeDefined();
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-
-      // Clean up - end stdout so readline closes
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("resets timer on each stdout line", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Advance near first-line timeout, then write a line to reset inactivity window
-      await vi.advanceTimersByTimeAsync(50_000);
-
-      // Write a stream event line
-      proc.stdout.write(
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }) + "\n",
-      );
-      await vi.advanceTimersByTimeAsync(0);
-
-      // Advance close to inactivity timeout from last line -- should NOT timeout yet
-      await vi.advanceTimersByTimeAsync(1_790_000);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find(
-        (e: any) => e.type === "done" && e.message,
-      );
-      expect(doneEvent).toBeUndefined();
-
-      // Advance 10 more seconds (1800s since last line) -- NOW should timeout
-      await vi.advanceTimersByTimeAsync(10_000);
-
-      const doneEvent2 = mockStream._events.find(
-        (e: any) => e.type === "done" && e.message,
-      );
-      expect(doneEvent2).toBeDefined();
-      expect(doneEvent2.message.content).toBeDefined();
-
-      // Clean up
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("clears timer on normal completion", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Write normal result to stdout
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({ type: "result", subtype: "success", result: "ok" }),
-      ];
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Advance past 180s -- should NOT timeout since result was received
-      await vi.advanceTimersByTimeAsync(1_800_000);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const errorEvents = mockStream._events.filter(
-        (e: any) => e.type === "error",
-      );
-      expect(errorEvents).toHaveLength(0);
-    });
-  });
-
-  describe("abort handler fix", () => {
-    it("abort signal sends SIGKILL not SIGTERM", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-      const controller = new AbortController();
-
-      streamViaCli(model, context, { signal: controller.signal });
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Trigger abort
-      controller.abort();
-      await vi.advanceTimersByTimeAsync(0);
-
-      // Verify SIGKILL was used (not SIGTERM)
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-      // Ensure SIGTERM was NOT used
-      const sigTermCalls = proc.kill.mock.calls.filter(
-        (call: any[]) => call[0] === "SIGTERM",
-      );
-      expect(sigTermCalls).toHaveLength(0);
-
-      // Clean up
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-  });
-
-  describe("abort signal already aborted", () => {
-    it("kills subprocess immediately when signal is already aborted", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-      const controller = new AbortController();
-      controller.abort(); // Abort BEFORE calling streamViaCli
-
-      streamViaCli(model, context, { signal: controller.signal });
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-      expect(proc.kill).toHaveBeenCalledWith("SIGKILL");
-
-      // Clean up
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-  });
-
-  describe("MCP config with custom tool results", () => {
-    it("keeps MCP config even when conversation ends with custom tool result", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [
-          { role: "user", content: "deploy it" },
-          {
-            role: "assistant",
-            content: [
-              { type: "toolCall", name: "deploy", arguments: { env: "prod" } },
-            ],
-          },
-          {
-            role: "toolResult",
-            content: "Deployed successfully",
-            toolName: "deploy",
-          },
-        ],
-      };
-
-      streamViaCli(model, context, {
-        mcpConfigPath: "/tmp/mcp.json",
-      } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      // MCP config should always be passed so consecutive MCP tool calls work
-      expect(args).toContain("--mcp-config");
-
-      // Clean up
-      const proc = (spawn as any).mock.results[0].value;
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("does NOT suppress MCP config when conversation ends with user message", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context, {
-        mcpConfigPath: "/tmp/mcp.json",
-      } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).toContain("--mcp-config");
-
-      // Clean up
-      const proc = (spawn as any).mock.results[0].value;
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-  });
-
-  describe("effectiveReason override logic", () => {
-    it("overrides toolUse stopReason to stop when no pi-known tool calls in content", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Stream a sequence where Claude calls a user MCP tool (not pi-known)
-      // The event bridge filters it out so content has no toolCall items
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "tool_user",
-              name: "mcp__user-server__tool",
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({ type: "result", subtype: "success", result: "ok" }),
-      ];
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      // Advance past cleanup
-      vi.advanceTimersByTime(500);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find((e: any) => e.type === "done");
-      expect(doneEvent).toBeDefined();
-      // Reason should be overridden to "stop" (not "toolUse")
-      expect(doneEvent.reason).toBe("stop");
-      expect(doneEvent.message.stopReason).toBe("stop");
-    });
-
-    it("keeps toolUse stopReason when pi-known tool calls are present", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Read a file" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Stream a sequence where Claude calls a built-in tool (Read)
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: {
-              type: "tool_use",
-              id: "tool_read",
-              name: "Read",
-              input: "",
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_delta",
-            index: 0,
-            delta: {
-              type: "input_json_delta",
-              partial_json: '{"file_path":"/foo.ts"}',
-            },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "tool_use" },
-            usage: { output_tokens: 5 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-      ];
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      // Break-early kills and closes readline
-      await vi.advanceTimersByTimeAsync(100);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find((e: any) => e.type === "done");
-      expect(doneEvent).toBeDefined();
-      expect(doneEvent.reason).toBe("toolUse");
-      expect(doneEvent.message.stopReason).toBe("toolUse");
-
-      // Clean up
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("handles undefined output.content without crashing", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      // Stream a minimal sequence with no content blocks — just message_start,
-      // message_delta with stop_reason, message_stop, and result.
-      // This produces output.content = undefined in the event bridge.
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "end_turn" },
-            usage: { output_tokens: 0 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({ type: "result", subtype: "success", result: "ok" }),
-      ];
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      vi.advanceTimersByTime(500);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find((e: any) => e.type === "done");
-      expect(doneEvent).toBeDefined();
-      // Should not crash — stopReason should be "stop" (end_turn maps to stop)
-      expect(doneEvent.reason).toBe("stop");
-    });
-
-    it("passes through length stopReason unchanged", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Write a very long essay" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-
-      const lines = [
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_start",
-            message: { usage: { input_tokens: 10, output_tokens: 0 } },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_start",
-            index: 0,
-            content_block: { type: "text", text: "" },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "content_block_delta",
-            index: 0,
-            delta: { type: "text_delta", text: "Long text..." },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "content_block_stop", index: 0 },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: {
-            type: "message_delta",
-            delta: { stop_reason: "max_tokens" },
-            usage: { output_tokens: 8192 },
-          },
-        }),
-        JSON.stringify({
-          type: "stream_event",
-          event: { type: "message_stop" },
-        }),
-        JSON.stringify({ type: "result", subtype: "success", result: "ok" }),
-      ];
-      for (const line of lines) {
-        proc.stdout.write(line + "\n");
-      }
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-
-      vi.advanceTimersByTime(500);
-
-      const mockStream = MockAssistantMessageEventStream.mock.instances[0];
-      const doneEvent = mockStream._events.find((e: any) => e.type === "done");
-      expect(doneEvent).toBeDefined();
-      expect(doneEvent.reason).toBe("length");
-      expect(doneEvent.message.stopReason).toBe("length");
-    });
-  });
-
-  describe("session resume via options.sessionId", () => {
-    it("passes --resume when sessionId option is provided on subsequent turn", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [
-          { role: "user", content: "Hello" },
-          { role: "assistant", content: "Hi" },
-          { role: "user", content: "Follow-up" },
-        ],
-      };
-
-      streamViaCli(model, context, { sessionId: "sess-abc-123" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).toContain("--resume");
-      const idx = args.indexOf("--resume");
-      expect(args[idx + 1]).toBe("sess-abc-123");
-
-      // Clean up
-      const proc = (spawn as any).mock.results[0].value;
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("passes --session-id on first turn when sessionId provided", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context, { sessionId: "sess-new" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).not.toContain("--resume");
-      expect(args).toContain("--session-id");
-      const idx = args.indexOf("--session-id");
-      expect(args[idx + 1]).toBe("sess-new");
-
-      // Clean up
-      const proc = (spawn as any).mock.results[0].value;
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("does not pass --resume or --session-id when no sessionId option", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [{ role: "user", content: "Hello" }],
-      };
-
-      streamViaCli(model, context);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).not.toContain("--resume");
-      expect(args).not.toContain("--session-id");
-
-      // Clean up
-      const proc = (spawn as any).mock.results[0].value;
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("uses buildResumePrompt when sessionId is provided (sends only new content)", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [
-          { role: "user", content: "first message" },
-          { role: "assistant", content: "response" },
-          { role: "user", content: "follow-up" },
-        ],
-      };
-
-      streamViaCli(model, context, { sessionId: "sess-resume" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const proc = (spawn as any).mock.results[0].value;
-      const written = proc.stdin.write.mock.calls[0][0] as string;
-      const parsed = JSON.parse(written.trim());
-      // Should only contain the latest user message, not full history
-      expect(parsed.message.content).toBe("follow-up");
-
-      // Clean up
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
-
-    it("does not pass system prompt when resuming", async () => {
-      const model = mockModels[0] as any;
-      const context = {
-        messages: [
-          { role: "user", content: "Hello" },
-          { role: "assistant", content: "Hi" },
-          { role: "user", content: "follow-up" },
-        ],
-        systemPrompt: "Be helpful",
-      };
-
-      streamViaCli(model, context, { sessionId: "sess-resume" } as any);
-      await vi.advanceTimersByTimeAsync(0);
-
-      const args = (spawn as any).mock.calls[0][1] as string[];
-      expect(args).toContain("--resume");
-      expect(args).not.toContain("--append-system-prompt");
-
-      // Clean up
-      const proc = (spawn as any).mock.results[0].value;
-      proc.stdout.end();
-      await vi.advanceTimersByTimeAsync(100);
-    });
+describe("droid-cli provider shim", () => {
+  it("re-exports streamViaCli from the droid runtime plugin", () => {
+    expect(shimStreamViaCli).toBe(pluginStreamViaCli);
   });
 });