@bitkyc08/opencodex 2.6.32 → 2.7.0

package/src/adapters/cursor/live-transport.ts

@@ -31,6 +31,7 @@ import {
   type InteractionResponse,
 } from "./gen/agent_pb";
 import { debugProviderDiagnostic } from "../../lib/debug";
+import { classifyCursorError, isCursorBenignCancelError, safeCursorErrorMessage } from "./cursor-errors";
 import { mcpArgsFromToolCall } from "./protobuf-events";
 import { OCX_RESPONSES_TOOL_PROVIDER } from "./tool-definitions";
 import { cursorUnsafeNativeLocalExecEnabled, handleCursorNativeExec, handleCursorNativeKv, type CursorNativeExecContext } from "./native-exec";
@@ -53,7 +54,7 @@ import type { CursorClientMessage, CursorRunRequest, CursorServerMessage } from
 import type { CursorTransport, CursorTransportFactoryInput } from "./transport";
 
 const CURSOR_RUN_PATH = "/agent.v1.AgentService/Run";
-const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+const CURSOR_CLIENT_VERSION = "cli-2026.07.08-0c04a8a";
 const HEARTBEAT_MS = 5_000;
 const CURSOR_FIRST_FRAME_TIMEOUT_MS = 30_000;
 const CLIENT_TOOL_FINALIZE_GRACE_MS = 50;
@@ -323,6 +324,14 @@ class LiveCursorTransport implements CursorTransport {
   private readonly desktopDeps: CursorNativeToolDeps;
   private execContext: CursorNativeExecContext = {};
   private mcpPrepared?: Promise<void>;
+  // Per-turn diagnostic counters/timestamps when provider debug is on (`ocx debug provider on`). Stamped in open(), cleared on
+  // close; safe to read after a stream failure because open() owns the only writer before run().
+  private turnStartedAt = 0;
+  private framesReceived = 0;
+ private firstFrameAt?: number;
+ private firstFrameLogged = false;
+  /** Stable session identifier sent as x-session-id; mirrors IDE session semantics. */
+  private readonly sessionId = crypto.randomUUID();
 
   constructor(private readonly input: CursorTransportFactoryInput) {
     this.token = resolveCursorToken(input.provider, input.headers);
@@ -379,6 +388,27 @@ class LiveCursorTransport implements CursorTransport {
     let done = false;
     let failure: Error | undefined;
     let state = createCursorProtobufEventState();
+    let failureLogged = false;
+    // One per-turn summary of the failure path (end-stream error, socket reset, abort) so the
+    // operator can see how far the turn got and how it was classified without re-scanning every
+    // frame. Gated behind provider debug (`ocx debug provider on`).
+    const summarizeFailure = (err: Error): Error => {
+      if (!failureLogged && !(this.expectedClose && isCursorBenignCancelError(err))) {
+        failureLogged = true;
+        debugProviderDiagnostic("cursor", "turn-failed", {
+          committed: this.committed,
+          framesReceived: this.framesReceived,
+          outputTokens: state.usage.outputTokens,
+          contextTokens: state.contextTokens,
+          firstFrameMs: this.firstFrameAt ? this.firstFrameAt - this.turnStartedAt : undefined,
+          elapsedMs: this.turnStartedAt ? Date.now() - this.turnStartedAt : undefined,
+          classified: classifyCursorError(err.message),
+          errorCode: (err as { code?: unknown }).code ?? undefined,
+          message: redactCursorForLog(err.message),
+        });
+      }
+      return err;
+    };
     const wake = () => {
       const fn = notify;
       notify = undefined;
@@ -428,13 +458,21 @@ class LiveCursorTransport implements CursorTransport {
         const message = queue.shift();
         if (message) yield message;
       }
-      if (failure) throw attachPartialUsage(failure, state);
+      if (failure) {
+        // A CANCEL is benign only on the client-tool suspend path (expectedClose); an
+        // unexpected server-side NGHTTP2_CANCEL must surface as a real transport error.
+        if (this.expectedClose && isCursorBenignCancelError(failure)) return;
+        throw attachPartialUsage(summarizeFailure(failure), state);
+      }
       if (done) break;
       await new Promise<void>(resolve => {
         notify = resolve;
       });
     }
-    if (failure) throw attachPartialUsage(failure, state);
+    if (failure) {
+      if (this.expectedClose && isCursorBenignCancelError(failure)) return;
+      throw attachPartialUsage(summarizeFailure(failure), state);
+    }
   }
 
   writeClient(_message: CursorClientMessage): void {}
@@ -506,6 +544,11 @@ class LiveCursorTransport implements CursorTransport {
       const terminal = finalizeAfterDrain(state);
       if (terminal.length === 0) return;
       for (const event of terminal) push(event);
+      debugProviderDiagnostic("cursor", "client-tool-suspend", {
+        reason: "Responses bridge owns client tools; ending turn without fake mcpResult",
+        framesReceived: this.framesReceived,
+        elapsedMs: Date.now() - this.turnStartedAt,
+      });
       this.cancelCursorRun();
     }, this.activeClientToolFinalizeGraceMs);
   }
@@ -518,11 +561,20 @@ class LiveCursorTransport implements CursorTransport {
     fail: (error: Error) => void,
     finish: () => void,
   ): void {
+    this.turnStartedAt = Date.now();
+    this.framesReceived = 0;
+    this.firstFrameAt = undefined;
+    this.firstFrameLogged = false;
+    const dialHost = cursorHostLabel(this.input.provider.baseUrl || "https://api2.cursor.sh");
+    debugProviderDiagnostic("cursor", "dial", { host: dialHost });
     this.session = http2.connect(this.input.provider.baseUrl || "https://api2.cursor.sh");
     // The run request is buffered until the HTTP/2 session connects. Failures before `connect`
     // (DNS, ECONNREFUSED, TLS, connect timeout) mean the server never received the request, so they
     // are safe to retry. Once connected, bytes flush to the server and the turn must not be replayed.
-    this.session.on("connect", () => { this.committed = true; });
+    this.session.on("connect", () => {
+      this.committed = true;
+      debugProviderDiagnostic("cursor", "connected", { connectMs: Date.now() - this.turnStartedAt });
+    });
     this.stream = this.session.request({
       ":method": "POST",
       ":path": CURSOR_RUN_PATH,
@@ -534,6 +586,7 @@ class LiveCursorTransport implements CursorTransport {
       "x-cursor-client-version": CURSOR_CLIENT_VERSION,
       "x-cursor-client-type": "cli",
       "x-request-id": crypto.randomUUID(),
+      "x-session-id": this.sessionId,
     });
 
     // Single owner of the pre-first-frame deadline. Cleared by the first server frame/end-stream and
@@ -543,6 +596,12 @@ class LiveCursorTransport implements CursorTransport {
       if (this.expectedClose) {
         // We already emitted a terminal `done` and cancelled the run (client-tool suspension). The
         // RST_STREAM CANCEL surfaces here as a stream error/abort; it is expected, not a failure.
+        debugProviderDiagnostic("cursor", "stream-cancel-expected", {
+          code: (error as { code?: unknown }).code,
+          message: redactCursorForLog(error.message),
+          framesReceived: this.framesReceived,
+          elapsedMs: Date.now() - this.turnStartedAt,
+        });
         finish();
         return;
       }
@@ -552,6 +611,7 @@ class LiveCursorTransport implements CursorTransport {
     const stream = this.stream;
     this.firstFrameTimer = setTimeout(() => {
       this.firstFrameTimer = undefined;
+      debugProviderDiagnostic("cursor", "first-frame-timeout", { timeoutMs: this.input.firstFrameTimeoutMs ?? CURSOR_FIRST_FRAME_TIMEOUT_MS });
       try { stream.close(); } catch { /* already closing */ }
       try { session.close(); } catch { /* already closing */ }
       fail(new Error("Cursor transport timed out before first response"));
@@ -560,6 +620,11 @@ class LiveCursorTransport implements CursorTransport {
     let pending: Uint8Array<ArrayBufferLike> = new Uint8Array();
     this.stream.on("data", chunk => {
       this.clearFirstFrameTimer();
+      if (!this.firstFrameLogged) {
+        this.firstFrameLogged = true;
+        this.firstFrameAt = Date.now();
+        debugProviderDiagnostic("cursor", "first-frame", { latencyMs: this.firstFrameAt - this.turnStartedAt });
+      }
       const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
       pending = concatBytes(pending, bytes);
       try {
@@ -567,8 +632,16 @@ class LiveCursorTransport implements CursorTransport {
         pending = decoded.remainder;
         const frames = decoded.frames;
         for (const frame of frames) {
+          this.framesReceived++;
           if ((frame.flags & CONNECT_FLAG_END_STREAM) === CONNECT_FLAG_END_STREAM) {
             const endError = parseConnectEndStreamError(frame.payload);
+            debugProviderDiagnostic("cursor", "connect-end-stream", endError ? {
+              code: cursorConnectErrorCode(frame.payload),
+              message: redactCursorForLog(endError.message),
+              classified: classifyCursorError(endError.message),
+              framesReceived: this.framesReceived,
+              elapsedMs: Date.now() - this.turnStartedAt,
+            } : { framesReceived: this.framesReceived, elapsedMs: Date.now() - this.turnStartedAt });
             if (endError) failAndClear(endError);
             continue;
           }
@@ -582,10 +655,38 @@ class LiveCursorTransport implements CursorTransport {
     });
     this.stream.on("trailers", trailers => {
       const status = trailers["grpc-status"];
+      if (status !== undefined) debugProviderDiagnostic("cursor", "trailers", { grpcStatus: String(status) });
       if (status && status !== "0") failAndClear(new Error(`Cursor gRPC error ${status}`));
     });
-    this.stream.on("error", err => failAndClear(err instanceof Error ? err : new Error(String(err))));
-    this.stream.on("end", () => { this.clearFirstFrameTimer(); finish(); });
+    this.stream.on("error", err => {
+      const realErr = err instanceof Error ? err : new Error(String(err));
+      if (this.expectedClose) {
+        failAndClear(realErr);
+        return;
+      }
+      const code = (realErr as { code?: unknown }).code;
+      const errno = (realErr as { errno?: unknown }).errno;
+      debugProviderDiagnostic("cursor", "stream-error", {
+        code: typeof code === "string" || typeof code === "number" ? String(code) : undefined,
+        errno: typeof errno === "string" || typeof errno === "number" ? String(errno) : undefined,
+        name: realErr.name,
+        message: redactCursorForLog(realErr.message),
+        committed: this.committed,
+        framesReceived: this.framesReceived,
+        elapsedMs: Date.now() - this.turnStartedAt,
+      });
+      failAndClear(realErr);
+    });
+    this.stream.on("end", () => {
+      this.clearFirstFrameTimer();
+      debugProviderDiagnostic("cursor", "stream-end", {
+        committed: this.committed,
+        framesReceived: this.framesReceived,
+        expectedClose: this.expectedClose,
+        elapsedMs: Date.now() - this.turnStartedAt,
+      });
+      finish();
+    });
 
     signal?.addEventListener("abort", () => {
       this.close();
@@ -689,7 +790,7 @@ function attachPartialUsage(failure: Error, state: ReturnType<typeof createCurso
 }
 
 /**
- * Compact frame descriptor for OCX_DEBUG_FRAMES diagnostics: outer case plus the inner
+ * Compact frame descriptor for provider debug (`ocx debug provider on`): outer case plus the inner
  * interactionUpdate/exec case and tool-call union case when present. No payload content is logged.
  */
 function describeCursorServerFrame(message: AgentServerMessage): Record<string, unknown> {
@@ -758,6 +859,34 @@ function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array {
   return out;
 }
 
+/** Host-only label for Cursor transport diagnostics — never leaks path/query/credentials. */
+function cursorHostLabel(baseUrl: string): string {
+  try {
+    return new URL(baseUrl).host;
+  } catch {
+    return "cursor";
+  }
+}
+
+/** Redact a Cursor error message for diagnostic output. Cursor error strings can carry raw
+ * credential key=value pairs beyond what redactSecretString covers; safeCursorErrorMessage
+ * already applies the full sanitizer plus the classified prefix, so reuse it verbatim. */
+function redactCursorForLog(message: string): string {
+  return safeCursorErrorMessage(message).slice(0, 300);
+}
+
+/** Extract the Connect end-stream `error.code` from the raw trailer frame payload without
+ * surfacing the (potentially secret-bearing) message — used for `[ocx:cursor:connect-end-stream]`
+ * diagnostics. Returns undefined when the payload is not the expected Connect error shape. */
+function cursorConnectErrorCode(payload: Uint8Array): string | undefined {
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(payload)) as { error?: { code?: string } };
+    return parsed?.error?.code;
+  } catch {
+    return undefined;
+  }
+}
+
 export function createLiveCursorTransport(input: CursorTransportFactoryInput): CursorTransport {
   return new LiveCursorTransport(input);
 }

package/src/adapters/cursor/protobuf-request.ts

@@ -22,6 +22,8 @@ import {
   McpToolResultSchema,
   ModelDetailsSchema,
   ResumeActionSchema,
+  RequestContextSchema,
+  RequestContextEnvSchema,
   ThinkingMessageSchema,
   ToolCallSchema,
   UserMessageActionSchema,
@@ -39,6 +41,24 @@ import {
 
 const encoder = new TextEncoder();
 
+/** Runtime timezone for protobuf RequestContextEnv (dynamic, never hardcoded). */
+function runtimeTimeZone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+/** Builds a RequestContext with env.timeZone populated dynamically. */
+function buildRequestContext() {
+  return create(RequestContextSchema, {
+    env: create(RequestContextEnvSchema, {
+      timeZone: runtimeTimeZone(),
+    }),
+  });
+}
+
 function jsonBlob(value: unknown): Uint8Array {
   return encoder.encode(JSON.stringify(value));
 }
@@ -307,11 +327,14 @@ export function encodeCursorRunRequest(request: CursorRunRequest): Uint8Array {
               text,
               messageId: crypto.randomUUID(),
             }),
+            requestContext: buildRequestContext(),
           }),
         }
       : {
           case: "resumeAction",
-          value: create(ResumeActionSchema, {}),
+          value: create(ResumeActionSchema, {
+            requestContext: buildRequestContext(),
+          }),
         },
   });
 

package/src/adapters/cursor/request-builder.ts

@@ -8,17 +8,18 @@ import type {
 } from "../../types";
 import { namespacedToolName } from "../../types";
 import type { CursorRequestMessage, CursorRunRequest } from "./types";
+import { cursorCodexToWireModelId } from "./discovery";
 import { cursorEffortSuffix } from "./effort-map";
 
 /**
  * Resolve a `cursor/<model>` selection + Codex reasoning effort to the actual Cursor model id. Cursor
- * encodes the effort as a per-model suffix (`claude-4.6-opus-high`); `cursorEffortSuffix` picks the
- * right tier for that specific model (top effort → the model's top tier, e.g. `-max`/`-xhigh`) or
- * `undefined` for non-reasoning models like `composer-2.5`. A fully-qualified id (one that isn't a
- * known effort base) passes through unchanged.
+* encodes the effort as a per-model suffix (`claude-4.6-opus-high`); `cursorEffortSuffix` picks the
+ * right tier for that specific model (literal pass-through, with rank clamp fallback) or
+* `undefined` for non-reasoning models like `composer-2.5`. A fully-qualified id (one that isn't a
+* known effort base) passes through unchanged.
  */
 function normalizeCursorModelId(modelId: string, reasoning?: string): string {
-  const id = modelId.startsWith("cursor/") ? modelId.slice("cursor/".length) : modelId;
+  const id = cursorCodexToWireModelId(modelId);
   const suffix = cursorEffortSuffix(id, reasoning);
   return suffix ? `${id}-${suffix}` : id;
 }

package/src/adapters/cursor/transport-retry.ts

@@ -1,6 +1,8 @@
 import type { CursorRunRequest, CursorServerMessage } from "./types";
 import type { CursorTransport, CursorTransportFactory, CursorTransportFactoryInput } from "./transport";
 import { abortError, sleepWithAbort } from "../../lib/upstream-retry";
+import { debugProviderDiagnostic } from "../../lib/debug";
+import { safeCursorErrorMessage } from "./cursor-errors";
 
 // Compat: historical name for the shared abortable sleep, kept for external callers.
 export { sleepWithAbort as abortAwareSleep } from "../../lib/upstream-retry";
@@ -20,6 +22,8 @@ export function isRetryableCursorError(err: unknown): boolean {
   const message = err instanceof Error ? err.message : typeof err === "string" ? err : "";
   const haystack = `${code} ${message}`.toLowerCase();
   if (/auth|unauthor|forbidden|invalid|permission|denied|not found|unsupported/.test(haystack)) return false;
+  if (/resource.exhausted|resource_exhausted|rate limit|too many requests|throttl/.test(haystack)) return false;
+  if (haystack.includes("nghttp2_cancel") || haystack.includes("stream suspended")) return false;
   return (
     haystack.includes("econnreset") ||
     haystack.includes("econnrefused") ||
@@ -27,7 +31,7 @@ export function isRetryableCursorError(err: unknown): boolean {
     haystack.includes("enetunreach") ||
     haystack.includes("eai_again") ||
     haystack.includes("goaway") ||
-    haystack.includes("nghttp2") ||
+    (haystack.includes("nghttp2") && !haystack.includes("nghttp2_cancel")) ||
     haystack.includes("socket hang up") ||
     haystack.includes("connection reset") ||
     haystack.includes("unavailable") ||
@@ -83,8 +87,23 @@ export async function runCursorTurnWithRetry(
         !signal?.aborted &&
         requestUncommitted(transport) &&
         isRetryableCursorError(err);
-      if (!canRetry) throw err;
-      await sleepWithAbort(cursorRetryDelayMs(attempt), signal);
+      if (!canRetry) {
+        debugProviderDiagnostic("cursor", "no-retry", {
+          attempt,
+          reason: safeCursorErrorMessage(err instanceof Error ? err.message : String(err)),
+          emittedAny,
+          committed: !requestUncommitted(transport),
+          aborted: !!signal?.aborted,
+        });
+        throw err;
+      }
+      const backoffMs = cursorRetryDelayMs(attempt);
+      debugProviderDiagnostic("cursor", "retry", {
+        attempt,
+        reason: safeCursorErrorMessage(err instanceof Error ? err.message : String(err)),
+        backoffMs,
+      });
+      await sleepWithAbort(backoffMs, signal);
     } finally {
       await transport.close?.();
     }

package/src/adapters/cursor.ts

@@ -1,7 +1,7 @@
 import type { AdapterEvent, OcxProviderConfig } from "../types";
 import type { ProviderAdapter } from "./base";
 import { cursorExecDeniedMessage } from "./cursor/exec-policy";
-import { safeCursorErrorMessage } from "./cursor/cursor-errors";
+import { isCursorBenignCancelError, safeCursorErrorMessage } from "./cursor/cursor-errors";
 import { createCursorKvStore, type CursorKvStore } from "./cursor/kv-store";
 import { mapCursorServerMessage } from "./cursor/message-mapper";
 import { createCursorRequest, generatedCursorConversationId } from "./cursor/request-builder";
@@ -91,6 +91,7 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
           },
         );
       } catch (err) {
+        if (isCursorBenignCancelError(err)) return;
         const partialUsage = (err as { partialUsage?: import("../types").OcxUsage }).partialUsage;
         emit({ type: "error", message: safeCursorTransportError(err), ...(partialUsage ? { usage: partialUsage } : {}) });
       }

package/src/adapters/openai-chat.ts

@@ -76,7 +76,9 @@ function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderCon
             type: "function",
             function: { name: namespacedToolName(tc.namespace, tc.name), arguments: JSON.stringify(tc.arguments) },
           }));
-          if (!chatMsg.content) chatMsg.content = null;
+          // "" instead of null: strict validators (xAI: "Each message must have at least one
+          // content element", langchain#34140) reject content-less assistant history entries.
+          if (!chatMsg.content) chatMsg.content = "";
         }
         if (chatMsg.reasoning_content !== undefined && chatMsg.content === undefined && chatMsg.tool_calls === undefined) {
           chatMsg.content = "";
@@ -97,7 +99,7 @@ function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderCon
           const name = safeToolName(msg.toolName);
           out.push({
             role: "assistant",
-            content: null,
+            content: "",
             tool_calls: [{
               id: toolCallId,
               type: "function",
@@ -166,6 +168,20 @@ function usageFromOpenAIChat(usage: Record<string, unknown> | undefined): OcxUsa
   };
 }
 
+function thinkingBudgetForEffort(parsed: OcxParsedRequest, reasoningEffort: string): number | undefined {
+  if (parsed.options.reasoning === "minimal") return 0;
+  const maxBudget = parsed.options.maxOutputTokens ?? 32768;
+  const fractions: Record<string, number> = {
+    low: 0.20,
+    medium: 0.50,
+    high: 0.75,
+    xhigh: 0.90,
+    max: 1.0,
+  };
+  const fraction = fractions[reasoningEffort];
+  return fraction === undefined ? undefined : Math.max(1, Math.floor(maxBudget * fraction));
+}
+
 export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAdapter {
   return {
     name: "openai-chat",
@@ -196,7 +212,10 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       if (parsed.options.stopSequences !== undefined) body.stop = parsed.options.stopSequences;
       const reasoningEffort = mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning);
       if (reasoningEffort !== undefined) {
-        if (modelInList(provider.thinkingToggleModels, parsed.modelId)) {
+        if (modelInList(provider.thinkingBudgetModels, parsed.modelId)) {
+          const budget = thinkingBudgetForEffort(parsed, reasoningEffort);
+          if (budget !== undefined) body.thinking_budget = budget;
+        } else if (modelInList(provider.thinkingToggleModels, parsed.modelId)) {
           // Vendor thinking-toggle wire (MiMo v2.x, GLM 5/5.1): the mapped value is the toggle
           // state, sent as `thinking: {type}` — these models ignore/reject reasoning_effort.
           if (reasoningEffort === "enabled" || reasoningEffort === "disabled") {
@@ -213,7 +232,15 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         body.frequency_penalty = parsed.options.frequencyPenalty;
       }
 
-      if (tools) body.parallel_tool_calls = false;
+      if (tools) {
+        // Default-ON for chat-completions providers (user decision 260709): the buffered
+        // parser assembles multi-call streams safely, so `parallelToolCalls: false` is the
+        // only per-provider opt-out; Codex's request bit can still force false per request.
+        // Rationale + provider evidence: devlog/_plan/260709_parallel_tool_calls.
+        body.parallel_tool_calls = provider.parallelToolCalls === false
+          ? false
+          : parsed.options.parallelToolCalls !== false;
+      }
       if (parsed.stream) {
         body.stream_options = { include_usage: true };
       }
@@ -235,8 +262,26 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
       let buffer = "";
-      let currentToolCallId = "";
-      let currentToolCallName = "";
+      // Streamed tool calls are BUFFERED until a terminal signal, then flushed as atomic
+      // start/delta/end sequences. The bridge treats text/reasoning deltas as barriers that
+      // close an open tool-call item (bridge.ts closeCurrentToolCall on text_delta), so
+      // emitting calls incrementally would orphan later argument deltas whenever a provider
+      // interleaves content — and parallel tool calls (multiple ids, index-keyed continuation
+      // chunks, whole-chunk calls) cannot be represented live without overlapping sequences.
+      // Keyed by `index` (OpenAI wire standard), falling back to `id`, falling back to the
+      // last-seen call for providers that omit both on continuation chunks.
+      interface PendingToolCall { key: string; id: string; name: string; args: string }
+      const pendingToolCalls: PendingToolCall[] = [];
+      let toolCallSeq = 0;
+      const flushToolCalls = function* (): Generator<AdapterEvent> {
+        for (const call of pendingToolCalls) {
+          if (!call.id) call.id = `call_${++toolCallSeq}`;
+          yield { type: "tool_call_start", id: call.id, name: call.name };
+          if (call.args.length > 0) yield { type: "tool_call_delta", arguments: call.args };
+          yield { type: "tool_call_end" };
+        }
+        pendingToolCalls.length = 0;
+      };
       let pendingUsage: OcxUsage | undefined;
       // Track terminal signals so a socket EOF without any terminator can fail closed instead of
       // being reported as a clean completion (silent truncation). A graceful close is either an
@@ -252,10 +297,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         if (!line.startsWith("data: ")) return "continue";
         const payload = line.slice(6).trim();
         if (payload === "[DONE]") {
-          if (currentToolCallId) {
-            yield { type: "tool_call_end" };
-            currentToolCallId = "";
-          }
+          yield* flushToolCalls();
           yield { type: "done", usage: pendingUsage };
           return "terminate";
         }
@@ -273,7 +315,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         // classified response.failed (bridge case "error") — never a truncated completion.
         if (chunk.error) {
           const err = chunk.error as { message?: string } | undefined;
-          if (currentToolCallId) yield { type: "tool_call_end" };
+          yield* flushToolCalls();
           yield { type: "error", message: err?.message ?? "upstream error" };
           return "terminate";
         }
@@ -302,25 +344,34 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             yield { type: "reasoning_raw_delta", text: delta.reasoning_content };
           }
 
-          const toolCalls = delta.tool_calls as { index: number; id?: string; function?: { name?: string; arguments?: string } }[] | undefined;
+          const toolCalls = delta.tool_calls as { index?: number; id?: string; function?: { name?: string; arguments?: string } }[] | undefined;
           if (toolCalls) {
             for (const tc of toolCalls) {
-              if (tc.id && tc.id !== currentToolCallId) {
-                if (currentToolCallId) yield { type: "tool_call_end" };
-                currentToolCallId = tc.id;
-                currentToolCallName = tc.function?.name ?? "";
-                yield { type: "tool_call_start", id: tc.id, name: currentToolCallName };
-              }
-              if (tc.function?.arguments) {
-                yield { type: "tool_call_delta", arguments: tc.function.arguments };
+              const key = typeof tc.index === "number"
+                ? `i:${tc.index}`
+                : tc.id
+                ? `id:${tc.id}`
+                : pendingToolCalls[pendingToolCalls.length - 1]?.key;
+              let call = key !== undefined ? pendingToolCalls.find(c => c.key === key) : undefined;
+              // Mixed keying rescue: a call opened under an index key must still absorb an
+              // id-only continuation for the same provider id (and vice versa) instead of
+              // splitting into two calls that share one call_id downstream.
+              if (!call && tc.id) call = pendingToolCalls.find(c => c.id === tc.id);
+              if (!call) {
+                call = { key: key ?? `seq:${pendingToolCalls.length}`, id: "", name: "", args: "" };
+                pendingToolCalls.push(call);
               }
+              if (tc.id && !call.id) call.id = tc.id;
+              if (tc.function?.name && !call.name) call.name = tc.function.name;
+              if (tc.function?.arguments) call.args += tc.function.arguments;
             }
           }
         }
 
-        if (choices[0].finish_reason === "tool_calls" && currentToolCallId) {
-          yield { type: "tool_call_end" };
-          currentToolCallId = "";
+        // Any non-empty finish_reason ends the generation: flush assembled tool calls as
+        // atomic sequences (covers "tool_calls" AND providers that close tool turns with "stop").
+        if (typeof choices[0].finish_reason === "string" && choices[0].finish_reason) {
+          yield* flushToolCalls();
         }
         return "continue";
       };
@@ -347,9 +398,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         if (buffer.length > 0) {
           if ((yield* handleDataLine(buffer)) === "terminate") return;
         }
-        if (currentToolCallId) {
-          yield { type: "tool_call_end" };
-        }
+        yield* flushToolCalls();
         // Reader EOF. A graceful close shows at least one terminal signal: `[DONE]` (returns above),
         // a non-null finish_reason (sawFinish), or a trailing usage chunk (providers emit usage only
         // at end-of-generation). If NONE of those were seen, the stream was cut mid-flight — fail