@runfusion/fusion 0.2.7 → 0.4.0

package/dist/pi-claude-cli/index.ts

@@ -13,56 +13,93 @@ import {
   validateCliAuth,
   killAllProcesses,
 } from "./src/process-manager.js";
-import { getCustomToolDefs, writeMcpConfig } from "./src/mcp-config.js";
+import { createHash } from "node:crypto";
+import {
+  getCustomToolDefs,
+  toolsFromContext,
+  writeMcpConfig,
+  type McpToolDef,
+} from "./src/mcp-config.js";
 
 // Kill all active Claude subprocesses on process exit to prevent orphans
 process.on("exit", killAllProcesses);
 
 const PROVIDER_ID = "pi-claude-cli";
 
-let mcpConfigPath: string | undefined;
-let mcpConfigResolved = false;
+let cachedMcpConfig: { hash: string; configPath: string } | undefined;
 
 /**
- * Lazily generate MCP config on first request (not at load time).
- * pi.getAllTools() fails during extension loading; this defers it
- * until the pi runtime is fully initialized.
+ * Resolve the MCP config path for the current request, regenerating it when
+ * the set of custom tools changes.
+ *
+ * Source of truth (in order of preference):
+ * 1. `context.tools` — the per-session tool list pi-ai actually hands to
+ *    `streamSimple`. This is what the session is asking the model to see, so
+ *    it includes session-scoped registrations (e.g. `fn_review_spec` and
+ *    `fn_review_step` injected by the engine's triage/executor sessions).
+ * 2. `pi.getAllTools()` — fallback for older callers that don't supply
+ *    `context.tools`.
  *
- * Only locks (sets mcpConfigResolved) when getAllTools() returns a
- * real array — if it returns undefined/null (registry not ready),
- * we retry on the next request. Once the registry is ready we
- * commit to the result even if there are zero custom tools.
+ * Why not a single once-and-lock cache:
+ * - The engine spawns triage/executor sessions with session-scoped tools.
+ *   A locked-on-first-call cache silently drops them and the Claude CLI
+ *   subprocess refuses with "unknown tool fn_review_spec".
+ * - Hashing the tool defs lets us reuse temp files when the tool set is
+ *   unchanged across calls and produce fresh files (with the hash in the
+ *   filename to avoid races) when it changes.
  *
- * Uses warn-don't-block: failure logs a warning but does not
- * prevent the provider from functioning (built-ins still work).
+ * Uses warn-don't-block: failure logs a warning but does not prevent the
+ * provider from functioning (built-ins still work).
  */
-function ensureMcpConfig(pi: ExtensionAPI): string | undefined {
-  if (mcpConfigResolved) return mcpConfigPath;
+function ensureMcpConfig(
+  pi: ExtensionAPI,
+  contextTools?: ReadonlyArray<{
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  }>,
+): string | undefined {
   try {
-    const allTools = pi.getAllTools();
+    let toolDefs: McpToolDef[] = toolsFromContext(contextTools);
+
+    // Fallback to the pi runtime registry if the context didn't carry tools.
+    // (Older agent-loop versions don't populate Context.tools for streamSimple.)
+    if (toolDefs.length === 0) {
+      const allTools = pi.getAllTools();
+      if (!Array.isArray(allTools)) {
+        return cachedMcpConfig?.configPath;
+      }
+      toolDefs = getCustomToolDefs(pi);
+    }
 
-    // Registry not ready yet — don't lock, retry on next call
-    if (!Array.isArray(allTools)) {
-      return mcpConfigPath;
+    if (toolDefs.length === 0) {
+      cachedMcpConfig = undefined;
+      return undefined;
     }
 
-    // Registry is ready — lock regardless of whether custom tools exist
-    mcpConfigResolved = true;
+    const hash = createHash("sha1")
+      .update(JSON.stringify(toolDefs))
+      .digest("hex")
+      .slice(0, 12);
 
-    const toolDefs = getCustomToolDefs(pi);
-    if (toolDefs.length > 0) {
-      mcpConfigPath = writeMcpConfig(toolDefs);
-      console.error(
-        `[pi-claude-cli] MCP config generated with ${toolDefs.length} custom tool(s)`,
-      );
+    if (cachedMcpConfig?.hash === hash) {
+      return cachedMcpConfig.configPath;
     }
+
+    const configPath = writeMcpConfig(toolDefs, hash);
+    cachedMcpConfig = { hash, configPath };
+    const toolNames = toolDefs.map((t) => t.name).join(", ");
+    console.error(
+      `[pi-claude-cli] MCP config refreshed with ${toolDefs.length} custom tool(s) [${toolNames}] (hash=${hash})`,
+    );
+    return configPath;
   } catch (err) {
     console.warn(
       "[pi-claude-cli] MCP config generation failed, custom tools unavailable:",
       err,
     );
+    return cachedMcpConfig?.configPath;
   }
-  return mcpConfigPath;
 }
 
 export default function (pi: ExtensionAPI) {
@@ -118,7 +155,14 @@ export default function (pi: ExtensionAPI) {
       api: "pi-claude-cli",
       models,
       streamSimple: (model, context, options) => {
-        const configPath = ensureMcpConfig(pi);
+        const configPath = ensureMcpConfig(
+          pi,
+          (context as { tools?: ReadonlyArray<{
+            name: string;
+            description: string;
+            parameters: Record<string, unknown>;
+          }> }).tools,
+        );
         return streamViaCli(model, context, {
           ...options,
           mcpConfigPath: configPath,

package/dist/pi-claude-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.2.7",
+  "version": "1.0.0",
   "description": "Fusion vendored fork: pi coding-agent extension that routes LLM calls through the Claude Code CLI. Forked from rchern/pi-claude-cli (MIT). See UPSTREAM.md.",
   "license": "MIT",
   "private": true,

package/dist/pi-claude-cli/src/__tests__/event-bridge.test.ts

@@ -444,6 +444,40 @@ describe("createEventBridge", () => {
       expect(event.toolCall.arguments).toEqual({ path: "/foo.ts" });
     });
 
+    it("emits {} for parameterless MCP tool calls (no input_json_delta)", () => {
+      // Parameterless MCP tools (e.g. fn_review_spec, schema
+      // {type:"object", properties:{}}) emit ZERO input_json_delta events.
+      // Without the empty-partialJson guard, finalArgs would fall through to
+      // the raw-string fallback ("") and pi's TypeBox validator would reject
+      // the call with "Validation failed for tool ...: root: must be object".
+      const bridge = createBridgeWithStart();
+      bridge.handleEvent({
+        type: "content_block_start",
+        index: 0,
+        content_block: {
+          type: "tool_use",
+          id: "toolu_01XYZ",
+          name: "mcp__custom-tools__fn_review_spec",
+        },
+      });
+      // No content_block_delta with input_json_delta — Claude emits none for
+      // parameterless tools.
+      stream.push.mockClear();
+      stream.events.length = 0;
+
+      bridge.handleEvent({
+        type: "content_block_stop",
+        index: 0,
+      });
+
+      expect(stream.push).toHaveBeenCalledTimes(1);
+      const event = stream.events[0] as any;
+      expect(event.type).toBe("toolcall_end");
+      expect(event.toolCall.arguments).toEqual({});
+      // The MCP prefix should be stripped: pi sees the bare tool name.
+      expect(event.toolCall.name).toBe("fn_review_spec");
+    });
+
     it("tracks multiple tool_use blocks independently by Claude event.index", () => {
       const bridge = createBridgeWithStart();
 

package/dist/pi-claude-cli/src/__tests__/mcp-config.test.ts

@@ -269,4 +269,26 @@ describe("writeMcpConfig", () => {
     expect(result).toMatch(/pi-claude-mcp-config/);
     expect(result).toMatch(/\.json$/);
   });
+
+  it("includes cacheKey in filenames when provided so distinct tool sets do not collide", () => {
+    const toolDefs: McpToolDef[] = [
+      {
+        name: "search",
+        description: "Search",
+        inputSchema: { type: "object" },
+      },
+    ];
+
+    const pathA = writeMcpConfig(toolDefs, "aaaaaaaaaaaa");
+    const pathB = writeMcpConfig(toolDefs, "bbbbbbbbbbbb");
+
+    expect(pathA).toContain("aaaaaaaaaaaa");
+    expect(pathB).toContain("bbbbbbbbbbbb");
+    expect(pathA).not.toBe(pathB);
+
+    const schemaPathA = mocks.writeFileSync.mock.calls[0][0];
+    const schemaPathB = mocks.writeFileSync.mock.calls[2][0];
+    expect(schemaPathA).toContain("aaaaaaaaaaaa");
+    expect(schemaPathB).toContain("bbbbbbbbbbbb");
+  });
 });

package/dist/pi-claude-cli/src/__tests__/prompt-builder.test.ts

@@ -21,7 +21,7 @@ describe("buildPrompt", () => {
     expect(buildPrompt(context)).toBe("ASSISTANT:\nHi there");
   });
 
-  it("produces 'TOOL RESULT (historical {claudeName}):\\n{content}' for a tool result message", () => {
+  it("produces 'TOOL RESULT ({claudeName}):\\n{content}' for a tool result message", () => {
     const context = {
       messages: [
         {
@@ -33,7 +33,7 @@ describe("buildPrompt", () => {
     } as unknown as any;
     // Pi tool name "read" should be mapped to Claude name "Read" in the label
     expect(buildPrompt(context)).toBe(
-      "TOOL RESULT (historical Read):\nfile contents here",
+      "TOOL RESULT (Read):\nfile contents here",
     );
   });
 
@@ -57,7 +57,7 @@ describe("buildPrompt", () => {
       "What is in file.ts?",
       "ASSISTANT:",
       "Let me read that file.",
-      "TOOL RESULT (historical Read):",
+      "TOOL RESULT (Read):",
       "export const x = 1;",
       "USER:",
       "Now explain it.",
@@ -109,7 +109,7 @@ describe("buildPrompt", () => {
     // Tool name should be mapped from pi "read" to Claude "Read"
     // Arg "path" should be mapped from pi format to Claude "file_path"
     expect(result).toContain(
-      'Historical tool call (non-executable): Read args={"file_path":"/file.ts"}',
+      '[Prior tool call — already executed; result follows in TOOL RESULT (Read):] args={"file_path":"/file.ts"}',
     );
   });
 
@@ -158,7 +158,7 @@ describe("buildPrompt", () => {
     const result = buildPrompt(context);
     // Pi "bash" maps to Claude "Bash"
     expect(result).toContain(
-      "Historical tool call (non-executable): Bash args={}",
+      "[Prior tool call — already executed; result follows in TOOL RESULT (Bash):] args={}",
     );
   });
 
@@ -177,7 +177,7 @@ describe("buildPrompt", () => {
     } as unknown as any;
 
     const result = buildPrompt(context);
-    expect(result).toBe("TOOL RESULT (historical Bash):\nline 1\nline 2");
+    expect(result).toBe("TOOL RESULT (Bash):\nline 1\nline 2");
   });
 
   describe("tool name and argument reverse mapping", () => {
@@ -237,7 +237,7 @@ describe("buildPrompt", () => {
       } as unknown as any;
 
       const result = buildPrompt(context);
-      expect(result).toContain("TOOL RESULT (historical Read):");
+      expect(result).toContain("TOOL RESULT (Read):");
     });
 
     it("prefixes custom (non-built-in) tool names with MCP prefix", () => {
@@ -281,7 +281,8 @@ describe("buildPrompt", () => {
 
       const result = buildPrompt(context);
       // String arguments should be serialized as JSON string
-      expect(result).toContain('Read args="raw string args"');
+      expect(result).toContain('TOOL RESULT (Read):');
+      expect(result).toContain('args="raw string args"');
     });
   });
 });
@@ -688,7 +689,7 @@ describe("custom tool history replay", () => {
     } as unknown as any;
 
     const result = buildPrompt(context);
-    expect(result).toContain("TOOL RESULT (historical Read):");
+    expect(result).toContain("TOOL RESULT (Read):");
     expect(result).not.toContain("mcp__custom-tools__");
   });
 
@@ -910,6 +911,67 @@ describe("buildSystemPrompt", () => {
     expect(result).toContain("IMPORTANT:");
     expect(result).toContain("tool results");
   });
+
+  it("rewrites bare custom tool references to MCP-prefixed names", async () => {
+    vi.resetModules();
+    vi.doMock("node:fs", () => ({
+      existsSync: () => false,
+      readFileSync: () => "",
+    }));
+
+    const { buildSystemPrompt: bsp } = await import("../prompt-builder");
+    const context = {
+      systemPrompt:
+        "Write the PROMPT.md, then call `fn_review_spec()` for review. " +
+        "If REVISE, call fn_review_spec again. Do not call mcp__custom-tools__fn_review_spec twice manually.",
+      messages: [],
+      tools: [
+        { name: "fn_review_spec", description: "review", parameters: {} },
+        { name: "read", description: "builtin", parameters: {} },
+      ],
+    } as unknown as any;
+    const result = bsp(context, "/some/project");
+
+    // Bare name occurrences are rewritten
+    expect(result).toContain(
+      "call `mcp__custom-tools__fn_review_spec()` for review",
+    );
+    expect(result).toContain(
+      "call mcp__custom-tools__fn_review_spec again",
+    );
+    // Already-prefixed occurrence is not double-prefixed
+    expect(result).not.toContain(
+      "mcp__custom-tools__mcp__custom-tools__fn_review_spec",
+    );
+    // Built-in pi tool names are not rewritten
+    expect(result).not.toContain("mcp__custom-tools__read");
+    // The addendum still lists the custom tool with its full mapping
+    expect(result).toContain("mcp__custom-tools__fn_review_spec");
+  });
+
+  it("does not rewrite identifier substrings that happen to overlap a tool name", async () => {
+    vi.resetModules();
+    vi.doMock("node:fs", () => ({
+      existsSync: () => false,
+      readFileSync: () => "",
+    }));
+
+    const { buildSystemPrompt: bsp } = await import("../prompt-builder");
+    const context = {
+      systemPrompt: "fn_review_specifier and fn_reviews are not the tool.",
+      messages: [],
+      tools: [
+        { name: "fn_review", description: "x", parameters: {} },
+        { name: "fn_review_spec", description: "y", parameters: {} },
+      ],
+    } as unknown as any;
+    const result = bsp(context, "/some/project");
+    // Neither substring should be rewritten — they're different identifiers.
+    expect(result).toContain("fn_review_specifier");
+    expect(result).toContain("fn_reviews");
+    expect(result).not.toContain("mcp__custom-tools__fn_review_specifier");
+    expect(result).not.toContain("mcp__custom-tools__fn_reviews");
+  });
 });
 
 describe("buildResumePrompt", () => {
@@ -958,7 +1020,7 @@ describe("buildResumePrompt", () => {
       ],
     };
     const result = buildResumePrompt(context) as string;
-    expect(result).toContain("TOOL RESULT (historical Read):");
+    expect(result).toContain("TOOL RESULT (Read):");
     expect(result).toContain("file contents here");
     expect(result).toContain("Now explain it");
   });

package/dist/pi-claude-cli/src/__tests__/provider.test.ts

@@ -1292,7 +1292,7 @@ describe("streamViaCli", () => {
   });
 
   describe("inactivity timeout", () => {
-    it("kills subprocess and pushes error after 180s of no output", async () => {
+    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" }],
@@ -1303,8 +1303,8 @@ describe("streamViaCli", () => {
 
       const proc = (spawn as any).mock.results[0].value;
 
-      // Advance timers by 180 seconds without writing to stdout
-      await vi.advanceTimersByTimeAsync(180_000);
+      // 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(
@@ -1330,8 +1330,8 @@ describe("streamViaCli", () => {
 
       const proc = (spawn as any).mock.results[0].value;
 
-      // Advance to 170s then write a line
-      await vi.advanceTimersByTimeAsync(170_000);
+      // Advance to 290s then write a line (just under the 300s cap)
+      await vi.advanceTimersByTimeAsync(1_790_000);
 
       // Write a stream event line
       proc.stdout.write(
@@ -1345,8 +1345,8 @@ describe("streamViaCli", () => {
       );
       await vi.advanceTimersByTimeAsync(0);
 
-      // Advance another 170s (340s total, 170s since last line) -- should NOT timeout
-      await vi.advanceTimersByTimeAsync(170_000);
+      // Advance another 290s (580s total, 290s since last line) -- should NOT timeout
+      await vi.advanceTimersByTimeAsync(1_790_000);
 
       const mockStream = MockAssistantMessageEventStream.mock.instances[0];
       const doneEvent = mockStream._events.find(
@@ -1354,7 +1354,7 @@ describe("streamViaCli", () => {
       );
       expect(doneEvent).toBeUndefined();
 
-      // Advance 10 more seconds (180s since last line) -- NOW should timeout
+      // Advance 10 more seconds (1800s since last line) -- NOW should timeout
       await vi.advanceTimersByTimeAsync(10_000);
 
       const doneEvent2 = mockStream._events.find(
@@ -1401,7 +1401,7 @@ describe("streamViaCli", () => {
       await vi.advanceTimersByTimeAsync(100);
 
       // Advance past 180s -- should NOT timeout since result was received
-      await vi.advanceTimersByTimeAsync(180_000);
+      await vi.advanceTimersByTimeAsync(1_800_000);
 
       const mockStream = MockAssistantMessageEventStream.mock.instances[0];
       const errorEvents = mockStream._events.filter(

package/dist/pi-claude-cli/src/event-bridge.ts

@@ -323,13 +323,24 @@ export function createEventBridge(
         partial: output,
       });
     } else if (block.type === "tool_use") {
-      // Final JSON parse with fallback to raw string
+      // Final JSON parse with fallback to raw string.
+      // Special case: parameterless MCP tools (e.g. fn_review_spec, schema
+      // `{type:"object", properties:{}}`) emit ZERO input_json_delta events,
+      // so `partialJson` stays "". Without this guard we'd JSON.parse("")
+      // → throw → fall through to `finalArgs = ""` (raw string), and pi's
+      // TypeBox validator then rejects with "root: must be object" because
+      // an empty string is not an object. Default to `{}` so the call lands.
       let finalArgs: Record<string, unknown> | string;
-      try {
-        const parsed = JSON.parse(block.partialJson);
-        finalArgs = translateClaudeArgsToPi(block.claudeName, parsed);
-      } catch {
-        finalArgs = block.partialJson;
+      const trimmedJson = block.partialJson.trim();
+      if (trimmedJson === "") {
+        finalArgs = {};
+      } else {
+        try {
+          const parsed = JSON.parse(trimmedJson);
+          finalArgs = translateClaudeArgsToPi(block.claudeName, parsed);
+        } catch {
+          finalArgs = block.partialJson;
+        }
       }
 
       // Update output.content with final arguments

package/dist/pi-claude-cli/src/mcp-config.ts

@@ -67,6 +67,31 @@ export function getCustomToolDefs(pi: PiInstance): McpToolDef[] {
     }));
 }
 
+/** Minimal pi-ai Tool shape (the subset we need from `Context.tools`). */
+interface PiAiToolLike {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+}
+
+/**
+ * Convert the pi-ai `Context.tools` array (the authoritative per-session tool
+ * list pi-coding-agent passes to streamSimple) into MCP tool defs, filtering
+ * out the 6 built-ins that pi handles natively.
+ */
+export function toolsFromContext(
+  contextTools: ReadonlyArray<PiAiToolLike> | undefined,
+): McpToolDef[] {
+  if (!Array.isArray(contextTools)) return [];
+  return contextTools
+    .filter((tool) => !BUILT_IN_TOOL_NAMES.has(tool.name))
+    .map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.parameters,
+    }));
+}
+
 /**
  * Write MCP config and tool schemas to temp files.
  *
@@ -75,13 +100,21 @@ export function getCustomToolDefs(pi: PiInstance): McpToolDef[] {
  * 2. Config file: MCP config pointing to the schema-only server
  *
  * @param toolDefs - Array of custom tool definitions
+ * @param cacheKey - Optional suffix appended to filenames so that distinct
+ *   tool sets (e.g. session-scoped tool registrations) get distinct files
+ *   and don't race on a single shared path.
  * @returns Path to the MCP config file
  */
-export function writeMcpConfig(toolDefs: McpToolDef[]): string {
+export function writeMcpConfig(
+  toolDefs: McpToolDef[],
+  cacheKey?: string,
+): string {
+  const suffix = cacheKey ? `${process.pid}-${cacheKey}` : `${process.pid}`;
+
   // Write tool schemas to temp file
   const schemaFilePath = join(
     tmpdir(),
-    `pi-claude-mcp-schemas-${process.pid}.json`,
+    `pi-claude-mcp-schemas-${suffix}.json`,
   );
   writeFileSync(schemaFilePath, JSON.stringify(toolDefs));
 
@@ -103,7 +136,7 @@ export function writeMcpConfig(toolDefs: McpToolDef[]): string {
   // Write config to temp file
   const configFilePath = join(
     tmpdir(),
-    `pi-claude-mcp-config-${process.pid}.json`,
+    `pi-claude-mcp-config-${suffix}.json`,
   );
   writeFileSync(configFilePath, JSON.stringify(config));