fix(provider): recover parallel call arguments on done for all responses

Author: TheGreatAxios

src/provider/codex-responses-sse.test.ts

@@ -7,6 +7,11 @@ import { describe, expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { createCodexResponsesAdapter } from "./codex-responses.js";
+import { createOpenAIResponsesAdapter } from "./openai-responses.js";
+import { createGrokResponsesAdapter } from "./grok-responses.js";
+import { createInferenceDependencies } from "./inference-dependencies.js";
+import { META_PROVIDER } from "@corbits/meta-provider";
+import type { ProviderAdapter } from "@intx/inference";
 import type { InferenceEvent, LastCycleSource } from "@intx/types/runtime";
 import { defined } from "../../testkit/defined.js";
 import { ProtocolMismatchError } from "@intx/inference";
@@ -29,15 +34,21 @@ function loadFixture(name: string): object[] {
 }
 
 /** Parse a full fixture stream with one adapter instance (shared indexer). */
-function parseFixture(name: string): InferenceEvent[] {
-  const adapter = createCodexResponsesAdapter(SOURCE);
+function parseFixtureWithAdapter(
+  adapter: ProviderAdapter,
+  name: string,
+): InferenceEvent[] {
   const out: InferenceEvent[] = [];
   for (const event of loadFixture(name)) {
     out.push(...adapter.parseResponse(JSON.stringify(event)));
   }
   return out;
 }
 
+function parseFixture(name: string): InferenceEvent[] {
+  return parseFixtureWithAdapter(createCodexResponsesAdapter(SOURCE), name);
+}
+
 /** Parse until the first throw; return events emitted before the failure. */
 function parseUntilError(name: string): {
   events: InferenceEvent[];
@@ -212,24 +223,58 @@ describe("codex-sse fixtures (golden parse)", () => {
     expect(String(error)).toMatch(/fixture stream error \(sanitized\)/);
   });
 
-  test("parallel calls whose arguments arrive only on done still carry their arguments", () => {
-    const out = parseFixture("parallel-tools-arguments-on-done.json");
+  test("parallel calls whose arguments arrive only on done still carry their arguments across all Responses adapters", async () => {
+    const deps = await createInferenceDependencies();
+    const adapters: [string, ProviderAdapter][] = [
+      ["codex-responses", createCodexResponsesAdapter(SOURCE)],
+      [
+        "openai-responses",
+        createOpenAIResponsesAdapter({
+          sourceId: "go/fixture",
+          provider: "openai-responses",
+          model: "gpt-fixture",
+        }),
+      ],
+      [
+        "grok-responses",
+        createGrokResponsesAdapter({
+          sourceId: "xai/fixture",
+          provider: "grok-responses",
+          model: "grok-fixture",
+        }),
+      ],
+      [
+        "meta-responses",
+        deps.adapters.resolve({
+          sourceId: "meta/fixture",
+          provider: META_PROVIDER,
+          model: "llama-fixture",
+        }),
+      ],
+    ];
 
-    expect(eventTypes(out)).toEqual([
-      "inference.tool_call.start",
-      "inference.tool_call.delta",
-      "inference.tool_call.start",
-      "inference.tool_call.delta",
-      "inference.usage",
-    ]);
-    expect(out[1]).toMatchObject({
-      type: "inference.tool_call.delta",
-      data: { callId: "0", argumentFragment: '{"path":"a.txt"}', index: 0 },
-    });
-    expect(out[3]).toMatchObject({
-      type: "inference.tool_call.delta",
-      data: { callId: "1", argumentFragment: '{"path":"b.txt"}', index: 1 },
-    });
+    for (const [label, adapter] of adapters) {
+      const out = parseFixtureWithAdapter(
+        adapter,
+        "parallel-tools-arguments-on-done.json",
+      );
+
+      expect(eventTypes(out), label).toEqual([
+        "inference.tool_call.start",
+        "inference.tool_call.delta",
+        "inference.tool_call.start",
+        "inference.tool_call.delta",
+        "inference.usage",
+      ]);
+      expect(out[1], label).toMatchObject({
+        type: "inference.tool_call.delta",
+        data: { callId: "0", argumentFragment: '{"path":"a.txt"}', index: 0 },
+      });
+      expect(out[3], label).toMatchObject({
+        type: "inference.tool_call.delta",
+        data: { callId: "1", argumentFragment: '{"path":"b.txt"}', index: 1 },
+      });
+    }
   });
 
   test("lifecycle envelopes alone produce no InferenceEvents", () => {

src/provider/codex-responses.ts

@@ -58,11 +58,13 @@ const FunctionCallItemDone = type({
   item: { type: "'function_call'", call_id: "string", arguments: "string" },
 });
 
-// With parallel calls on, some Codex backends send a call's arguments only on
-// output_item.done and never as deltas. The packaged parser reads deltas
+// With parallel calls on, some Responses backends send a call's arguments only
+// on output_item.done and never as deltas. The packaged parser reads deltas
 // alone, so without this replay the harness assembles those calls as `{}`
-// (CL-10582).
-function withArgumentsFromDone(adapter: ProviderAdapter): ProviderAdapter {
+// (CL-10582, CL-11324).
+export function withArgumentsFromDone(
+  adapter: ProviderAdapter,
+): ProviderAdapter {
   let indexByCallId = new Map<string, number>();
   let streamedIndices = new Set<number>();
   return {

src/provider/grok-responses.ts

@@ -1,6 +1,7 @@
 import { responsesAdapterFactory } from "@corbits/openai-responses";
 import { XAI_USER_ID_OPTION, xaiResponsesQuirks } from "@corbits/xai-provider";
 import type { AdapterFactory } from "@intx/inference";
+import { withArgumentsFromDone } from "./codex-responses.js";
 
 export const GROK_RESPONSES_PROVIDER = "grok-responses";
 
@@ -11,20 +12,22 @@ export const GROK_SESSION_ID_OPTION = "grokSessionId";
 // grokUserId / grokSessionId / reasoning_effort; aliasing those in a
 // buildRequest wrapper would hide the mismatch instead of baking the host
 // names.
-export const createGrokResponsesAdapter: AdapterFactory =
-  responsesAdapterFactory({
-    ...xaiResponsesQuirks,
-    sessionIdOption: GROK_SESSION_ID_OPTION,
-    headers: {
-      ...xaiResponsesQuirks.headers,
-      fromOption: (xaiResponsesQuirks.headers?.fromOption ?? []).map((entry) =>
-        entry.optionKey === XAI_USER_ID_OPTION
-          ? { ...entry, optionKey: GROK_USER_ID_OPTION }
-          : entry,
-      ),
-    },
-    reasoning: {
-      ...xaiResponsesQuirks.reasoning,
-      effortOption: "reasoning_effort",
-    },
-  });
+const createPackageGrokResponsesAdapter = responsesAdapterFactory({
+  ...xaiResponsesQuirks,
+  sessionIdOption: GROK_SESSION_ID_OPTION,
+  headers: {
+    ...xaiResponsesQuirks.headers,
+    fromOption: (xaiResponsesQuirks.headers?.fromOption ?? []).map((entry) =>
+      entry.optionKey === XAI_USER_ID_OPTION
+        ? { ...entry, optionKey: GROK_USER_ID_OPTION }
+        : entry,
+    ),
+  },
+  reasoning: {
+    ...xaiResponsesQuirks.reasoning,
+    effortOption: "reasoning_effort",
+  },
+});
+
+export const createGrokResponsesAdapter: AdapterFactory = (source) =>
+  withArgumentsFromDone(createPackageGrokResponsesAdapter(source));

src/provider/inference-dependencies.ts

@@ -1,4 +1,8 @@
-import { createDependencies, type Dependencies } from "@intx/inference";
+import {
+  createDependencies,
+  type AdapterFactory,
+  type Dependencies,
+} from "@intx/inference";
 import { loadAdapterRegistry } from "@intx/inference/providers";
 // AdapterManifest moved from the @intx/inference barrel to @intx/types at
 // upstream 4cc6972 (the inference barrel no longer re-exports it).
@@ -13,12 +17,13 @@ import * as openaiResponses from "./openai-responses.js";
 import * as anthropicSession from "./anthropic-session-adapter.js";
 import {
   CODEX_RESPONSES_PROVIDER,
+  withArgumentsFromDone,
   withCodexContentTypeRepair,
 } from "./codex-responses.js";
 import { GROK_RESPONSES_PROVIDER } from "./grok-responses.js";
 import {
   META_PROVIDER,
-  createMetaResponsesAdapter,
+  createMetaResponsesAdapter as createPackageMetaResponsesAdapter,
 } from "@corbits/meta-provider";
 import { withAnthropicCacheBreakpoint } from "./anthropic-cache-breakpoint.js";
 import { withReplaySanitizer } from "./replay-sanitizer.js";
@@ -90,6 +95,9 @@ const manifest: AdapterManifest = [
   },
 ];
 
+const createMetaResponsesAdapter: AdapterFactory = (source) =>
+  withArgumentsFromDone(createPackageMetaResponsesAdapter(source));
+
 const localModules: Record<string, unknown> = {
   "openai-compatible-adapter": openaiCompatible,
   "opencode-go-adapter": opencodeGo,

src/provider/openai-responses.ts

@@ -3,6 +3,7 @@ import {
   type ResponsesQuirks,
 } from "@corbits/openai-responses";
 import type { AdapterFactory } from "@intx/inference";
+import { withArgumentsFromDone } from "./codex-responses.js";
 import { OPENCODE_SESSION_ID_OPTION } from "./opencode-session.js";
 
 export const OPENAI_RESPONSES_PROVIDER = "openai-responses";
@@ -24,5 +25,7 @@ export const hostQuirks: ResponsesQuirks = {
   reasoning: { summary: "auto" },
 };
 
-export const createOpenAIResponsesAdapter: AdapterFactory =
-  responsesAdapterFactory(hostQuirks);
+const createPackageOpenAIResponsesAdapter = responsesAdapterFactory(hostQuirks);
+
+export const createOpenAIResponsesAdapter: AdapterFactory = (source) =>
+  withArgumentsFromDone(createPackageOpenAIResponsesAdapter(source));