@bitkyc08/opencodex 2.57.0 → 2.59.0

package/src/adapters/google.ts

@@ -57,7 +57,6 @@ const GOOGLE_BREVITY_INSTRUCTION = [
 
 const ANTIGRAVITY_REJECTED_CLAUDE_SDK_PARAGRAPH =
   "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
-
 /**
  * CCA Flash generations that reject the Claude-Agent identity paragraph.
  *
@@ -102,6 +101,20 @@ function stripAntigravityRejectedClaudeSdkParagraph(systemText: string): string
     .join("\n\n");
 }
 
+/**
+ * Strips Claude Code CLI's internal billing header (`x-anthropic-billing-header: ...`)
+ * at the start of the system prompt, because Cloud Code Assist / Google Antigravity inspects
+ * `systemInstruction` and rejects requests containing Anthropic billing metadata with
+ * HTTP 429 RESOURCE_EXHAUSTED.
+ *
+ * Matching is restricted to the prompt start (`^` without the `/m` multiline flag) so that
+ * user prompts discussing billing headers in intermediate lines are never modified, and
+ * prompts without a billing header preserve their leading whitespace untouched.
+ */
+function stripAntigravityBillingHeader(systemText: string): string {
+  return systemText.replace(/^x-anthropic-billing-header:[^\n]*\n*/, "");
+}
+
 /**
  * Documented output ceiling for a Google-surface model, or `undefined` when the id is not
  * recognized.
@@ -276,6 +289,7 @@ function messagesToGeminiFormat(
   parsed: OcxParsedRequest,
   identityModelId: string,
   stripRejectedClaudeSdkParagraph = false,
+  isCloudCodeAssist = false,
 ): { systemInstruction?: unknown; contents: unknown[]; replayedCallIds: string[] } {
   // Neutralize Codex's GPT-5 identity line (Gemini/Antigravity share this path) so a routed model
   // never misreports as GPT-5/OpenAI, and never leaks the proxy identity upstream.
@@ -285,9 +299,12 @@ function messagesToGeminiFormat(
     ...(toolCatalogNudge ? [toolCatalogNudge] : []),
     GOOGLE_BREVITY_INSTRUCTION,
   ].join("\n\n"), identityModelId);
-  const systemText = stripRejectedClaudeSdkParagraph
-    ? stripAntigravityRejectedClaudeSdkParagraph(identifiedSystemText)
+  let systemText = isCloudCodeAssist
+    ? stripAntigravityBillingHeader(identifiedSystemText)
     : identifiedSystemText;
+  if (stripRejectedClaudeSdkParagraph) {
+    systemText = stripAntigravityRejectedClaudeSdkParagraph(systemText);
+  }
   const systemInstruction = { parts: [{ text: systemText }] };
 
   const contents: unknown[] = [];
@@ -833,12 +850,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
         && /^gemini-/.test(routedModelId) && !isImageCapableModel(parsed.modelId);
       // AI Studio's `-tiered` spelling is wire-only; CCA aliases may migrate to another generation.
       const identityModelId = provider.googleMode === "cloud-code-assist" ? routedModelId : parsed.modelId;
-      const stripRejectedClaudeSdkParagraph = provider.googleMode === "cloud-code-assist"
+      const isCloudCodeAssist = provider.googleMode === "cloud-code-assist";
+      const stripRejectedClaudeSdkParagraph = isCloudCodeAssist
         && rejectsClaudeSdkParagraph(parsed.modelId, routedModelId);
       const { systemInstruction, contents, replayedCallIds } = messagesToGeminiFormat(
         parsed,
         identityModelId,
         stripRejectedClaudeSdkParagraph,
+        isCloudCodeAssist,
       );
       lastInjectedCallIds = [...replayedCallIds];
       lastReasoningReplayScope = parsed._reasoningReplayScope;

package/src/adapters/mimo-free.ts

@@ -6,6 +6,8 @@ import { recordOwnedConfigPath } from "../lib/config-ownership";
 import type { OcxProviderConfig, OcxParsedRequest } from "../types";
 import { createOpenAIChatAdapter } from "./openai-chat";
 import type { ProviderAdapter, AdapterRequest, IncomingMeta } from "./base";
+import { createAdapterPhysicalSend } from "./physical-send";
+import { SendBudgetExhaustedError } from "../lib/upstream-retry";
 
 const BOOTSTRAP_URL = "https://api.xiaomimimo.com/api/free-ai/bootstrap";
 export const MIMO_CHAT_URL = "https://api.xiaomimimo.com/api/free-ai/openai/chat";
@@ -248,33 +250,46 @@ export function createMimoFreeAdapter(provider: OcxProviderConfig): ProviderAdap
     },
 
     async fetchResponse(request: AdapterRequest, ctx): Promise<Response> {
-      const response = await fetch(request.url, {
+      const send = createAdapterPhysicalSend(ctx);
+      const response = await send({ url: request.url, dispatch: executor => executor(request.url, {
         method: request.method,
         redirect: "manual",
         headers: request.headers as Record<string, string>,
         body: request.body,
         signal: ctx?.abortSignal,
-      });
+      }) });
 
       // Retry predicate: 401 (expired/invalid JWT) retries ONCE with a fresh token.
       // 403 is NOT retried — Xiaomi uses it for anti-abuse "Illegal access" and there is
       // no documented token-expiry signature that would mark a 403 as retryable.
       if (response.status === 401) {
-        // Drain the first response body before issuing the retry.
-        try { await response.body?.cancel(); } catch { /* already consumed */ }
-        resetMimoJwtCache();
-        const freshJwt = await getMimoJwt(ctx?.abortSignal);
-        const retryHeaders = {
-          ...(request.headers as Record<string, string>),
-          "Authorization": `Bearer ${freshJwt}`,
-        };
-        return fetch(request.url, {
-          method: request.method,
-          redirect: "manual",
-          headers: retryHeaders,
-          body: request.body,
-          signal: ctx?.abortSignal,
-        });
+        let retryHeaders = request.headers;
+        try {
+          return await send({ url: request.url, sendClass: "auth-recovery", recovery: "oauth-401",
+            beforeDispatch: async () => {
+              // Drain the first response body and refresh the JWT only after admission: a
+              // refused replay still returns THIS response to the caller, body intact.
+              // Draining comes first within the block because getMimoJwt issues its own
+              // network call and may throw, and the 401 body would then never be released.
+              try { void response.body?.cancel().catch(() => {}); } catch { /* already consumed */ }
+              resetMimoJwtCache();
+              const freshJwt = await getMimoJwt(ctx?.abortSignal);
+              retryHeaders = {
+                ...(request.headers as Record<string, string>),
+                "Authorization": `Bearer ${freshJwt}`,
+              };
+            },
+            dispatch: executor => executor(request.url, {
+              method: request.method,
+              redirect: "manual",
+              headers: retryHeaders,
+              body: request.body,
+              signal: ctx?.abortSignal,
+            }) });
+        } catch (error) {
+          if (error instanceof SendBudgetExhaustedError) return response;
+          throw error;
+        }
       }
 
       return response;

package/src/adapters/ollama-native.ts

@@ -306,17 +306,37 @@ function buildNativeMessages(
   // owned by this adapter/request lifecycle rather than process-global state.
   reservedToolCallIds.clear();
   let pending: PendingToolBatch | undefined;
+  // Codex records mid-turn injections (a PostToolUse hook verdict, a context notice) between an
+  // assistant tool call and that call's own tool result. Native Ollama needs the call and its
+  // results adjacent, so those conversational messages wait here instead of closing the batch
+  // early. The openai-chat adapter defers them the same way; refusing the replay killed the turn.
+  let deferred: OllamaNativeMessage[] = [];
+
+  const releaseDeferred = (): void => {
+    if (deferred.length === 0) return;
+    messages.push(...deferred);
+    deferred = [];
+  };
 
   const flushPending = (): void => {
     if (!pending) return;
     for (const call of pending.calls) {
       if (!call.result) {
-        throw new Error(`ollama-native tool call ${call.id} is missing its tool result; refusing interrupted replay`);
+        // No result exists anywhere in the replayed history: the turn was interrupted, or the
+        // result never reached it. State exactly that instead of inventing an outcome, and keep
+        // the conversation replayable.
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          tool_name: call.wireName,
+          // Same marker text as the chat adapter (openai-chat/messages.ts), so both adapters read
+          // the same in an operator's log. The name is this wire's flattened tool name, which is
+          // what the assistant turn above it carries.
+          content: `[ocx] no tool result was recorded for "${call.wireName}"; execution status unknown — do not treat this as success, failure, or user-provided input.`,
+        });
+        continue;
       }
-    }
-    for (const call of pending.calls) {
-      const result = call.result!;
-      const translated = contentToNative(result.content, "tool result");
+      const translated = contentToNative(call.result.content, "tool result");
       messages.push({
         role: "tool",
         tool_call_id: call.id,
@@ -326,6 +346,7 @@ function buildNativeMessages(
       });
     }
     pending = undefined;
+    releaseDeferred();
   };
 
   for (const message of parsed.context.messages) {
@@ -347,9 +368,22 @@ function buildNativeMessages(
       continue;
     }
 
-    // Native Ollama requires the whole assistant tool-call turn followed by its tool results.  A
-    // new conversational message is a hard boundary; unresolved calls are never fabricated.
-    if (pending) flushPending();
+    // Native Ollama requires the whole assistant tool-call turn followed by its tool results. A
+    // conversational message that arrives while the batch is still open is held aside instead of
+    // closing it, so the call keeps its results adjacent; it is released right after the batch
+    // flushes. Anything else (a new assistant turn) settles the batch first.
+    if (pending) {
+      if (message.role === "user" || message.role === "developer") {
+        const translated = message.role === "user"
+          ? contentToNative(message.content, "user")
+          : contentToNative(message.content, "developer", false);
+        deferred.push(message.role === "user"
+          ? { role: "user", content: translated.content, ...(translated.images ? { images: translated.images } : {}) }
+          : { role: "system", content: translated.content });
+        continue;
+      }
+      flushPending();
+    }
 
     switch (message.role) {
       case "user": {

package/src/adapters/openai-chat/response-events.ts

@@ -1,4 +1,5 @@
 import { diagnoseInvalidToolCalls, isRecord, type InvalidToolCallDiagnostic } from "./tool-call-validation";
+import { TranslatorBudgetExceededError, type TranslatorBudget } from "../../lib/translator-budget";
 import type { AdapterEvent, OcxUsage } from "../../types";
 
 export function stopReasonFor(finishReason: unknown): "max_tokens" | "content_filter" | undefined {
@@ -22,6 +23,9 @@ export interface ReasoningDetailSegment {
   text: string;
 }
 
+const MAX_REASONING_DETAIL_KEY_BYTES = 1024;
+const MAX_REASONING_DETAIL_SEGMENTS = 1024;
+
 /**
  * Structured `reasoning_details` array (MiniMax M-series with `reasoning_split`).
  * Each segment's key scopes cumulative-snapshot tracking: upstream repeats the
@@ -35,6 +39,11 @@ export function reasoningDetailSegmentsFrom(record: Record<string, unknown>): Re
     const item: unknown = raw[i];
     if (!isRecord(item)) continue;
     if (typeof item.text !== "string" || item.text.length === 0) continue;
+    // Parsing retains nothing, so it rejects nothing. The non-streaming
+    // parseResponse path shares this function and reads only `text`; failing a
+    // whole valid response there because an opaque upstream id is long would be
+    // a new rejection unrelated to the retention bound. The key cap lives with
+    // the map that holds the key; see the tracker below.
     const key = typeof item.id === "string" && item.id.length > 0
       ? `id:${item.id}`
       : typeof item.index === "number"
@@ -45,6 +54,58 @@ export function reasoningDetailSegmentsFrom(record: Record<string, unknown>): Re
   return segments;
 }
 
+/**
+ * Per-stream cumulative-snapshot store for structured `reasoning_details`. Each stream chunk
+ * repeats a detail's full text-so-far, so deltas are derived by prefix-diffing per segment key;
+ * a piece that does not extend the previous snapshot is appended whole, which keeps incremental
+ * senders parseable on the same path. Retained key+text bytes are charged to the translator
+ * budget under the `reasoning` kind, and both the key length and the segment count are capped
+ * here, where the map actually retains them, so a hostile upstream cannot grow it without bound.
+ */
+export function createReasoningDetailSnapshotTracker(budget: TranslatorBudget): {
+  ingest(segment: ReasoningDetailSegment): string | null;
+  release(): void;
+} {
+  const snapshots = new Map<string, string>();
+  const encoder = new TextEncoder();
+  let retainedBytes = 0;
+  return {
+    ingest(segment) {
+      const existing = snapshots.get(segment.key);
+      if (existing === undefined && encoder.encode(segment.key).byteLength > MAX_REASONING_DETAIL_KEY_BYTES) {
+        throw new TranslatorBudgetExceededError("reasoning", MAX_REASONING_DETAIL_KEY_BYTES);
+      }
+      if (existing === undefined && snapshots.size >= MAX_REASONING_DETAIL_SEGMENTS) {
+        throw new TranslatorBudgetExceededError("reasoning", MAX_REASONING_DETAIL_SEGMENTS);
+      }
+      const prev = existing ?? "";
+      if (segment.text === prev) return null;
+      const extendsPrev = segment.text.startsWith(prev);
+      const next = extendsPrev ? segment.text : prev + segment.text;
+      const previousBytes = existing === undefined
+        ? 0
+        : encoder.encode(segment.key).byteLength + encoder.encode(prev).byteLength;
+      const nextBytes = encoder.encode(segment.key).byteLength + encoder.encode(next).byteLength;
+      const reservation = budget.reserveTransient(nextBytes, { kind: "reasoning" });
+      try {
+        snapshots.set(segment.key, next);
+        reservation.commitRetained();
+        budget.releaseRetained(previousBytes, { kind: "reasoning" });
+        retainedBytes += nextBytes - previousBytes;
+      } catch (error) {
+        reservation.release();
+        throw error;
+      }
+      return extendsPrev ? segment.text.slice(prev.length) : segment.text;
+    },
+    release() {
+      budget.releaseRetained(retainedBytes, { kind: "reasoning" });
+      retainedBytes = 0;
+      snapshots.clear();
+    },
+  };
+}
+
 /** Single-segment `reasoning_details` entry for replaying preserved reasoning (MiniMax wire shape). */
 export function reasoningDetailSegmentForWire(text: string): Record<string, unknown> {
   return { type: "reasoning.text", id: "reasoning-text-1", format: "MiniMax-response-v1", index: 0, text };

package/src/adapters/openai-chat.ts

@@ -23,6 +23,7 @@ import {
   type InvalidToolCallDiagnostic,
 } from "./openai-chat/tool-call-validation";
 import {
+  createReasoningDetailSnapshotTracker,
   invalidChoicesEvent,
   invalidToolCallsEvent,
   reasoningDetailSegmentsFrom,
@@ -385,7 +386,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       // full text-so-far, so deltas are derived by prefix-diffing per segment key.
       // A piece that does not extend the previous snapshot is appended whole, which
       // keeps incremental senders parseable on the same path.
-      const reasoningDetailSnapshots = new Map<string, string>();
+      const reasoningDetailTracker = createReasoningDetailSnapshotTracker(budget);
       // Gate on the routed model, not list length: a mixed openai-chat provider
       // can list MiniMax ids without putting every sibling on MiniMax semantics.
       const reasoningDetailsOptIn = modelInList(provider.reasoningDetailsModels, lastRequestedModelId ?? "");
@@ -448,15 +449,8 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           const detailSegments = reasoningDetailsOptIn ? reasoningDetailSegmentsFrom(delta) : [];
           if (detailSegments.length > 0) {
             for (const segment of detailSegments) {
-              const prev = reasoningDetailSnapshots.get(segment.key) ?? "";
-              if (segment.text === prev) continue;
-              if (segment.text.startsWith(prev)) {
-                reasoningDetailSnapshots.set(segment.key, segment.text);
-                yield { type: "reasoning_raw_delta", text: segment.text.slice(prev.length) };
-              } else {
-                reasoningDetailSnapshots.set(segment.key, prev + segment.text);
-                yield { type: "reasoning_raw_delta", text: segment.text };
-              }
+              const reasoningDelta = reasoningDetailTracker.ingest(segment);
+              if (reasoningDelta !== null) yield { type: "reasoning_raw_delta", text: reasoningDelta };
             }
           } else {
             const reasoningText = reasoningTextFrom(delta);
@@ -692,6 +686,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         throw error;
       } finally {
         budget.releaseRetained(bufferBytes, { kind: "live_transient" });
+        reasoningDetailTracker.release();
         closeToolCalls();
         reader.releaseLock();
       }

package/src/adapters/openai-responses/passthrough.ts

@@ -32,11 +32,12 @@ import {
   createAdapterTierMetadata,
 } from "../../providers/fastwire";
 import { mapRoutedResponsesReasoningEffort, normalizeConfiguredReasoningSummaryDelivery, sanitizeReasoningInputContent, stripDisabledReasoningSummaries, stripDisabledVerbosity, stripUnsupportedReasoningSummaryDelivery } from "./reasoning";
-import { scrubOcxCompactionItems, stripCanonicalOnlyToolFields, stripInternalChatMessageMetadataPassthrough, stripInvalidItemIds, stripItemIdsWhenUnstored } from "./request-strips";
+import { scrubOcxCompactionItems, stripCanonicalOnlyToolFields, stripCanonicalOnlyTopLevelFields, stripInternalChatMessageMetadataPassthrough, stripInvalidItemIds, stripItemIdsWhenUnstored } from "./request-strips";
 import { stripCanonicalForwardPromptCacheOptions, stripDeprecatedPromptCacheRetention } from "./prompt-cache";
 import { isPlainObject } from "./internal";
 import { normalizeToolSchemas, promoteClientLoadedTools, stripUnsupportedHostedTools } from "./tool-schema";
-import { annotateEmptyResponsesToolOutputs, backfillWebSearchQueries, normalizeResponsesToolResultAdjacency, repairOrphanedInputItems, repairOversizedReplayCallIds, repairUnidentifiedToolOutputItems } from "./tool-output-recovery";
+import { annotateEmptyResponsesToolOutputs, backfillWebSearchQueries, normalizeResponsesToolResultAdjacency, repairOrphanedInputItems, repairOversizedReplayCallIds, repairUnidentifiedToolOutputItems, restoreBridgedWebSearchCalls } from "./tool-output-recovery";
+import { bridgeSearchReplayScope } from "../../responses/bridge-search-replay-cache";
 import { applyTierDecisionToResponsesBody, normalizeCanonicalForwardContinuationEnvelope, normalizeCanonicalForwardPromptEnvelope, stripCanonicalForwardSamplingParams, stripPreviousResponseId, stripStatefulResponsesParams, stripUnsupportedForwardParams } from "./canonical-forward";
 import { normalizeImageGenClientTools, preferConfiguredHostedTools } from "./image-gen";
 import { stripMuseSparkUnsupportedWebSearchFields, stripOpenAiOnlyWebSearchFields } from "./web-search";
@@ -270,19 +271,31 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       // tier write so a force-fast/default decision can never mutate parsed._rawBody.
       outBody = applyTierDecisionToResponsesBody(outBody, parsed.options?.tierDecision);
       const stateless = provider.statelessResponses === true;
+      const adjacentToolResults = provider.requiresAdjacentResponsesToolResults === true;
+      // Adjacency reorders items the upstream would accept in some order. Pairing synthesizes an
+      // item the client never sent, which is a larger claim about the conversation, so it is its
+      // own capability: Kimi carries the adjacency flag but accepts a dangling call (#4726) and
+      // must not start receiving placeholders it never needed.
+      const pairedToolResults = provider.requiresPairedResponsesToolResults === true;
       if (stateless) outBody = stripStatefulResponsesParams(outBody);
       // A replay miss can leave a function_call_output whose paired function_call sat
       // in the prefix that was never expanded. A stateless upstream cannot resolve the
       // pair from its own storage either, so it needs the same repair the forward
       // backend gets — dropping previous_response_id is not much use if the body that
       // reaches the wire is unparseable.
+      // A parser can also 400 on a function_call with no matching output at all. DeepSeek gets
+      // that repair through statelessResponses. xAI cannot be marked stateless: its Responses API
+      // stores conversations for 30 days and documents previous_response_id. So it carries the
+      // pairing capability instead, which reuses the orphan-call placeholder without touching
+      // store or previous_response_id.
       if (provider.annotateEmptyToolOutputs === true) {
         outBody = annotateEmptyResponsesToolOutputs(outBody, true);
       }
-      if (forward || stateless) {
-        outBody = repairOrphanedInputItems(outBody, unexpandedMiss, stateless && !forward);
+      const synthesizeMissingCallOutputs = !forward && (stateless || pairedToolResults);
+      if (forward || stateless || pairedToolResults) {
+        outBody = repairOrphanedInputItems(outBody, unexpandedMiss, synthesizeMissingCallOutputs);
       }
-      if (provider.requiresAdjacentResponsesToolResults === true) {
+      if (adjacentToolResults) {
         outBody = normalizeResponsesToolResultAdjacency(outBody);
       }
       if (forward) {
@@ -309,6 +322,14 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         outBody = repairOversizedReplayCallIds(outBody);
       }
       outBody = stripUnsupportedReasoningSummaryDelivery(outBody, parsed.modelId);
+      // #4587: on a bridged provider, hand the destination back the search call and result the
+      // proxy executed on its behalf, in place of the hosted cell the caller replays. Scoped to
+      // this destination and recorded by the bridge itself, so a provider without the opt-in
+      // computes no identity and keeps the body reference it already had. This runs before the
+      // query backfill below because a restored cell is no longer a web_search_call to repair.
+      if (provider.webSearchBridge?.enabled === true) {
+        outBody = restoreBridgedWebSearchCalls(outBody, bridgeSearchReplayScope(provider.baseUrl));
+      }
       // Repair stored history from before the bridge emitted both keys, in either
       // direction: a conversation that already recorded a web_search_call replays it
       // every turn, and a strict parser rejects the whole request over the missing key —
@@ -316,6 +337,20 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       outBody = backfillWebSearchQueries(outBody);
       if (!isCanonicalOpenAiForwardProvider(provider)) {
         outBody = stripInternalChatMessageMetadataPassthrough(outBody);
+        // The same class of private field, one level up, but keyed on the DESTINATION rather than
+        // on the canonical surface alone. `src/server/responses/compact.ts` spreads the caller's
+        // raw body into the native `/responses/compact` request without passing through this
+        // adapter, and that endpoint is offered only to OpenAI-operated destinations
+        // (supportsNativeResponsesCompactEndpoint). Stripping on the canonical predicate here
+        // would make the two paths disagree for `openai-apikey`; stripping on the destination
+        // keeps every OpenAI-operated route byte-identical and removes the field exactly where it
+        // is known to break, which is a gateway this proxy does not operate.
+        //
+        // Placed before the routed compaction body is built and before serialization, so the HTTP,
+        // routed-compaction and WebSocket outbounds are all covered by this one call.
+        if (!isOpenAiOperatedResponsesDestination(provider)) {
+          outBody = stripCanonicalOnlyTopLevelFields(outBody);
+        }
         outBody = promoteClientLoadedTools(outBody);
       }
       if (!isCanonicalOpenAiForwardProvider(provider)) {

package/src/adapters/openai-responses/request-strips.ts

@@ -120,6 +120,49 @@ export function stripInternalChatMessageMetadataPassthrough(body: unknown): unkn
   return changed ? { ...body, input } : body;
 }
 
+/**
+ * OpenAI-private TOP-LEVEL request keys, the sibling of `CANONICAL_ONLY_TOOL_FIELDS` one level up.
+ *
+ * Codex attaches these on the request body itself rather than on a tool or an input item, and gates
+ * them on its own auth rather than on the destination URL. Loopback injection keeps Codex pointed at
+ * its built-in `openai` provider, so the client still believes it is addressing the canonical
+ * ChatGPT backend and keeps the key no matter where this proxy routes the turn. A Responses gateway
+ * that validates its top-level schema then rejects the whole request before inference.
+ *
+ * Keep this a table, and keep it to keys a client is OBSERVED to send. It is not an unknown-field
+ * sanitizer: a top-level key nobody has traced to a client is forwarded untouched, because deleting
+ * it would silently drop a parameter some other caller means.
+ */
+const CANONICAL_ONLY_TOP_LEVEL_FIELDS: readonly string[] = [
+  // Cyber access program selector, new in Codex 0.155. codex-rs mints it from
+  // `cyber_access_program::for_auth`, which filters on ChatGPT auth alone and never on the
+  // destination base URL, and serializes it on the Responses request, the compaction input and the
+  // WebSocket `response.create` envelope. No public specification defines it, so a strict
+  // third-party gateway answers with an unknown-parameter error naming it, and every turn of that
+  // thread fails (#4853).
+  //
+  // `codex_output_schema` is deliberately NOT here. In codex-rs it is the `name` of the JSON-schema
+  // `text.format` object, not a top-level key, so listing it would delete a field this client never
+  // sends and discard it for any client that does send it meaningfully.
+  "access_programs",
+];
+
+/**
+ * Remove the OpenAI-private top-level keys.
+ *
+ * The caller decides the boundary; see the call site in `passthrough.ts`, which applies this only
+ * to a destination OpenCodex does not operate. Returns the input unchanged when no listed key is
+ * present, so the common path allocates nothing and the caller-owned raw body is never mutated.
+ */
+export function stripCanonicalOnlyTopLevelFields(body: unknown): unknown {
+  if (!isPlainObject(body)) return body;
+  if (!CANONICAL_ONLY_TOP_LEVEL_FIELDS.some(field => Object.hasOwn(body, field))) return body;
+
+  const next = { ...body };
+  for (const field of CANONICAL_ONLY_TOP_LEVEL_FIELDS) delete next[field];
+  return next;
+}
+
 /**
  * When `store` is false, the upstream API does not persist response items. Any item ID
  * forwarded in `input` is then interpreted as a reference to a stored item that does not

package/src/adapters/openai-responses/tool-output-recovery.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { EMPTY_TOOL_OUTPUT_ANNOTATION, isWhitespaceOnlyTextPartArray } from "../empty-tool-output-annotation";
 import { isPlainObject } from "./internal";
+import { peekBridgeSearchReplay } from "../../responses/bridge-search-replay-cache";
 
 const MAX_RESPONSES_CALL_ID_LENGTH = 64;
 
@@ -265,6 +266,80 @@ export function backfillWebSearchQueries(body: unknown): unknown {
   return changed ? { ...body, input } : body;
 }
 
+/**
+ * Give a bridged destination back its own search call and result (issue #4587).
+ *
+ * When `providers.<name>.webSearchBridge` is armed, the proxy intercepts the destination's
+ * `function_call` named `web_search`, runs the search, and shows the CALLER a hosted
+ * `web_search_call` cell. The caller stores that cell and replays it on every later turn, so the
+ * destination receives an item type it never produced, carrying a query and sources but no result.
+ * It typically responds by searching again.
+ *
+ * This restores the exchange the destination actually had: the cell becomes the destination's own
+ * `function_call`, immediately followed by the `function_call_output` the bridge produced for
+ * it, in the cell's original position. It runs before the first leg of the next turn is
+ * dispatched, which is the only place it can run — by the time the bridge wraps a turn, that
+ * turn's first leg is already on the wire.
+ *
+ * Three things it deliberately does not do:
+ *   - It never re-runs a search. A missing memo entry means the result is gone, and paying for a
+ *     second search would answer the model with a different search than its history claims.
+ *   - It never invents result text. A miss leaves the item exactly as the caller sent it, which is
+ *     the behaviour every unbridged conversation already has.
+ *   - It never restores a call id the body already carries. If the history somehow holds that
+ *     `function_call` too, emitting a second one would be a duplicate the upstream must reject.
+ *
+ * Entries are scoped to the upstream destination, so a history replayed against a different
+ * provider cannot resurrect a call that provider never made. Callers pass `undefined` for any
+ * provider without the bridge armed, and the common path then returns the original reference.
+ */
+export function restoreBridgedWebSearchCalls(body: unknown, destinationScope: string | undefined): unknown {
+  if (destinationScope === undefined) return body;
+  if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
+  const input = body.input;
+
+  // Cheap pre-check: nothing to do for a conversation that carries no hosted search cell at all,
+  // which is every turn before the model's first bridged search.
+  let hasCell = false;
+  for (const item of input) {
+    if (isPlainObject(item) && item.type === "web_search_call" && typeof item.id === "string") {
+      hasCell = true;
+      break;
+    }
+  }
+  if (!hasCell) return body;
+
+  const occupiedCallIds = new Set<string>();
+  for (const item of input) {
+    if (isPlainObject(item) && typeof item.call_id === "string") occupiedCallIds.add(item.call_id);
+  }
+
+  let changed = false;
+  const restored: unknown[] = [];
+  for (const item of input) {
+    if (isPlainObject(item) && item.type === "web_search_call" && typeof item.id === "string") {
+      const memo = peekBridgeSearchReplay(destinationScope, item.id);
+      if (memo && !occupiedCallIds.has(memo.callId)) {
+        changed = true;
+        occupiedCallIds.add(memo.callId);
+        restored.push({
+          type: "function_call",
+          ...(memo.sourceItemId ? { id: memo.sourceItemId } : {}),
+          call_id: memo.callId,
+          name: memo.name,
+          // The bridge records the complete arguments text from the call's own done frame; the
+          // empty-object fallback matches what a continuation leg would have sent.
+          arguments: memo.argumentsText.length > 0 ? memo.argumentsText : "{}",
+        });
+        restored.push({ type: "function_call_output", call_id: memo.callId, output: memo.output });
+        continue;
+      }
+    }
+    restored.push(item);
+  }
+  return changed ? { ...body, input: restored } : body;
+}
+
 export function repairOrphanedInputItems(body: unknown, dropReasoning: boolean, synthesizeMissingCallOutputs = false): unknown {
   if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
   const input = body.input;

package/src/adapters/openai-responses/tool-schema.ts

@@ -1,5 +1,5 @@
 import { namespacedToolName, type AdapterEvent, type OcxParsedRequest, type OcxProviderConfig, type OcxUsage, type TierDecision } from "../../types";
-import { isHostedToolUnsupportedForModel } from "../../responses/hosted-tool-policy";
+import { declaredUnsupportedHostedTools, isHostedToolUnsupportedForModel } from "../../responses/hosted-tool-policy";
 import { debugProviderDiagnostic } from "../../lib/debug";
 import { stripUnicodePropertyPatterns } from "../responses-tool-schema";
 import {
@@ -225,17 +225,29 @@ export function promoteClientLoadedTools(body: unknown): unknown {
 }
 
 /**
- * Remove hosted tool entries the target native slug rejects, so the OAuth-passthrough body never
- * carries a tool the upstream model 400s on. No-op (returns the original reference) when nothing
- * matches, keeping the common path allocation-free.
+ * Remove hosted tool entries the destination rejects, so the OAuth-passthrough body never
+ * carries a tool the upstream 400s on. Two sources of truth are consulted: the built-in
+ * table of known-broken native slugs and destinations, and the routed provider's own
+ * `unsupportedHostedTools` declaration. The declaration is what lets an OpenAI-compatible
+ * Responses gateway with a narrower capability set be described in config instead of
+ * requiring a hard-coded destination rule per vendor (#5002).
+ *
+ * No-op (returns the original reference) when nothing matches, keeping the common path
+ * allocation-free.
  */
-export function stripUnsupportedHostedTools(body: unknown, provider: Pick<OcxProviderConfig, "baseUrl">): unknown {
+export function stripUnsupportedHostedTools(
+  body: unknown,
+  provider: Pick<OcxProviderConfig, "baseUrl" | "unsupportedHostedTools">,
+): unknown {
   if (!isPlainObject(body)) return body;
   const model = typeof body.model === "string" ? body.model : "";
+  // Expanded once per request rather than per tool: the alias walk is the only
+  // non-lookup work in this filter.
+  const declaredUnsupported = declaredUnsupportedHostedTools(provider);
   const filterTools = (tools: unknown[]): unknown[] => {
     const filtered = tools.filter(t => {
       const type = isPlainObject(t) && typeof t.type === "string" ? t.type : undefined;
-      return !type || !isHostedToolUnsupportedForModel(model, type, provider.baseUrl);
+      return !type || !isHostedToolUnsupportedForModel(model, type, provider.baseUrl, declaredUnsupported);
     });
     return filtered.length === tools.length ? tools : filtered;
   };
@@ -274,7 +286,7 @@ export function stripUnsupportedHostedTools(body: unknown, provider: Pick<OcxPro
   } else if (
     isPlainObject(toolChoice)
     && typeof toolChoice.type === "string"
-    && isHostedToolUnsupportedForModel(model, toolChoice.type, provider.baseUrl)
+    && isHostedToolUnsupportedForModel(model, toolChoice.type, provider.baseUrl, declaredUnsupported)
   ) {
     next = { ...next, tool_choice: "none" };
     changed = true;