@tyvm/knowhow 0.0.137 → 0.0.140

package/tests/chat/detach-attach-rendering.test.ts

@@ -0,0 +1,315 @@
+
+/**
+ * Tests for detach / re-attach rendering correctness.
+ *
+ * Bug: after calling /detach and then /attach again, the agent's tool calls
+ * and messages were not rendering to the console.
+ *
+ * Root cause: both SessionsModule.attachToFsAgent / attachToWebAgent AND
+ * AgentModule.attachedAgentChatLoop were calling wireAgentRendering().
+ * Since wireAgentRendering uses setListener (keyed, replaces-on-conflict),
+ * the second call on the SAME EventService replaced the first — but the
+ * watcher's `done` event handler registered by SessionsModule was also
+ * removed. More critically: after /detach, unwireAgentRendering() removes
+ * the keyed listeners from `_wireAgentEvents` and clears the stored ref.
+ * On re-attach a new FsSyncedAgentWatcher is created with a fresh
+ * EventService, but the double-wire means the stored `_wireAgentEvents`
+ * ref held by the AgentModule was pointing at the WRONG EventService
+ * (the one from the second wireAgentRendering call).
+ *
+ * The fix: SessionsModule no longer calls wireAgentRendering itself —
+ * it delegates entirely to attachedAgentChatLoop which already calls it.
+ *
+ * These tests verify the wireAgentRendering / unwireAgentRendering contract
+ * using real EventService instances so we catch regressions in EventService
+ * changes too.
+ */
+
+import { EventService } from "../../src/services/EventService";
+
+// ─── Minimal harness that mirrors AgentModule's wire/unwire logic exactly ────
+
+const EVENT_TYPES = {
+  done: "done",
+  toolCall: "tool:pre_call",
+  toolUsed: "tool:post_call",
+  agentSay: "agent:say",
+  threadUpdate: "thread_update",
+};
+
+interface RenderEvent {
+  type: string;
+  taskId: string;
+  agentName: string;
+  data: any;
+}
+
+class RenderingHarness {
+  // Mirror of AgentModule's stored wire params
+  private _wireAgentEvents: EventService | undefined;
+  private _wireTaskId: string | undefined;
+  private _wireAgentName: string | undefined;
+  private _wireEventTypes:
+    | { toolCall?: string; toolUsed?: string; agentSay?: string; done: string }
+    | undefined;
+
+  public rendered: RenderEvent[] = [];
+
+  /**
+   * Mirrors AgentModule.wireAgentRendering exactly (uses real EventService.setListener).
+   */
+  wireAgentRendering(
+    taskId: string,
+    agentEvents: EventService,
+    eventTypes: { toolCall?: string; toolUsed?: string; agentSay?: string; done: string },
+    agentName: string
+  ): void {
+    if (eventTypes.toolCall) {
+      agentEvents.setListener(
+        { key: "agentModule:render:toolCall", event: eventTypes.toolCall },
+        (data: any) => this.rendered.push({ type: "toolCall", taskId, agentName, data })
+      );
+    }
+    if (eventTypes.toolUsed) {
+      agentEvents.setListener(
+        { key: "agentModule:render:toolUsed", event: eventTypes.toolUsed },
+        (data: any) => this.rendered.push({ type: "toolResult", taskId, agentName, data })
+      );
+    }
+    if (eventTypes.agentSay) {
+      agentEvents.setListener(
+        { key: "agentModule:render:agentSay", event: eventTypes.agentSay },
+        (data: any) => this.rendered.push({ type: "agentMessage", taskId, agentName, data })
+      );
+    }
+    this._wireAgentEvents = agentEvents;
+    this._wireTaskId = taskId;
+    this._wireAgentName = agentName;
+    this._wireEventTypes = eventTypes;
+  }
+
+  /**
+   * Mirrors AgentModule.unwireAgentRendering exactly.
+   */
+  unwireAgentRendering(): void {
+    if (this._wireAgentEvents) {
+      this._wireAgentEvents.removeManagedListenersByPrefix("agentModule:render:");
+      this._wireAgentEvents = undefined;
+    }
+    this._wireTaskId = undefined;
+    this._wireAgentName = undefined;
+    this._wireEventTypes = undefined;
+  }
+
+  reset() {
+    this.rendered = [];
+  }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("detach / re-attach rendering", () => {
+  let harness: RenderingHarness;
+
+  beforeEach(() => {
+    harness = new RenderingHarness();
+  });
+
+  // 1. Basic: emitted events reach the renderer after wireAgentRendering ────────
+
+  it("emitted events reach the renderer after wireAgentRendering", () => {
+    const events = new EventService();
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
+
+    events.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "execCommand" } } });
+    events.emit(EVENT_TYPES.agentSay, { message: "hello" });
+    events.emit(EVENT_TYPES.toolUsed, { toolCall: {}, functionResp: "output" });
+
+    expect(harness.rendered).toHaveLength(3);
+    expect(harness.rendered[0].type).toBe("toolCall");
+    expect(harness.rendered[1].type).toBe("agentMessage");
+    expect(harness.rendered[2].type).toBe("toolResult");
+  });
+
+  // 2. After detach (unwire), old EventService no longer triggers renders ───────
+
+  it("old EventService does NOT render after unwireAgentRendering (detach)", () => {
+    const events = new EventService();
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
+
+    // Verify wired first
+    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    expect(harness.rendered).toHaveLength(1);
+    harness.reset();
+
+    // Detach
+    harness.unwireAgentRendering();
+
+    // Emit on the OLD EventService — nothing should render
+    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    events.emit(EVENT_TYPES.agentSay, { message: "zombie" });
+    events.emit(EVENT_TYPES.toolUsed, { toolCall: {}, functionResp: "output" });
+
+    expect(harness.rendered).toHaveLength(0);
+  });
+
+  // 3. Re-attach on a NEW EventService renders correctly ───────────────────────
+
+  it("events on a NEW EventService render after re-wiring (re-attach)", () => {
+    const oldEvents = new EventService();
+    harness.wireAgentRendering("task-1", oldEvents, EVENT_TYPES, "Dev");
+    harness.unwireAgentRendering();
+
+    // Re-attach: new watcher = new EventService
+    const newEvents = new EventService();
+    harness.wireAgentRendering("task-1", newEvents, EVENT_TYPES, "Dev");
+
+    newEvents.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "readFile" } } });
+    newEvents.emit(EVENT_TYPES.agentSay, { message: "re-attached message" });
+
+    expect(harness.rendered).toHaveLength(2);
+    expect(harness.rendered[0].type).toBe("toolCall");
+    expect(harness.rendered[0].data.toolCall.function.name).toBe("readFile");
+    expect(harness.rendered[1].type).toBe("agentMessage");
+    expect(harness.rendered[1].data.message).toBe("re-attached message");
+  });
+
+  // 4. Old EventService still silent after re-attach on new EventService ────────
+
+  it("old EventService stays silent after re-attach on new EventService", () => {
+    const oldEvents = new EventService();
+    harness.wireAgentRendering("task-1", oldEvents, EVENT_TYPES, "Dev");
+    harness.unwireAgentRendering();
+
+    const newEvents = new EventService();
+    harness.wireAgentRendering("task-1", newEvents, EVENT_TYPES, "Dev");
+
+    // New events render
+    newEvents.emit(EVENT_TYPES.agentSay, { message: "new" });
+    expect(harness.rendered).toHaveLength(1);
+
+    // Old events still silent
+    oldEvents.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    oldEvents.emit(EVENT_TYPES.agentSay, { message: "old" });
+    expect(harness.rendered).toHaveLength(1); // unchanged
+  });
+
+  // 5. Double-wire on the SAME EventService does NOT double-render ──────────────
+  //
+  // This is the bug that existed: SessionsModule.attachToFsAgent called
+  // wireAgentRendering, then attachedAgentChatLoop also called it.
+  // Since setListener is keyed (replaces), the net result is one listener —
+  // but the done handler registered by SessionsModule was lost.
+  // The fix removes the extra wireAgentRendering from SessionsModule.
+
+  it("calling wireAgentRendering twice on same EventService does NOT double-render", () => {
+    const events = new EventService();
+
+    // Simulate the OLD (buggy) behavior: SessionsModule wires, then attachedAgentChatLoop wires again
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev"); // first call
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev"); // second call (setListener replaces)
+
+    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+
+    // setListener keyed — only ONE render expected, not two
+    expect(harness.rendered).toHaveLength(1);
+  });
+
+  // 6. Full cycle: attach → emit → detach → re-attach → emit all render correctly
+
+  it("full attach → detach → re-attach cycle: all phases render correctly", () => {
+    // ── First attach ──────────────────────────────────────────────────────────
+    const watcher1 = new EventService();
+    harness.wireAgentRendering("task-A", watcher1, EVENT_TYPES, "Developer");
+
+    watcher1.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "execCommand" } } });
+    watcher1.emit(EVENT_TYPES.agentSay, { message: "initial work" });
+    expect(harness.rendered).toHaveLength(2);
+    harness.reset();
+
+    // ── /detach ───────────────────────────────────────────────────────────────
+    harness.unwireAgentRendering();
+
+    // Events from watcher1 after detach should NOT render
+    watcher1.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    watcher1.emit(EVENT_TYPES.agentSay, { message: "zombie message" });
+    expect(harness.rendered).toHaveLength(0);
+
+    // ── Re-attach (new FsSyncedAgentWatcher creates a new EventService) ───────
+    const watcher2 = new EventService();
+    harness.wireAgentRendering("task-A", watcher2, EVENT_TYPES, "Developer");
+
+    watcher2.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "readFile" } } });
+    watcher2.emit(EVENT_TYPES.agentSay, { message: "continuing after re-attach" });
+
+    // THE CRITICAL ASSERTION: renders must arrive after re-attach
+    expect(harness.rendered).toHaveLength(2);
+    expect(harness.rendered[0].type).toBe("toolCall");
+    expect(harness.rendered[0].data.toolCall.function.name).toBe("readFile");
+    expect(harness.rendered[1].type).toBe("agentMessage");
+    expect(harness.rendered[1].data.message).toBe("continuing after re-attach");
+  });
+
+  // 7. toolResult renders after re-attach ──────────────────────────────────────
+
+  it("toolResult events render after re-attach", () => {
+    const events1 = new EventService();
+    harness.wireAgentRendering("task-1", events1, EVENT_TYPES, "Dev");
+    harness.unwireAgentRendering();
+
+    const events2 = new EventService();
+    harness.wireAgentRendering("task-1", events2, EVENT_TYPES, "Dev");
+
+    events2.emit(EVENT_TYPES.toolUsed, {
+      toolCall: { function: { name: "execCommand" } },
+      functionResp: "$ echo hello\nhello",
+    });
+
+    expect(harness.rendered).toHaveLength(1);
+    expect(harness.rendered[0].type).toBe("toolResult");
+    expect(harness.rendered[0].data.functionResp).toBe("$ echo hello\nhello");
+  });
+
+  // 8. Multiple sequential attach/detach cycles all work ───────────────────────
+
+  it("3 sequential attach/detach cycles all render correctly", () => {
+    for (let i = 0; i < 3; i++) {
+      harness.reset();
+      const events = new EventService();
+      harness.wireAgentRendering(`task-${i}`, events, EVENT_TYPES, "Dev");
+
+      events.emit(EVENT_TYPES.agentSay, { message: `cycle ${i}` });
+      expect(harness.rendered).toHaveLength(1);
+      expect(harness.rendered[0].data.message).toBe(`cycle ${i}`);
+      expect(harness.rendered[0].taskId).toBe(`task-${i}`);
+
+      // Detach: old events stop rendering
+      harness.unwireAgentRendering();
+      events.emit(EVENT_TYPES.agentSay, { message: "should not render" });
+      expect(harness.rendered).toHaveLength(1); // still 1, not 2
+    }
+  });
+
+  // 9. hasManagedListener confirms listener is present/absent at right times ───
+
+  it("hasManagedListener reflects wired/unwired state correctly", () => {
+    const events = new EventService();
+
+    // Before wiring: no managed render listeners
+    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(false);
+    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(false);
+
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
+
+    // After wiring: listeners registered
+    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(true);
+    expect(events.hasManagedListener("agentModule:render:toolUsed")).toBe(true);
+    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(true);
+
+    harness.unwireAgentRendering();
+
+    // After detach: listeners removed
+    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(false);
+    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(false);
+  });
+});

package/tests/clients/contextLimits.test.ts

@@ -4,6 +4,27 @@
  */
 import { Models } from "../../src/types";
 import { ContextLimits, getModelContextLimit, DEFAULT_CONTEXT_LIMIT } from "../../src/clients/contextLimits";
+import {
+  OpenAiTextPricing,
+  GeminiTextPricing,
+  AnthropicTextPricing,
+  XaiTextPricing,
+} from "../../src/clients/pricing";
+
+// Model ids explicitly marked deprecated across all pricing tables. Deprecated
+// models are allowed to be absent from ContextLimits — they can be trimmed from
+// Models.* / the context-limit map without breaking anything, since cost
+// tracking reads the *TextPricing tables directly by model id.
+const deprecatedModelIds = new Set<string>(
+  Object.entries({
+    ...OpenAiTextPricing,
+    ...GeminiTextPricing,
+    ...AnthropicTextPricing,
+    ...XaiTextPricing,
+  } as Record<string, { deprecated?: boolean }>)
+    .filter(([, p]) => p && p.deprecated === true)
+    .map(([id]) => id)
+);
 
 describe("ContextLimits", () => {
   describe("coverage - all Models.* values have a recorded context limit", () => {
@@ -19,7 +40,8 @@ describe("ContextLimits", () => {
         });
 
         for (const [key, modelId] of modelEntries) {
-          it(`${provider}.${key} (${modelId}) should have a context limit`, () => {
+          const testFn = deprecatedModelIds.has(modelId) ? it.skip : it;
+          testFn(`${provider}.${key} (${modelId}) should have a context limit`, () => {
             const limit = ContextLimits[modelId];
             expect(limit).toBeDefined();
             expect(typeof limit).toBe("number");

package/tests/clients/pricing.test.ts

@@ -150,15 +150,34 @@ describe("Model Catalog Coverage", () => {
    * Every model defined in Models.* and EmbeddingModels.* must have an entry
    * in ALL_MODEL_CATALOG. This ensures the catalog stays in sync and is the
    * single source of truth for model metadata and pricing.
+   *
+   * Exception: models flagged `deprecated` in their pricing entry are allowed to
+   * be absent from the catalog. Cost tracking for historical usage still works
+   * because calculateCost() reads the *TextPricing tables directly by model id,
+   * independently of the catalog — so deprecated models can be trimmed from the
+   * catalog/Models.* without breaking cost calculation.
    */
   const catalogIds = new Set(ALL_MODEL_CATALOG.map((m) => m.id));
 
+  // Model ids explicitly marked deprecated across all pricing tables.
+  const deprecatedModelIds = new Set<string>(
+    Object.entries({
+      ...OpenAiTextPricing,
+      ...GeminiTextPricing,
+      ...AnthropicTextPricing,
+      ...XaiTextPricing,
+    } as Record<string, { deprecated?: boolean }>)
+      .filter(([, p]) => p && p.deprecated === true)
+      .map(([id]) => id)
+  );
+
   describe("All Models.* entries are in the catalog", () => {
     for (const [provider, providerModels] of Object.entries(Models)) {
       for (const [modelKey, modelId] of Object.entries(
         providerModels as Record<string, string>
       )) {
-        it(`Models.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
+        const testFn = deprecatedModelIds.has(modelId) ? it.skip : it;
+        testFn(`Models.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
           expect(catalogIds.has(modelId)).toBe(true);
         });
       }

package/tests/services/Tools.test.ts

@@ -1,4 +1,4 @@
-import { ToolsService, ToolContext } from "../../src/services/Tools";
+import { ToolsService, ToolContext, ToolCallContext } from "../../src/services/Tools";
 import { Tool, ToolCall } from "../../src/clients/types";
 import { createPatternMatcher } from "../../src/services/types";
 import { AgentService } from "../../src/services/AgentService";
@@ -268,7 +268,11 @@ describe("ToolsService", () => {
 
       const result = await toolsService.callTool(mockToolCall);
 
-      expect(mockFunction).toHaveBeenCalledWith({ input: "test value" });
+      // Non-positional tools receive `_ctx` merged onto the args object.
+      expect(mockFunction).toHaveBeenCalledWith(
+        expect.objectContaining({ input: "test value" })
+      );
+      expect(mockFunction.mock.calls[0][0]._ctx).toBeDefined();
       expect(result.toolMessages).toHaveLength(1);
       expect(result.toolMessages[0]).toEqual({
         tool_call_id: "call_123",
@@ -312,7 +316,12 @@ describe("ToolsService", () => {
 
       await toolsService.callTool(positionalCall);
 
-      expect(mockFunction).toHaveBeenCalledWith("hello", 42);
+      // Positional tools receive `_ctx` as the LAST positional argument.
+      expect(mockFunction).toHaveBeenCalledWith(
+        "hello",
+        42,
+        expect.objectContaining({ Tools: expect.anything() })
+      );
     });
 
     it("should handle tool not enabled error", async () => {
@@ -433,7 +442,10 @@ describe("ToolsService", () => {
 
       await toolsService.callTool(toolCallWithStringArgs);
 
-      expect(mockFunction).toHaveBeenCalledWith({ input: "escaped\nstring" });
+      expect(mockFunction).toHaveBeenCalledWith(
+        expect.objectContaining({ input: "escaped\nstring" })
+      );
+      expect(mockFunction.mock.calls[0][0]._ctx).toBeDefined();
     });
   });
   describe("Tool Override System", () => {
@@ -492,8 +504,9 @@ describe("ToolsService", () => {
 
       const result = await toolsService.callTool(toolCall);
 
+      // Non-positional args now include `_ctx`; the override receives them in an array.
       expect(overrideFunction).toHaveBeenCalledWith(
-        [{ input: "test" }],
+        [expect.objectContaining({ input: "test" })],
         expect.any(Object)
       );
       expect(originalFunction).not.toHaveBeenCalled();
@@ -627,7 +640,9 @@ describe("ToolsService", () => {
       const result = await toolsService.callTool(toolCall);
 
       expect(wrapperFunction).toHaveBeenCalled();
-      expect(originalFunction).toHaveBeenCalledWith({ input: "test" });
+      expect(originalFunction).toHaveBeenCalledWith(
+        expect.objectContaining({ input: "test" })
+      );
       expect(result.functionResp).toBe("wrapped: original result");
     });
 
@@ -841,7 +856,8 @@ describe("ToolsService", () => {
 
       const result = await toolsService.callTool(noParamCall);
 
-      expect(mockFunction).toHaveBeenCalledWith({});
+      expect(mockFunction).toHaveBeenCalledWith(expect.any(Object));
+      expect(mockFunction.mock.calls[0][0]._ctx).toBeDefined();
       expect(result.functionResp).toBe("no param result");
     });
 
@@ -897,14 +913,16 @@ describe("ToolsService", () => {
 
       const result = await toolsService.callTool(complexCall);
 
-      expect(mockFunction).toHaveBeenCalledWith({
+      expect(mockFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
         config: {
           settings: [
             { key: "timeout", value: 5000 },
             { key: "retries", value: 3 },
           ],
         },
-      });
+        })
+      );
       expect(result.functionResp).toBe("complex result");
     });
 
@@ -1570,4 +1588,149 @@ describe("ToolsService", () => {
       expect(foundTools.map(t => t.function.name)).toContain("tool2");
     });
   });
+
+  describe("_ctx per-call context threading", () => {
+    const positionalTool: Tool = {
+      type: "function",
+      function: {
+        name: "posCtxTool",
+        parameters: {
+          type: "object",
+          positional: true,
+          properties: {
+            arg1: { type: "string" },
+          },
+          required: ["arg1"],
+        },
+      },
+    };
+
+    const nonPositionalTool: Tool = {
+      type: "function",
+      function: {
+        name: "nonPosCtxTool",
+        parameters: {
+          type: "object",
+          properties: {
+            input: { type: "string" },
+          },
+          required: ["input"],
+        },
+      },
+    };
+
+    it("passes _ctx as the last positional argument for positional tools", async () => {
+      const fn = jest.fn().mockResolvedValue("ok");
+      toolsService.addTool(positionalTool);
+      toolsService.setFunction("posCtxTool", fn);
+
+      const caller = { name: "TestAgent" };
+      await toolsService.callTool(
+        {
+          id: "c1",
+          type: "function",
+          function: {
+            name: "posCtxTool",
+            arguments: JSON.stringify({ arg1: "hello" }),
+          },
+        },
+        undefined,
+        { caller, taskId: "task-123" }
+      );
+
+      const callArgs = fn.mock.calls[0];
+      expect(callArgs[0]).toBe("hello");
+      const ctx = callArgs[1] as ToolCallContext;
+      expect(ctx).toBeDefined();
+      expect(ctx.caller).toBe(caller);
+      expect(ctx.taskId).toBe("task-123");
+      expect(ctx.Tools).toBe(toolsService);
+    });
+
+    it("merges _ctx onto the args object for non-positional tools", async () => {
+      const fn = jest.fn().mockResolvedValue("ok");
+      toolsService.addTool(nonPositionalTool);
+      toolsService.setFunction("nonPosCtxTool", fn);
+
+      const caller = { name: "TestAgent" };
+      await toolsService.callTool(
+        {
+          id: "c2",
+          type: "function",
+          function: {
+            name: "nonPosCtxTool",
+            arguments: JSON.stringify({ input: "value" }),
+          },
+        },
+        undefined,
+        { caller, taskId: "task-456" }
+      );
+
+      const argObj = fn.mock.calls[0][0];
+      expect(argObj.input).toBe("value");
+      expect(argObj._ctx).toBeDefined();
+      expect(argObj._ctx.caller).toBe(caller);
+      expect(argObj._ctx.taskId).toBe("task-456");
+      expect(argObj._ctx.Tools).toBe(toolsService);
+    });
+
+    it("still provides a _ctx (with Tools) when no callContext is passed", async () => {
+      const fn = jest.fn().mockResolvedValue("ok");
+      toolsService.addTool(nonPositionalTool);
+      toolsService.setFunction("nonPosCtxTool", fn);
+
+      await toolsService.callTool({
+        id: "c3",
+        type: "function",
+        function: {
+          name: "nonPosCtxTool",
+          arguments: JSON.stringify({ input: "value" }),
+        },
+      });
+
+      const argObj = fn.mock.calls[0][0];
+      expect(argObj._ctx).toBeDefined();
+      expect(argObj._ctx.Tools).toBe(toolsService);
+      expect(argObj._ctx.caller).toBeUndefined();
+    });
+
+    it("does not leak _ctx into the multi_tool_use.parallel extraction", async () => {
+      // The parallel path should extract calls from the ORIGINAL args, not the
+      // _ctx-augmented ones.
+      const parallelTool: Tool = {
+        type: "function",
+        function: {
+          name: "multi_tool_use.parallel",
+          parameters: { type: "object", properties: {} },
+        },
+      };
+      const inner = jest
+        .fn()
+        .mockResolvedValue(["r1", "r2"]);
+      toolsService.addTool(parallelTool);
+      toolsService.setFunction("multi_tool_use.parallel", inner);
+
+      const result = await toolsService.callTool(
+        {
+          id: "c4",
+          type: "function",
+          function: {
+            name: "multi_tool_use.parallel",
+            arguments: JSON.stringify([
+              { recipient_name: "functions.a", parameters: {} },
+              { recipient_name: "functions.b", parameters: {} },
+            ]),
+          },
+        },
+        undefined,
+        { caller: {}, taskId: "t" }
+      );
+
+      // Two tool messages, one per parallel call — proves extraction used the
+      // original array shape rather than an _ctx-wrapped object.
+      expect(result.toolMessages).toHaveLength(2);
+      expect(result.toolMessages[0].name).toBe("a");
+      expect(result.toolMessages[1].name).toBe("b");
+    });
+  });
 });