@bitkyc08/opencodex 2.7.13 → 2.7.18

package/src/bridge.ts

@@ -146,11 +146,13 @@ export function bridgeToResponsesSSE(
 
   return new ReadableStream<Uint8Array>({
     async start(controller) {
+      let emittedSinceYield = false;
       const emit = (name: string, data: Record<string, unknown>) => {
         if (closed) return;
         activity = true;
         try {
           controller.enqueue(encoder.encode(sseEvent(name, { type: name, sequence_number: seq++, ...data })));
+          emittedSinceYield = true;
         } catch {
           closed = true;
         }
@@ -264,7 +266,7 @@ export function bridgeToResponsesSSE(
       let currentToolCall: { itemId: string; outputIndex: number; callId: string; name: string; args: string; namespace?: string; freeform?: boolean; toolSearch?: boolean; inputEmitted?: string } | null = null;
       // Open native web-search cell (between begin and end). Holds the output index allocated on
       // begin so the matching done reuses it; closed as `failed` if the stream terminates early.
-      let currentWebSearch: { itemId: string; outputIndex: number } | null = null;
+      let currentWebSearch: { itemId: string; eventId: string; outputIndex: number } | null = null;
       // Sources from completed web searches, awaiting the next assistant message. Attached as
       // url_citation annotations on that message (the desktop app's Sources chip), then cleared so
       // they bind to exactly one message. Deduped by URL across multiple searches in the turn.
@@ -399,9 +401,19 @@ export function bridgeToResponsesSSE(
       // we synthesize response.completed below, so Codex never hits the parser's
       // "stream closed before response.completed" (responses.rs) -> ApiError::Stream.
       let terminated = false;
+      let macrotaskFired = true;
+      let macrotaskTimer: ReturnType<typeof setTimeout> | undefined;
 
       try {
         for await (const event of events) {
+          if (!macrotaskFired && emittedSinceYield) {
+            await new Promise<void>(r => setTimeout(r, 0));
+            macrotaskFired = true;
+          }
+          emittedSinceYield = false;
+          macrotaskFired = false;
+          if (macrotaskTimer !== undefined) clearTimeout(macrotaskTimer);
+          macrotaskTimer = setTimeout(() => { macrotaskFired = true; macrotaskTimer = undefined; }, 0);
           activity = true;
           stallTicks = 0;
           // Compaction turns emit ONLY the synthetic compaction item + response.completed. The
@@ -498,12 +510,12 @@ export function bridgeToResponsesSSE(
               if (currentRawReasoning) closeCurrentRawReasoning();
               flushHiddenRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
-              const itemId = `fc_${uuid()}`;
               const mapped = toolNsMap?.get(event.name);
               const realName = mapped?.name ?? event.name;
               const ns = mapped?.namespace;
               const toolSearch = toolSearchToolNames?.has(realName) ?? false;
               const freeform = !toolSearch && (freeformToolNames?.has(realName) ?? false);
+              const itemId = `${toolSearch ? "tsc" : freeform ? "ctc" : "fc"}_${uuid()}`;
               const item = toolSearch
                 ? { type: "tool_search_call", id: itemId, call_id: event.id, execution: "client", arguments: {}, status: "in_progress" }
                 : freeform
@@ -554,23 +566,25 @@ export function bridgeToResponsesSSE(
               flushHiddenRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
               if (currentWebSearch) closeCurrentWebSearch("completed", []);
+              const wsItemId = `ws_${uuid()}`;
               emit("response.output_item.added", {
                 output_index: outputIndex,
-                item: { type: "web_search_call", id: event.id, status: "in_progress" },
+                item: { type: "web_search_call", id: wsItemId, status: "in_progress" },
               });
-              currentWebSearch = { itemId: event.id, outputIndex };
+              currentWebSearch = { itemId: wsItemId, eventId: event.id, outputIndex };
               break;
             }
             case "web_search_call_end": {
               // The sidecar resolved — finalize the cell as "Searched <query>". If no begin opened
               // (defensive), synthesize the added frame first so the done has a matching item.
-              if (!currentWebSearch || currentWebSearch.itemId !== event.id) {
+              if (!currentWebSearch || currentWebSearch.eventId !== event.id) {
                 if (currentWebSearch) closeCurrentWebSearch("completed", []);
+                const wsItemId2 = `ws_${uuid()}`;
                 emit("response.output_item.added", {
                   output_index: outputIndex,
-                  item: { type: "web_search_call", id: event.id, status: "in_progress" },
+                  item: { type: "web_search_call", id: wsItemId2, status: "in_progress" },
                 });
-                currentWebSearch = { itemId: event.id, outputIndex };
+                currentWebSearch = { itemId: wsItemId2, eventId: event.id, outputIndex };
               }
               closeCurrentWebSearch(event.status ?? "completed", event.queries, event.sources);
               // Queue this search's sources for the next assistant message (dedup by URL).
@@ -650,6 +664,7 @@ export function bridgeToResponsesSSE(
       }
 
       if (beat) clearInterval(beat);
+      if (macrotaskTimer !== undefined) clearTimeout(macrotaskTimer);
 
       if (!terminated) {
         // The adapter generator ended without an explicit done/error event. Mark as incomplete
@@ -782,13 +797,13 @@ export function buildResponseJSON(
     const freeform = !toolSearch && (options?.freeformToolNames?.has(realName) ?? false);
     if (toolSearch) {
       output.push({
-        type: "tool_search_call", id: `fc_${uuid()}`,
+        type: "tool_search_call", id: `tsc_${uuid()}`,
         call_id: currentToolCallId, execution: "client",
         arguments: parseArgsObj(currentToolCallArgs), status: "completed",
       });
     } else if (freeform) {
       output.push({
-        type: "custom_tool_call", id: `fc_${uuid()}`,
+        type: "custom_tool_call", id: `ctc_${uuid()}`,
         call_id: currentToolCallId, name: realName,
         input: freeformInput(currentToolCallArgs), status: "completed",
       });
@@ -862,7 +877,7 @@ export function buildResponseJSON(
         if (currentRawReasoning) flushRawReasoning();
         flushToolCall();
         output.push({
-          type: "web_search_call", id: e.id, status: e.status ?? "completed",
+          type: "web_search_call", id: `ws_${uuid()}`, status: e.status ?? "completed",
           action: webSearchAction(e.queries),
           ...(e.sources && e.sources.length > 0 ? { sources: e.sources } : {}),
         });

package/src/cli/claude.ts

@@ -54,6 +54,9 @@ export function buildClaudeEnv(config: OcxConfig, port: number, base: ClaudeLaun
   if ((config.apiKeys?.length ?? 0) > 0) {
     setDefault("ANTHROPIC_AUTH_TOKEN", config.apiKeys![0].key);
   }
+  if (!env.ANTHROPIC_AUTH_TOKEN && config.claudeCode?.authMode === "proxy") {
+    env.ANTHROPIC_AUTH_TOKEN = "opencodex-proxy";
+  }
   // NOTE: do NOT set _CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL here. While it enables
   // Design/Remote Control, it DISABLES gateway model discovery (Claude Code's eligibility
   // check returns false when isFirstPartyBaseUrl() is true). Model routing through the

package/src/codex/catalog.ts

@@ -851,6 +851,17 @@ function deriveEntry(template: RawEntry | null, slug: string, desc: string, prio
       applyNativeOpenAiContextOverride(e);
       if (isGpt56NativeSlug(slug)) ensureGpt56ReasoningLevels(e);
       else ensureUltraReasoningLevel(e);
+     // Non-5.6 natives (5.5, 5.4, 5.4-mini, spark) do not support responses-lite;
+     // the template may carry the flag from a 5.6 entry — strip it so codex-rs does
+     // not inject reasoning.context: "all_turns" for models that reject it.
+     if (!isGpt56NativeSlug(slug)) {
+        // Spark NEEDS use_responses_lite: true — it controls the tool delivery format
+        // (AdditionalTools in input vs top-level tools). The reasoning params that
+        // use_responses_lite triggers (context: "all_turns", summary) are stripped
+        // separately in the passthrough adapter (stripUnsupportedReasoningParams).
+        if (!slug.includes("codex-spark")) delete e.use_responses_lite;
+        delete e.supports_websockets;
+      }
     }
     return ensureStrictCatalogFields(normalizeServiceTiers(e));
   }

package/src/lib/upstream-retry.ts

@@ -94,11 +94,17 @@ export async function fetchWithAttemptDeadline(
   init: RequestInit,
   timeoutMs: number,
   abortSignal?: AbortSignal,
+  preferIdentityEncoding = false,
 ): Promise<Response> {
   const attemptTimeout = clearableDeadline(timeoutMs, abortSignal);
+  const headers = new Headers(init.headers);
+  if (preferIdentityEncoding && !headers.has("accept-encoding")) {
+    headers.set("accept-encoding", "identity");
+  }
   try {
     return await fetch(url, {
       ...init,
+      headers,
       signal: attemptTimeout.signal,
     });
   } finally {

package/src/providers/registry.ts

@@ -153,6 +153,17 @@ const KIMI_AUTO_TOOL_CHOICE_ONLY_MODELS = ["kimi-k2.7-code", "kimi-k2.7-code-hig
 const KIMI_API_MODEL_CONTEXT_WINDOWS: Record<string, number> = Object.fromEntries(
   KIMI_API_MODELS.map(id => [id, 262_144]),
 );
+
+// 260715 NVIDIA NIM kimi family (issue #126): documented served ids on integrate
+// chat/completions per docs.api.nvidia.com/nim/reference/llm-apis; live /v1/models
+// currently lists only kimi-k2.6 but the list is dynamic, so carry the documented family.
+const NVIDIA_NIM_KIMI_THINKING_MODELS = [
+  "moonshotai/kimi-k2.6", "moonshotai/kimi-k2.5", "moonshotai/kimi-k2-thinking",
+];
+const NVIDIA_NIM_KIMI_MODELS = [
+  ...NVIDIA_NIM_KIMI_THINKING_MODELS,
+  "moonshotai/kimi-k2-instruct", "moonshotai/kimi-k2-instruct-0905",
+];
 const KIMI_CODING_MODEL_CONTEXT_WINDOWS: Record<string, number> = Object.fromEntries(
   KIMI_CODING_MODELS.map(id => [id, 262_144]),
 );
@@ -202,7 +213,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     authKind: "oauth",
     featured: false,
     dashboardPreset: true,
-    note: "Experimental Cursor bridge. Live transport and live model discovery are enabled after a standalone PKCE browser login via 'ocx login cursor'; native read/write/delete/shell/fetch execution stays disabled unless you set \"nativeLocalExec\": \"on\" (always) or \"codex-sandbox\" (only for requests declaring the Codex danger-full-access sandbox; the declaration is caller-controlled prose the proxy cannot verify, and the auth-free loopback bind admits any process on this host, including other local users — enable only where every data-plane client is trusted) — legacy \"unsafeAllowNativeLocalExec\": true still means \"on\" — on providers.cursor in ~/.opencodex/config.json (dashboard: Providers → Cursor → Edit JSON) for a trusted local experiment.",
+    note: "Experimental Cursor bridge. Live transport and live model discovery are enabled after a standalone PKCE browser login via 'ocx login cursor'; native read/write/delete/shell/fetch execution defaults to codex-sandbox mode (auto-enabled when the request declares Codex danger-full-access sandbox); override with \"nativeLocalExec\": \"on\" (always), \"off\" (never), or \"codex-sandbox\" (only for requests declaring the Codex danger-full-access sandbox; the declaration is caller-controlled prose the proxy cannot verify, and the auth-free loopback bind admits any process on this host, including other local users — enable only where every data-plane client is trusted) — legacy \"unsafeAllowNativeLocalExec\": true still means \"on\" — on providers.cursor in ~/.opencodex/config.json (dashboard: Providers → Cursor → Edit JSON) for a trusted local experiment.",
     models: cursorModelIds(CURSOR_STATIC_MODELS),
     liveModels: true,
     defaultModel: "auto",
@@ -497,7 +508,21 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     preserveReasoningContentModels: KIMI_API_MODELS,
   },
   { id: "huggingface", label: "Hugging Face", baseUrl: "https://router.huggingface.co/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://huggingface.co/settings/tokens" },
-  { id: "nvidia", label: "NVIDIA NIM", baseUrl: "https://integrate.api.nvidia.com/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://build.nvidia.com" },
+  // 260715 NIM hardening (issue #126, devlog/_plan/260715_issue126_nim_kimi):
+  // - NIM kimi rejects `parallel_tool_calls: true` with 400 "This model only supports single
+  //   tool-calls at once!" (openclaw#37048). NVIDIA's own function-calling docs default the
+  //   Boolean to false, so provider-wide `false` is the documented-safe wire value.
+  // - `reasoning_effort` is not portable on NIM (models use chat_template_kwargs); the kimi
+  //   family is live-discovered with no capability metadata, so Codex would otherwise send
+  //   reasoning_effort=medium. Exact-id lists per modelInList semantics; gpt-oss on NIM keeps
+  //   its working reasoning_effort. Future kimi ids must be appended individually.
+  {
+    id: "nvidia", label: "NVIDIA NIM", baseUrl: "https://integrate.api.nvidia.com/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://build.nvidia.com",
+    parallelToolCalls: false,
+    noReasoningModels: NVIDIA_NIM_KIMI_MODELS,
+    modelReasoningEfforts: Object.fromEntries(NVIDIA_NIM_KIMI_MODELS.map(id => [id, []])),
+    preserveReasoningContentModels: NVIDIA_NIM_KIMI_THINKING_MODELS,
+  },
   { id: "venice", label: "Venice", baseUrl: "https://api.venice.ai/api/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://venice.ai/settings/api" },
   // 260710 GLM-5.2 context and path-specific ids: Tier-2 evidence in
   // devlog/_plan/260710_provider_hardening/002_research_cn.md.

package/src/server/claude-messages.ts

@@ -7,6 +7,8 @@
  * unchanged. The Responses output (SSE or JSON) is converted back to Anthropic shape.
  */
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
+import { enforceAnthropicImageLimits } from "../adapters/anthropic-image-guard";
+import { normalizeAnthropicImages } from "../adapters/anthropic-image-normalize";
 import { AnthropicRequestError, anthropicToResponsesTranslation, extractOcxRouteDirective, resolveInboundModel, type ClaudeCacheKeySource } from "../claude/inbound";
 import { stripOneMillionMarker } from "../claude/context-windows";
 import { captureClaudeInbound } from "../claude/inbound-debug";
@@ -187,6 +189,15 @@ async function anthropicNativePassthrough(
 
   const base = (config.claudeCode?.anthropicBaseUrl ?? "https://api.anthropic.com").replace(/\/$/, "");
   const search = new URL(req.url).search;
+  // Native passthrough bypasses the anthropic adapter, so the generous image pipeline
+  // (devlog/260714_image_normalization_pipeline/040) must run here: tier-normalize then
+  // guard the already-Anthropic-wire messages before serialization. Applies to
+  // count_tokens too — counts must match what the real send will contain, and the 32MB
+  // body cap applies to it equally. Non-message bodies pass through untouched.
+  if (Array.isArray(body.messages)) {
+    await normalizeAnthropicImages(body.messages);
+    enforceAnthropicImageLimits(body.messages);
+  }
   const headers = new Headers();
   req.headers.forEach((value, name) => {
     if (!PASSTHROUGH_STRIP_HEADERS.has(name.toLowerCase())) headers.set(name, value);

package/src/server/image-retry.ts

@@ -0,0 +1,42 @@
+/**
+ * Upstream-413 tightened-retry gate (devlog/260714_image_normalization_pipeline/030).
+ *
+ * When Anthropic still rejects a normalized request with 413 request_too_large (budget
+ * estimate missed: giant text share, tool schemas, ...), the proxy rebuilds the SAME
+ * request with `imageTierBias: 1` — every image one ladder position lower — and retries
+ * exactly once. The decision logic lives here so it is unit-testable; the fetch loop in
+ * responses.ts consumes it.
+ */
+
+import type { OcxParsedRequest } from "../types";
+
+/** True when the parsed request carries at least one inline (data-URL) image. */
+export function parsedHasInlineImage(parsed: OcxParsedRequest): boolean {
+  const messages = (parsed as { context?: { messages?: unknown[] } }).context?.messages ?? [];
+  for (const message of messages) {
+    const content = (message as { content?: unknown }).content;
+    if (!Array.isArray(content)) continue;
+    for (const part of content) {
+      const imageUrl = (part as { imageUrl?: unknown })?.imageUrl;
+      if (typeof imageUrl === "string" && imageUrl.startsWith("data:")) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * One tier-biased rebuild per request (spiral guard), only for the anthropic adapter
+ * (others ignore imageTierBias — an identical retry would just duplicate cost), and only
+ * when the request actually carries inline images the bias can shrink.
+ */
+export function shouldAttemptImageTierRetry(args: {
+  status: number;
+  adapterName: string;
+  parsed: OcxParsedRequest;
+  alreadyAttempted: boolean;
+}): boolean {
+  return args.status === 413
+    && !args.alreadyAttempted
+    && args.adapterName === "anthropic"
+    && parsedHasInlineImage(args.parsed);
+}

package/src/server/management-api.ts

@@ -273,6 +273,33 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     });
   }
 
+  if (url.pathname === "/api/shadow-call-settings" && req.method === "GET") {
+    const sci = config.shadowCallIntercept ?? {};
+    return jsonResponse({ enabled: sci.enabled === true, model: sci.model ?? "" });
+  }
+
+  if (url.pathname === "/api/shadow-call-settings" && req.method === "PUT") {
+    let raw: unknown;
+    try { raw = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
+    if (!isPlainRecord(raw)) return jsonResponse({ error: "body must be a JSON object" }, 400);
+    const body = raw as { enabled?: unknown; model?: unknown };
+    if (body.enabled !== undefined && typeof body.enabled !== "boolean") {
+      return jsonResponse({ error: "enabled must be a boolean" }, 400);
+    }
+    if (body.model !== undefined && typeof body.model !== "string") {
+      return jsonResponse({ error: "model must be a string" }, 400);
+    }
+    config.shadowCallIntercept = { ...config.shadowCallIntercept };
+    if (typeof body.enabled === "boolean") config.shadowCallIntercept.enabled = body.enabled;
+    if (typeof body.model === "string") {
+      if (body.model === "") delete config.shadowCallIntercept.model;
+      else config.shadowCallIntercept.model = body.model;
+    }
+    saveConfig(config);
+    const sci = config.shadowCallIntercept;
+    return jsonResponse({ ok: true, enabled: sci.enabled === true, model: sci.model ?? "" });
+  }
+
   if (url.pathname === "/api/logs" && req.method === "GET") {
     return jsonResponse(filterRequestLogs(getRequestLogEntries(), url.searchParams));
   }

package/src/server/responses.ts

@@ -41,6 +41,7 @@ import { isUsageDebugEnabled } from "../usage/debug";
 import { readJsonRequestBody, DecompressedBodyTooLargeError, UnsupportedContentEncodingError } from "./request-decompress";
 import { resolveAdapter, resolveWireProtocolOverride } from "./adapter-resolve";
 import { hasKeyPoolFailover, rotateProviderTransportOn429 } from "../providers/key-failover";
+import { shouldAttemptImageTierRetry } from "./image-retry";
 import { resolveProviderTransport } from "../providers/xai-transport";
 import type { WsData } from "./ws-bridge";
 import { registerTurn, trackStreamLifetime, unregisterTurn } from "./lifecycle";
@@ -346,9 +347,10 @@ export function sanitizeEncryptedContentInPlace(input: unknown): number {
           && (child as { type?: unknown }).type === "agent_message"
           && !hasEncryptedContentPart((child as { content?: unknown }).content)
         ) {
-          const message = child as { type: string; role?: string; author?: unknown; recipient?: unknown };
+          const message = child as { type: string; role?: string; id?: unknown; author?: unknown; recipient?: unknown };
           message.type = "message";
           message.role = "user";
+          delete message.id;
           delete message.author;
           delete message.recipient;
         }
@@ -465,6 +467,22 @@ export async function handleResponses(
   logCtx.configuredServiceTier = readConfiguredCodexServiceTier();
   logCtx.configuredSpeedLabel = requestLogSpeedLabel(logCtx.configuredServiceTier);
 
+  // Shadow call intercept: rewrite Codex Desktop's hard-coded gpt-5.4-mini helper calls
+  const _sci = config.shadowCallIntercept;
+  if (_sci?.enabled && _sci.model && parsed.modelId.startsWith("gpt-5.4-mini")) {
+    const _sciOriginal = parsed.modelId;
+    parsed.modelId = _sci.model;
+    if (parsed._rawBody && typeof parsed._rawBody === "object") {
+      (parsed._rawBody as { model?: string }).model = _sci.model;
+    }
+    // Force effort to low for shadow/helper calls (matching upstream behavior)
+    parsed.options.reasoning = "low";
+    if (parsed._rawBody && typeof parsed._rawBody === "object") {
+      (parsed._rawBody as Record<string, unknown>).reasoning = { effort: "low" };
+    }
+    (logCtx as unknown as Record<string, unknown>).shadowCallRewrittenFrom = _sciOriginal;
+  }
+
   let route;
   try {
     route = routeModel(config, parsed.modelId);
@@ -923,7 +941,7 @@ export async function handleResponses(
   let upstreamResponse: Response;
   try {
     upstreamResponse = adapter.fetchResponse
-      ? await adapter.fetchResponse(request, { abortSignal: upstream.signal, timeoutMs: connectMs })
+      ? await adapter.fetchResponse(request, { abortSignal: upstream.signal, timeoutMs: connectMs, stream: parsed.stream })
       : await fetchWithResetRetry(
           () => fetchWithHeaderTimeout(request.url, {
             method: request.method, headers: request.headers, body: request.body,
@@ -940,29 +958,22 @@ export async function handleResponses(
   }
 
   if (!upstreamResponse.ok) {
-    // Multi-key 429 failover: rotate to the next pool key (cooldown-aware) and retry the SAME
-    // request once per remaining key. OAuth/forward providers and single-key pools return null
-    // immediately, so this stays a no-op for them (src/providers/key-failover.ts).
-    while (upstreamResponse.status === 429 && hasKeyPoolFailover(route.provider)) {
-      const rotated = rotateProviderTransportOn429(config, route.providerName, {
-        retryAfter: upstreamResponse.headers.get("retry-after"),
-        now: Date.now(),
-        attemptedKey: route.provider.apiKey,
-        promptCacheKey: parsed.options.promptCacheKey,
+    // Recovery loop: multi-key 429 failover + at most ONE anthropic 413 tightened retry
+    // (devlog/260714_image_normalization_pipeline/030). One mutable activeAdapter serves
+    // both paths so a 429→413 sequence never rebuilds against a stale pre-rotation
+    // adapter, and imageTierBias — once armed — rides EVERY subsequent rebuild so a
+    // 413→429 rotation cannot silently undo the tightening.
+    let activeAdapter = adapter;
+    let imageTierBias = 0;
+    let imageRetryAttempted = false;
+    const rebuildAndRefetch = async (): Promise<Response | { failed: Response }> => {
+      const retryRequest = await activeAdapter.buildRequest(parsed, {
+        headers: selectedForwardHeaders,
+        ...(imageTierBias > 0 ? { imageTierBias } : {}),
       });
-      if (!rotated) break;
-      // Release the failed response's socket before retrying; unread bodies otherwise linger
-      // until runtime cleanup (one per rotated key under a rate-limit storm).
-      try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
-      route.provider = rotated;
-      const retryAdapter = resolveAdapter(
-        resolveWireProtocolOverride(route.providerName, route.modelId, route.provider),
-        config.cacheRetention,
-      );
-      const retryRequest = await retryAdapter.buildRequest(parsed, { headers: selectedForwardHeaders });
       try {
-        upstreamResponse = retryAdapter.fetchResponse
-          ? await retryAdapter.fetchResponse(retryRequest, { abortSignal: upstream.signal, timeoutMs: connectMs })
+        return activeAdapter.fetchResponse
+          ? await activeAdapter.fetchResponse(retryRequest, { abortSignal: upstream.signal, timeoutMs: connectMs, stream: parsed.stream })
           : await fetchWithHeaderTimeout(retryRequest.url, {
               method: retryRequest.method, headers: retryRequest.headers, body: retryRequest.body,
             }, upstream.signal, connectMs, parsed.stream);
@@ -972,8 +983,50 @@ export async function handleResponses(
         const msg = err instanceof Error && err.name === "TimeoutError"
           ? `Provider connect timeout after ${connectMs}ms`
           : `Provider unreachable: ${err instanceof Error ? err.message : String(err)}`;
-        return formatErrorResponse(502, "upstream_error", msg);
+        return { failed: formatErrorResponse(502, "upstream_error", msg) };
+      }
+    };
+    recovery: for (;;) {
+      // Multi-key 429 failover: rotate to the next pool key (cooldown-aware) and retry the
+      // SAME request once per remaining key. OAuth/forward providers and single-key pools
+      // return null immediately, so this stays a no-op for them (src/providers/key-failover.ts).
+      while (upstreamResponse.status === 429 && hasKeyPoolFailover(route.provider)) {
+        const rotated = rotateProviderTransportOn429(config, route.providerName, {
+          retryAfter: upstreamResponse.headers.get("retry-after"),
+          now: Date.now(),
+          attemptedKey: route.provider.apiKey,
+          promptCacheKey: parsed.options.promptCacheKey,
+        });
+        if (!rotated) break;
+        // Release the failed response's socket before retrying; unread bodies otherwise linger
+        // until runtime cleanup (one per rotated key under a rate-limit storm).
+        try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
+        route.provider = rotated;
+        activeAdapter = resolveAdapter(
+          resolveWireProtocolOverride(route.providerName, route.modelId, route.provider),
+          config.cacheRetention,
+        );
+        const result = await rebuildAndRefetch();
+        if ("failed" in result) return result.failed;
+        upstreamResponse = result;
+      }
+      // Anthropic 413 request_too_large: rebuild once with every image one tier lower
+      // (spiral guard: single attempt). The biased response re-enters the 429 check above.
+      if (shouldAttemptImageTierRetry({
+        status: upstreamResponse.status,
+        adapterName: activeAdapter.name,
+        parsed,
+        alreadyAttempted: imageRetryAttempted,
+      })) {
+        imageRetryAttempted = true;
+        imageTierBias = 1;
+        try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
+        const result = await rebuildAndRefetch();
+        if ("failed" in result) return result.failed;
+        upstreamResponse = result;
+        continue recovery;
       }
+      break;
     }
     if (!upstreamResponse.ok) {
       const errorText = await upstreamResponse.text().catch(() => "unknown error");

package/src/server/system-env.ts

@@ -25,13 +25,15 @@ function writeShellEnvFile(port: number, config: OcxConfig, modelEnv: Record<str
     `export ANTHROPIC_BASE_URL=${shellValue(`http://127.0.0.1:${port}`)}`,
     `export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=${shellValue("1")}`,
   ];
-  if (config.apiKeys?.length) {
-    lines.push(`export ANTHROPIC_AUTH_TOKEN=${shellValue(config.apiKeys[0].key)}`);
-  }
   // New lever keys are CONDITIONAL exports (audit 139 R2#1): a value the user already
   // exported in their shell wins even though launchctl knows nothing about it.
   const conditional = (name: string, value: string) =>
     `[ -z "\${${name}+x}" ] && export ${name}=${shellValue(value)}`;
+  if (config.apiKeys?.length) {
+    lines.push(`export ANTHROPIC_AUTH_TOKEN=${shellValue(config.apiKeys[0].key)}`);
+  } else if (config.claudeCode?.authMode === "proxy") {
+    lines.push(conditional("ANTHROPIC_AUTH_TOKEN", "opencodex-proxy"));
+  }
   // Model slots (default + tiers + legacy small-fast) with [1m] applied (devlog 260712 B2).
   if (modelEnv.ANTHROPIC_MODEL) {
     lines.push(`export ANTHROPIC_MODEL=${shellValue(modelEnv.ANTHROPIC_MODEL)}`);
@@ -238,6 +240,8 @@ export async function injectSystemEnv(port: number, config: OcxConfig): Promise<
     inject("CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY", "1");
     if (config.apiKeys?.length) {
       inject("ANTHROPIC_AUTH_TOKEN", config.apiKeys[0].key);
+    } else if (config.claudeCode?.authMode === "proxy" && launchctlGetenv("ANTHROPIC_AUTH_TOKEN") === undefined) {
+      inject("ANTHROPIC_AUTH_TOKEN", "opencodex-proxy");
     }
     // Lever keys (devlog 136 B6): user-wins — skip any key the user already set in the
     // launchd domain, and track ONLY the keys we actually injected so revert cannot

package/src/types.ts

@@ -270,6 +270,12 @@ export interface OcxClaudeCodeConfig {
    * on stop/shutdown. Default: false (opt-in). macOS only.
    */
   systemEnv?: boolean;
+  /**
+   * Auth mode for Claude Code inbound requests. "proxy" injects a dummy
+   * ANTHROPIC_AUTH_TOKEN so Claude Code routes through the proxy without a
+   * real Anthropic key. Default: undefined (no token injection).
+   */
+  authMode?: "proxy";
   /**
    * Context-window override for Claude Code/Desktop clients (devlog 136 B6):
    * injected as CLAUDE_CODE_MAX_CONTEXT_TOKENS + DISABLE_COMPACT=1 (the official
@@ -379,6 +385,17 @@ export interface OcxConfig {
    * are omitted from the bare /v1/models list.
    */
   disabledModels?: string[];
+  /**
+   * Shadow call intercept: redirect Codex Desktop's hard-coded gpt-5.4-mini helper calls
+   * (title generation, commit messages, skill orchestration) to a user-chosen model.
+   * Opt-in; disabled by default. When enabled, effort is forced to low.
+   */
+  shadowCallIntercept?: {
+    /** When true, all gpt-5.4-mini* requests are rewritten to the configured model. */
+    enabled?: boolean;
+    /** Replacement model id (e.g. "gpt-5.5"). */
+    model?: string;
+  };
   /**
    * 3-state multi-agent surface override:
    * - "v1": force ALL models to v1 surface (override upstream pins)
@@ -668,10 +685,11 @@ export interface OcxProviderConfig {
   unsafeAllowNativeLocalExec?: boolean;
   /**
    * Cursor adapter only: native local exec policy mode (exec-policy.ts).
-   * "off" (default) rejects all server-driven local exec; "on" always allows
-   * (same as legacy unsafeAllowNativeLocalExec:true); "codex-sandbox" allows only
-   * when the request's instructions/developer text declares the Codex
-   * danger-full-access sandbox. NOTE: the declaration is CALLER-CONTROLLED prose —
+   * "codex-sandbox" (default) allows server-driven local exec only when the
+   * request's instructions/developer text declares the Codex danger-full-access
+   * sandbox (approves the normal full-access flow, denies undeclared requests);
+   * "off" rejects all server-driven local exec; "on" always allows (same as legacy
+   * unsafeAllowNativeLocalExec:true). NOTE: the declaration is CALLER-CONTROLLED prose —
    * the proxy cannot verify it. Enable "codex-sandbox" only where every client
    * that can reach the data plane is trusted: the default loopback bind admits
    * ANY process on this host without auth (including other local users on

package/src/web-search/index.ts

@@ -97,13 +97,16 @@ export function findAnthropicSidecarProvider(config: OcxConfig): AnthropicSideca
   return undefined;
 }
 
-/** Precedence (audit F4/F7): explicit config wins; unset resolves to anthropic when a usable credential exists, else openai. */
+/**
+ * Precedence: explicit config wins; unset defaults to "openai" (ChatGPT forward path). The
+ * anthropic backend (web_search_20250305) is only used when explicitly configured — auto-selecting
+ * it from credential availability caused the sidecar to send incompatible models (e.g. gpt-5.6-luna)
+ * to the Anthropic API.
+ */
 export function resolveSidecarBackend(
   explicit: "openai" | "anthropic" | undefined,
-  anthropicSidecar: AnthropicSidecarProvider | undefined,
 ): "openai" | "anthropic" {
-  if (explicit === "anthropic" || explicit === "openai") return explicit;
-  return anthropicSidecar ? "anthropic" : "openai";
+  return explicit === "anthropic" ? "anthropic" : "openai";
 }
 
 export interface SidecarPlan {
@@ -145,7 +148,7 @@ export function planWebSearch(
   // Same `?? 200_000` default the server applies when threading connectTimeoutMs into the loop.
   const connectTimeoutMs = config.connectTimeoutMs ?? 200_000;
   const anthropicSidecar = findAnthropicSidecarProvider(config);
-  const backend = resolveSidecarBackend(cfg.backend, anthropicSidecar);
+  const backend = resolveSidecarBackend(cfg.backend);
   const maxSearches = cfg.maxSearchesPerTurn ?? DEFAULT_MAX_SEARCHES;
   const stallTimeoutSec = webSearchStallTimeoutSec(
     config.stallTimeoutSec,

package/src/web-search/loop.ts

@@ -271,14 +271,19 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
               abortSignal: headerDeadline.signal,
               timeoutMs: connectTimeoutMs,
               returnRawErrors: true,
+              stream: true,
             })
           : await fetchWithResetRetry(
-              () => fetch(request.url, {
-                method: request.method,
-                headers: request.headers,
-                body: request.body,
-                signal: headerDeadline.signal,
-              }),
+              () => {
+                const h = new Headers(request.headers);
+                if (!h.has("accept-encoding")) h.set("accept-encoding", "identity");
+                return fetch(request.url, {
+                  method: request.method,
+                  headers: h,
+                  body: request.body,
+                  signal: headerDeadline.signal,
+                });
+              },
               { abortSignal: headerDeadline.signal, label: "web-search-loop" },
             );
         return { response, responseAdapter: requestAdapter };