@bitkyc08/opencodex 2.56.0 → 2.58.0

package/src/web-search/passthrough-bridge.ts

@@ -128,6 +128,22 @@ const MAX_QUERIES_PER_CALL = 3;
 const MAX_RETAINED_OUTPUT_ITEMS = 500;
 /** Refuse to buffer an unbounded partial SSE event from a misbehaving upstream. */
 const MAX_SSE_BUFFER_CHARS = 8 * 1024 * 1024;
+/** UTF-16 code units in SSE data payloads, not a byte or total-heap measurement. */
+const MAX_HELD_CALL_CHARS = 8 * 1024 * 1024;
+/**
+ * Derived from MAX_HELD_CALL_CHARS rather than picked, so the two bounds bind at the same
+ * scale. The character budget is the real memory guard; this count only adds the per-event
+ * object overhead the character budget cannot see. A fine-grained argument delta serializes
+ * to roughly 128 code units -- an envelope of about 110 characters carrying the item id and
+ * output index, plus a token-sized fragment -- so 8 MiB of them is 65,536 events. The count
+ * therefore bites only for events smaller than that average. A flat 1,000 discarded a
+ * legitimate client-executed tool call: a sizeable apply_patch streamed as fine-grained
+ * deltas is ordinary, not exotic, and failing its leg trades one failure for another.
+ */
+export const MAX_HELD_CALL_EVENTS = MAX_HELD_CALL_CHARS / 128;
+
+/** A proxy-side admission bound, never an upstream transport failure. */
+class HeldCallBudgetExceededError extends Error {}
 
 /**
  * Retained for importers that pinned the first slice's contract: a leg mixing the search with
@@ -488,6 +504,7 @@ class BridgeStreamState {
    * failing the turn would let Codex start running a tool for a turn that never completes.
    */
   private heldCalls: HeldCallEvent[] = [];
+  private heldCallChars = 0;
   private heldIndexes = new Set<number>();
   private heldItemIds = new Set<string>();
   private terminalPayload: Record<string, unknown> | undefined;
@@ -497,9 +514,7 @@ class BridgeStreamState {
     this.suppressedSearches = new Map();
     this.suppressedItemIds = new Map();
     this.searches = [];
-    this.heldCalls = [];
-    this.heldIndexes = new Set();
-    this.heldItemIds = new Set();
+    this.dropHeldCalls();
     this.terminalPayload = undefined;
   }
 
@@ -507,6 +522,17 @@ class BridgeStreamState {
     return this.heldCalls.length > 0;
   }
 
+  private holdCall(payload: Record<string, unknown>, dataChars: number, upstreamIndex?: number): void {
+    if (this.heldCalls.length >= MAX_HELD_CALL_EVENTS
+      || dataChars > MAX_HELD_CALL_CHARS - this.heldCallChars) {
+      throw new HeldCallBudgetExceededError(
+        "web-search bridge withheld more client tool events than its per-leg buffer bound allows",
+      );
+    }
+    this.heldCalls.push({ payload, ...(upstreamIndex === undefined ? {} : { upstreamIndex }) });
+    this.heldCallChars += dataChars;
+  }
+
   private clientIndexFor(upstreamIndex: number): number {
     const existing = this.indexMap.get(upstreamIndex);
     if (existing !== undefined) return existing;
@@ -626,7 +652,7 @@ class BridgeStreamState {
       if (isClientExecutedItem(item)) {
         if (upstreamIndex !== undefined) this.heldIndexes.add(upstreamIndex);
         if (typeof item.id === "string") this.heldItemIds.add(item.id);
-        this.heldCalls.push({ payload, ...(upstreamIndex === undefined ? {} : { upstreamIndex }) });
+        this.holdCall(payload, data.length, upstreamIndex);
         return [];
       }
     }
@@ -648,7 +674,7 @@ class BridgeStreamState {
 
     if ((upstreamIndex !== undefined && this.heldIndexes.has(upstreamIndex))
       || (itemId !== undefined && this.heldItemIds.has(itemId))) {
-      this.heldCalls.push({ payload, ...(upstreamIndex === undefined ? {} : { upstreamIndex }) });
+      this.holdCall(payload, data.length, upstreamIndex);
       return [];
     }
 
@@ -658,19 +684,20 @@ class BridgeStreamState {
     return [this.render(payload.type, rewritten)];
   }
 
-  /** Release the withheld client tool calls once the turn is known to end here. */
-  flushHeldCalls(): string[] {
-    const blocks: string[] = [];
-    for (const held of this.heldCalls) {
-      const rewritten: Record<string, unknown> = { ...held.payload };
-      if (held.upstreamIndex !== undefined) {
-        rewritten.output_index = this.clientIndexFor(held.upstreamIndex);
+  /** Release lazily so flushing does not allocate a second full set of serialized events. */
+  *flushHeldCalls(): Generator<string> {
+    try {
+      for (const held of this.heldCalls) {
+        const rewritten: Record<string, unknown> = { ...held.payload };
+        if (held.upstreamIndex !== undefined) {
+          rewritten.output_index = this.clientIndexFor(held.upstreamIndex);
+        }
+        if (held.payload.type === "response.output_item.done") this.retain(held.payload.item);
+        yield this.render(String(held.payload.type), rewritten);
       }
-      if (held.payload.type === "response.output_item.done") this.retain(held.payload.item);
-      blocks.push(this.render(String(held.payload.type), rewritten));
+    } finally {
+      this.dropHeldCalls();
     }
-    this.heldCalls = [];
-    return blocks;
   }
 
   /**
@@ -680,6 +707,18 @@ class BridgeStreamState {
    */
   dropHeldCalls(): void {
     this.heldCalls = [];
+    this.heldCallChars = 0;
+    this.heldIndexes.clear();
+    this.heldItemIds.clear();
+  }
+
+  /** Fail before executing this leg's searches, closing every cell already shown to the client. */
+  *failLegFrames(code: string, message: string): Generator<string> {
+    this.dropHeldCalls();
+    for (const call of this.searches) {
+      yield* this.searchEndFrames(call, [], { text: "", sources: [], error: message });
+    }
+    yield* this.failureFrames(code, message);
   }
 
   /** Decide what the leg's terminal means once the whole leg has been read. */
@@ -979,7 +1018,7 @@ async function* bridgeStreamBlocks(
   // One continuation leg per allowed search, plus one final leg for the answer itself.
   let legsRemaining = options.plan.maxSearches + 1;
 
-  const emit = function* (blocks: readonly string[]): Generator<string> {
+  const emit = function* (blocks: Iterable<string>): Generator<string> {
     for (const block of blocks) yield block + "\n\n";
   };
 
@@ -991,10 +1030,15 @@ async function* bridgeStreamBlocks(
         if (aborted()) return;
       }
     } catch (error) {
+      if (aborted()) return;
       const message = error instanceof Error ? error.message : String(error);
-      yield* emit(state.failureFrames(
+      // A held-event overflow is this proxy's own bound. Attributing it to an upstream read
+      // failure would blame the provider for a refusal the bridge made.
+      yield* emit(state.failLegFrames(
         WEB_SEARCH_BRIDGE_ERROR_CODE,
-        "web-search bridge upstream read failed: " + message,
+        error instanceof HeldCallBudgetExceededError
+          ? message
+          : "web-search bridge upstream read failed: " + message,
       ));
       return;
     }
@@ -1003,18 +1047,7 @@ async function* bridgeStreamBlocks(
 
     const decision = state.decide(legsRemaining);
     if (decision.kind === "fail") {
-      // Close any cell this leg opened, or Codex keeps a "Searching the web" spinner running
-      // under a failed turn (the same reason src/bridge.ts closes a dangling search on teardown).
-      for (const call of decision.searches) {
-        yield* emit(state.searchEndFrames(call, [], {
-          text: "",
-          sources: [],
-          error: decision.message!,
-        }));
-      }
-      // The withheld client call is deliberately dropped: the turn is ending as failed, and
-      // releasing a tool call Codex would start executing is exactly what must not happen.
-      yield* emit(state.failureFrames(decision.code!, decision.message!));
+      yield* emit(state.failLegFrames(decision.code!, decision.message!));
       return;
     }
     if (decision.kind === "end") {

package/src/web-search/xai-executor.ts

@@ -110,7 +110,7 @@ export async function runXaiWebSearch(
         // Credential-bearing: never follow a redirect off the pinned origin.
         redirect: "manual",
       }, recovery)),
-      { abortSignal: linkedSignal.signal, label: "xai-web-search-sidecar" },
+      { replaySafe: true, abortSignal: linkedSignal.signal, label: "xai-web-search-sidecar" },
     );
     const detachBodyGuard = cancelBodyOnAbort(res.body, linkedSignal.signal);
     if (!res.ok) {