@bitkyc08/opencodex 2.7.36 → 2.7.37

package/src/adapters/google.ts

@@ -345,6 +345,86 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       let pendingUsage: OcxUsage | undefined;
       let toolCallsStarted = 0;
       let lastFinishReason: string | undefined;
+      let sawAnyFrame = false;
+      let sawTerminalSignal = false;
+
+      const handleDataLine = function* (line: string): Generator<AdapterEvent, "continue" | "content" | "terminate"> {
+        const payload = line.slice(5).trim();
+        if (!payload) return "continue";
+        let emittedContentEvent = false;
+
+        let chunk: Record<string, unknown>;
+        try {
+          chunk = JSON.parse(payload);
+        } catch {
+          yield { type: "error", message: "malformed upstream SSE data frame" };
+          return "terminate";
+        }
+        sawAnyFrame = true;
+
+        // Inline provider error inside a 200 stream → terminal error (see openai-chat.ts).
+        if (chunk.error) {
+          const err = chunk.error as { message?: string } | undefined;
+          // Clear-on-invalid: a signature rejection means our replayed thoughtSignatures are stale.
+          // Drop the cache entry so the next turn starts clean instead of re-injecting a bad sig.
+          if (provider.googleMode === "cloud-code-assist" && antigravityModel && antigravitySession
+            && /signature|invalid_argument|invalid argument/i.test(err?.message ?? "")) {
+            clearAntigravityReplay(antigravityModel, antigravitySession);
+          }
+          yield { type: "error", message: err?.message ?? "upstream error" };
+          return "terminate";
+        }
+
+        // Antigravity (CCA) nests the standard Gemini payload under `response`.
+        let root = chunk;
+        if (provider.googleMode === "cloud-code-assist") {
+          const wrapped = chunk.response;
+          if (!wrapped || typeof wrapped !== "object" || Array.isArray(wrapped)) {
+            yield { type: "error", message: "google-antigravity response missing response wrapper" };
+            return "terminate";
+          }
+          root = wrapped as Record<string, unknown>;
+        }
+        // usageMetadata is a top-level field independent of candidates; read it BEFORE the
+        // candidates guard so a usage-only final chunk is not dropped.
+        const usageMeta = root.usageMetadata as Record<string, number> | undefined;
+        if (usageMeta) {
+          // Accumulate usage; emit a single terminal `done` post-loop so usage is never
+          // dropped on EOF and the stream never yields two `done` events.
+          pendingUsage = usageFromGemini(usageMeta);
+          sawTerminalSignal = true;
+        }
+        const candidates = root.candidates as { content?: { parts?: unknown[] }; finishReason?: string }[] | undefined;
+        if (!candidates?.length) return "continue";
+
+        if (typeof candidates[0].finishReason === "string" && candidates[0].finishReason) {
+          lastFinishReason = candidates[0].finishReason;
+          sawTerminalSignal = true;
+        }
+
+        const parts = candidates[0].content?.parts as { text?: string; functionCall?: { name: string; args: unknown } }[] | undefined;
+        // Antigravity reasoning-replay: record thoughtSignatures from the model parts for the next turn.
+        if (provider.googleMode === "cloud-code-assist" && parts && antigravityModel && antigravitySession) {
+          observeAntigravityReplay(antigravityModel, antigravitySession, parts as unknown[]);
+        }
+        if (parts) {
+          for (const part of parts) {
+            if (part.text) {
+              emittedContentEvent = true;
+              yield { type: "text_delta", text: part.text };
+            }
+            if (part.functionCall) {
+              const id = `call_${crypto.randomUUID().slice(0, 8)}`;
+              toolCallsStarted++;
+              emittedContentEvent = true;
+              yield { type: "tool_call_start", id, name: restoreGoogleToolName(part.functionCall.name) };
+              yield { type: "tool_call_delta", arguments: JSON.stringify(part.functionCall.args ?? {}) };
+              yield { type: "tool_call_end" };
+            }
+          }
+        }
+        return emittedContentEvent ? "content" : "continue";
+      };
 
       try {
         while (true) {
@@ -355,70 +435,30 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           const lines = buffer.split("\n");
           buffer = lines.pop() ?? "";
 
+          let sawLiveness = false;
+          let sawContentEvent = false;
           for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            const payload = line.slice(6).trim();
-            if (!payload) continue;
-
-            let chunk: Record<string, unknown>;
-            try { chunk = JSON.parse(payload); } catch { debugDroppedFrame("google", payload); continue; }
-
-            // Inline provider error inside a 200 stream → terminal error (see openai-chat.ts).
-            if (chunk.error) {
-              const err = chunk.error as { message?: string } | undefined;
-              // Clear-on-invalid: a signature rejection means our replayed thoughtSignatures are stale.
-              // Drop the cache entry so the next turn starts clean instead of re-injecting a bad sig.
-              if (provider.googleMode === "cloud-code-assist" && antigravityModel && antigravitySession
-                && /signature|invalid_argument|invalid argument/i.test(err?.message ?? "")) {
-                clearAntigravityReplay(antigravityModel, antigravitySession);
-              }
-              yield { type: "error", message: err?.message ?? "upstream error" };
-              return;
-            }
-
-            // Antigravity (CCA) nests the standard Gemini payload under `response`.
-            let root = chunk;
-            if (provider.googleMode === "cloud-code-assist") {
-              const wrapped = chunk.response;
-              if (!wrapped || typeof wrapped !== "object" || Array.isArray(wrapped)) {
-                yield { type: "error", message: "google-antigravity response missing response wrapper" };
-                return;
-              }
-              root = wrapped as Record<string, unknown>;
-            }
-            // usageMetadata is a top-level field independent of candidates; read it BEFORE the
-            // candidates guard so a usage-only final chunk is not dropped.
-            const usageMeta = root.usageMetadata as Record<string, number> | undefined;
-            if (usageMeta) {
-              // Accumulate usage; emit a single terminal `done` post-loop so usage is never
-              // dropped on EOF and the stream never yields two `done` events.
-              pendingUsage = usageFromGemini(usageMeta);
-            }
-            const candidates = root.candidates as { content?: { parts?: unknown[] }; finishReason?: string }[] | undefined;
-            if (!candidates?.length) continue;
-
-            lastFinishReason = candidates[0].finishReason ?? lastFinishReason;
-
-            const parts = candidates[0].content?.parts as { text?: string; functionCall?: { name: string; args: unknown } }[] | undefined;
-            // Antigravity reasoning-replay: record thoughtSignatures from the model parts for the next turn.
-            if (provider.googleMode === "cloud-code-assist" && parts && antigravityModel && antigravitySession) {
-              observeAntigravityReplay(antigravityModel, antigravitySession, parts as unknown[]);
-            }
-            if (parts) {
-              for (const part of parts) {
-                if (part.text) {
-                  yield { type: "text_delta", text: part.text };
-                }
-                if (part.functionCall) {
-                  const id = `call_${crypto.randomUUID().slice(0, 8)}`;
-                  toolCallsStarted++;
-                  yield { type: "tool_call_start", id, name: restoreGoogleToolName(part.functionCall.name) };
-                  yield { type: "tool_call_delta", arguments: JSON.stringify(part.functionCall.args ?? {}) };
-                  yield { type: "tool_call_end" };
-                }
-              }
+            if (line.startsWith("data:")) {
+              const result = yield* handleDataLine(line);
+              if (result === "terminate") return;
+              if (result === "content") sawContentEvent = true;
+              continue;
             }
+            sawLiveness = true;
+            if (line.startsWith(":") || !line.trim()) continue;
+            debugDroppedFrame("google", line);
           }
+          if (sawLiveness && !sawContentEvent) yield { type: "heartbeat" };
+        }
+        buffer += decoder.decode();
+        if (buffer.trim().length > 0) {
+          const residual = buffer.trim();
+          if (residual.startsWith(":")) {
+            yield { type: "heartbeat" };
+          } else if (!residual.startsWith("data:")) {
+            yield { type: "error", message: "upstream stream ended with an incomplete SSE frame — possible truncation" };
+            return;
+          } else if ((yield* handleDataLine(residual)) === "terminate") return;
         }
         // Fail-closed: a turn cut off mid tool call (MAX_TOKENS / MALFORMED_FUNCTION_CALL) surfaces
         // an error instead of a silently-incomplete done. Mirrors kiro-truncation.
@@ -427,7 +467,20 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           yield { type: "error", message: vertexTruncationErrorMessage(lastFinishReason) };
           return;
         }
-        yield { type: "done", usage: pendingUsage };
+        if (!sawAnyFrame || !sawTerminalSignal) {
+          yield { type: "error", message: "upstream stream ended without a terminal signal — possible truncation" };
+          return;
+        }
+        const stopReason = lastFinishReason === "MAX_TOKENS"
+          ? "max_tokens"
+          : ["SAFETY", "RECITATION", "BLOCKLIST", "PROHIBITED_CONTENT", "SPII"].includes(lastFinishReason ?? "")
+            ? "content_filter"
+            : undefined;
+        yield {
+          type: "done",
+          usage: pendingUsage,
+          ...(stopReason ? { stopReason } : {}),
+        };
       } finally {
         reader.releaseLock();
       }

package/src/adapters/kiro.ts

@@ -917,23 +917,9 @@ async function* parseKiroAttempt(
         terminal: { type: "done", usage: finalUsage, endTurn: false, ...(finalProviderState ? { providerState: finalProviderState } : {}) },
       };
     }
-    // A clean Smithy EOF after ordinary assistant text is a complete answer even when the
-    // private completion tool was advertised. Replaying that answer through a second Kiro
-    // request adds latency and can hang an otherwise-finished Codex turn if the retry stalls.
-    // Reasoning-only output still needs the bounded fallback because it has no user-facing text.
-    if (mode === "required" && sawText) {
-      return {
-        assistantText,
-        sawReasoning,
-        terminal: {
-          type: "done",
-          usage: finalUsage,
-          endTurn: true,
-          ...(finalProviderState ? { providerState: finalProviderState } : {}),
-        },
-      };
-    }
-    if (mode === "required" && sawReasoning) {
+    // Kiro text has no trustworthy final/progress marker. When completion is required, ordinary
+    // text and reasoning remain unfinished until the one bounded fallback validates the turn.
+    if (mode === "required" && (sawText || sawReasoning)) {
       return { assistantText, sawReasoning, needsFallback: true, usage: finalUsage, providerState: finalProviderState };
     }
     if (!sawText && !sawReasoning) {

package/src/adapters/openai-chat.ts

@@ -604,7 +604,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       // being reported as a clean completion (silent truncation). A graceful close is either an
       // explicit `[DONE]` sentinel OR a chunk carrying a non-null `finish_reason` (some
       // OpenAI-compatible providers omit `[DONE]` but do send finish_reason).
-      let sawFinish = false;
+      let finishReason: string | undefined;
 
       // Single per-line handler shared by the streaming loop and the EOF residual-frame flush, so
       // a final frame is parsed identically wherever it lands (no duplicated, drift-prone parsing).
@@ -615,7 +615,12 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         const payload = line.slice(6).trim();
         if (payload === "[DONE]") {
           yield* flushToolCalls();
-          yield { type: "done", usage: pendingUsage };
+          const stopReason = finishReason === "length"
+            ? "max_tokens"
+            : finishReason === "content_filter"
+              ? "content_filter"
+              : undefined;
+          yield { type: "done", usage: pendingUsage, ...(stopReason ? { stopReason } : {}) };
           return "terminate";
         }
 
@@ -647,9 +652,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         const choices = chunk.choices as { delta?: Record<string, unknown>; finish_reason?: string }[] | undefined;
         if (!choices || choices.length === 0) return "continue";
         // Observe the terminator BEFORE the delta guard: a finish-only chunk (finish_reason set,
-        // no delta) is a graceful close and must mark sawFinish even though we skip it below.
+        // no delta) is a graceful close and must record finishReason even though we skip it below.
         if (typeof choices[0].finish_reason === "string" && choices[0].finish_reason) {
-          sawFinish = true;
+          finishReason = choices[0].finish_reason;
         }
         const delta = choices[0].delta;
         if (delta) {
@@ -720,12 +725,18 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         // 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
         // closed so the bridge emits a classified response.failed rather than a silent truncation.
+        const sawFinish = finishReason !== undefined;
         if (!sawFinish && pendingUsage === undefined) {
           yield { type: "error", message: "upstream stream ended without a terminal signal ([DONE] or finish_reason) — possible truncation" };
           return;
         }
         // Graceful close that omitted [DONE] but delivered finish_reason and/or final usage.
-        yield { type: "done", usage: pendingUsage };
+        const stopReason = finishReason === "length"
+          ? "max_tokens"
+          : finishReason === "content_filter"
+            ? "content_filter"
+            : undefined;
+        yield { type: "done", usage: pendingUsage, ...(stopReason ? { stopReason } : {}) };
       } finally {
         reader.releaseLock();
       }

package/src/adapters/openai-responses.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import type { IncomingMeta, ProviderAdapter } from "./base";
 import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../types";
 import { catalogModelSupportsReasoningSummaries } from "../codex/catalog";
@@ -328,6 +329,55 @@ function isPlainObject(v: unknown): v is Record<string, unknown> {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 
+const MAX_RESPONSES_CALL_ID_LENGTH = 64;
+const REPAIRED_CALL_ID_PREFIX = "call_ocx_";
+const REPAIRED_CALL_ID_DIGEST_LENGTH = MAX_RESPONSES_CALL_ID_LENGTH - REPAIRED_CALL_ID_PREFIX.length;
+
+/**
+ * The ChatGPT Responses backend rejects input `call_id` values longer than 64 characters. Codex
+ * sidechat/fork replay can namespace call ids from routed providers past that limit. Forward mode
+ * already sends explicit replay input without `previous_response_id`, so it is safe to replace each
+ * oversized id and every matching call/output occurrence with one deterministic request-local alias.
+ * Raw API-key continuations are intentionally excluded because an output-only continuation may
+ * reference a call stored upstream under the original id. Proxy-expanded API-key replays are
+ * explicit and stateless here, so they are safe to repair too.
+ */
+function repairOversizedReplayCallIds(body: unknown): unknown {
+  if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
+
+  const occupied = new Set<string>();
+  for (const item of body.input) {
+    if (!isPlainObject(item) || typeof item.call_id !== "string") continue;
+    if (item.call_id.length <= MAX_RESPONSES_CALL_ID_LENGTH) occupied.add(item.call_id);
+  }
+
+  const aliases = new Map<string, string>();
+  let changed = false;
+  const input = body.input.map(item => {
+    if (!isPlainObject(item) || typeof item.call_id !== "string") return item;
+    const original = item.call_id;
+    if (original.length <= MAX_RESPONSES_CALL_ID_LENGTH) return item;
+
+    let alias = aliases.get(original);
+    if (!alias) {
+      let salt = 0;
+      do {
+        const hashInput = salt === 0 ? original : `${original}\0${salt}`;
+        const digest = createHash("sha256").update(hashInput).digest("hex");
+        alias = `${REPAIRED_CALL_ID_PREFIX}${digest.slice(0, REPAIRED_CALL_ID_DIGEST_LENGTH)}`;
+        salt += 1;
+      } while (occupied.has(alias));
+      aliases.set(original, alias);
+      occupied.add(alias);
+    }
+
+    changed = true;
+    return { ...item, call_id: alias };
+  });
+
+  return changed ? { ...body, input } : body;
+}
+
 /** Flatten a Responses tool-output `output` value (string or content-part array) to plain text. */
 function toolOutputText(output: unknown): string {
   if (typeof output === "string") return output;
@@ -515,8 +565,13 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         parsed._rawBody,
         forward || parsed._previousResponseInputExpanded === true,
       );
-      if (forward) outBody = repairOrphanedInputItems(outBody, unexpandedMiss);
+      if (forward) {
+        outBody = repairOrphanedInputItems(outBody, unexpandedMiss);
+      }
       else outBody = stripConflictingHostedTools(outBody);
+      if (forward || parsed._previousResponseInputExpanded === true) {
+        outBody = repairOversizedReplayCallIds(outBody);
+      }
       outBody = stripUnsupportedReasoningSummaryDelivery(outBody, parsed.modelId);
       return {
         url,

package/src/adapters/run-turn-queue.ts

@@ -49,9 +49,13 @@ export async function preflightAdapterEvents(
   }
 }
 
-export function createAdapterEventQueue(): AdapterEventQueue {
+export function createAdapterEventQueue(opts?: {
+  maxBacklog?: number;
+  onBacklogExceeded?: () => void;
+}): AdapterEventQueue {
   const queued: AdapterEvent[] = [];
   const readers: QueueReader[] = [];
+  const maxBacklog = opts?.maxBacklog ?? 1_024;
   let closed = false;
 
   const push = (event: AdapterEvent): void => {
@@ -61,6 +65,12 @@ export function createAdapterEventQueue(): AdapterEventQueue {
       reader({ done: false, value: event });
       return;
     }
+    if (queued.length >= maxBacklog) {
+      opts?.onBacklogExceeded?.();
+      queued.push({ type: "error", message: "consumer backlog exceeded — turn aborted" });
+      close();
+      return;
+    }
     queued.push(event);
   };