@bitkyc08/opencodex 2.7.9-preview.20260712.1 → 2.7.9

package/src/server/management-api.ts

@@ -19,6 +19,7 @@ import {
   upsertOAuthProvider,
 } from "../oauth";
 import { removeCredential } from "../oauth/store";
+import { providerDestinationResolvedError } from "../lib/destination-policy";
 import { enrichProviderFromCatalog, listKeyLoginProviders } from "../oauth/key-providers";
 import { deriveProviderPresets } from "../providers/derive";
 import { fetchProviderQuotaReports } from "../providers/quota";
@@ -28,6 +29,7 @@ import { getUsageDebugLogEntries } from "../usage/debug";
 import { parseRange, summarizeUsage } from "../usage/summary";
 import { stripCodexRuntimeProviderFields } from "../codex/auth-context";
 import { getDebugLogEntries } from "../lib/debug-log-buffer";
+import { getInjectionDebugLogEntries } from "../lib/injection-debug-log";
 import {
   clearDebugSettings,
   clearDebugSetting,
@@ -35,10 +37,11 @@ import {
   setDebugSettings,
   type DebugFlag,
 } from "../lib/debug-settings";
-import type { OcxConfig, OcxProviderConfig } from "../types";
+import type { OcxClaudeCodeConfig, OcxConfig, OcxProviderConfig } from "../types";
 import { drainAndShutdown } from "./lifecycle";
 import { filterRequestLogs, getRequestLogEntries } from "./request-log";
 import { isAllowedRequestOrigin, jsonResponse, providerManagementConfigError, publicProviderBaseUrl, safeConfigDTO } from "./auth-cors";
+import { applySystemEnvToggle } from "./system-env";
 
 // Single source of truth = package.json (../ from src/), so /healthz + the GUI badge match the
 // installed npm version instead of a stale hardcode.
@@ -55,6 +58,11 @@ export interface ManagementApiDeps {
   refreshCodexCatalog?: () => Promise<void>;
 }
 
+/** Narrow an unknown JSON value to a plain (non-array) object for strict request-body validation. */
+function isPlainRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
 function parseDebugLogQuery(url: URL): { after: number; limit: number } {
   const after = Number(url.searchParams.get("after") ?? url.searchParams.get("since") ?? "0");
   const limit = Number(url.searchParams.get("limit") ?? "500");
@@ -190,30 +198,78 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     const ws = config.webSearchSidecar ?? {};
     const vs = config.visionSidecar ?? {};
     return jsonResponse({
-      webSearch: { model: ws.model ?? "gpt-5.6-luna", reasoning: ws.reasoning ?? "low" },
-      vision: { model: vs.model ?? "gpt-5.6-luna" },
+      webSearch: { model: ws.model ?? "gpt-5.6-luna", backend: ws.backend },
+      vision: {
+        model: vs.model ?? "gpt-5.6-luna",
+        backend: vs.backend,
+        maxDescriptionsPerTurn: vs.maxDescriptionsPerTurn,
+      },
     });
   }
 
   if (url.pathname === "/api/sidecar-settings" && req.method === "PUT") {
-    let body: { webSearch?: { model?: string; reasoning?: string }; vision?: { model?: string } };
-    try { body = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
+    let raw: unknown;
+    try { raw = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
+    // Strict shape (review F2): reject non-object bodies and non-object sections instead of throwing
+    // on `null` or silently accepting arrays/strings as no-op updates.
+    if (!isPlainRecord(raw)) return jsonResponse({ error: "body must be a JSON object" }, 400);
+    if (raw.webSearch !== undefined && !isPlainRecord(raw.webSearch)) return jsonResponse({ error: "webSearch must be an object" }, 400);
+    if (raw.vision !== undefined && !isPlainRecord(raw.vision)) return jsonResponse({ error: "vision must be an object" }, 400);
+    const body = raw as {
+      webSearch?: { model?: unknown; backend?: unknown; reasoning?: unknown };
+      vision?: { model?: unknown; backend?: unknown; maxDescriptionsPerTurn?: unknown };
+    };
+    if (body.webSearch && body.webSearch.backend !== undefined && body.webSearch.backend !== null
+      && body.webSearch.backend !== "openai" && body.webSearch.backend !== "anthropic") {
+      return jsonResponse({ error: "webSearch.backend must be openai, anthropic, or null" }, 400);
+    }
+    if (body.vision && body.vision.backend !== undefined
+      && body.vision.backend !== null && body.vision.backend !== "openai" && body.vision.backend !== "anthropic") {
+      return jsonResponse({ error: "vision.backend must be openai, anthropic, or null" }, 400);
+    }
+    if (body.vision && body.vision.maxDescriptionsPerTurn !== undefined
+      && (typeof body.vision.maxDescriptionsPerTurn !== "number"
+        || !Number.isInteger(body.vision.maxDescriptionsPerTurn)
+        || body.vision.maxDescriptionsPerTurn <= 0)) {
+      return jsonResponse({ error: "vision.maxDescriptionsPerTurn must be a positive integer" }, 400);
+    }
     if (body.webSearch) {
       config.webSearchSidecar = { ...config.webSearchSidecar };
-      if (typeof body.webSearch.model === "string") config.webSearchSidecar.model = body.webSearch.model;
+      if (typeof body.webSearch.model === "string") {
+        if (body.webSearch.model === "") delete config.webSearchSidecar.model;
+        else config.webSearchSidecar.model = body.webSearch.model;
+      }
+      if (body.webSearch.backend === null) delete config.webSearchSidecar.backend;
+      else if (body.webSearch.backend === "openai" || body.webSearch.backend === "anthropic") {
+        config.webSearchSidecar.backend = body.webSearch.backend;
+      }
       if (typeof body.webSearch.reasoning === "string") config.webSearchSidecar.reasoning = body.webSearch.reasoning;
     }
     if (body.vision) {
       config.visionSidecar = { ...config.visionSidecar };
-      if (typeof body.vision.model === "string") config.visionSidecar.model = body.vision.model;
+      if (typeof body.vision.model === "string") {
+        if (body.vision.model === "") delete config.visionSidecar.model;
+        else config.visionSidecar.model = body.vision.model;
+      }
+      if (body.vision.backend === null) delete config.visionSidecar.backend;
+      else if (body.vision.backend === "openai" || body.vision.backend === "anthropic") {
+        config.visionSidecar.backend = body.vision.backend;
+      }
+      if (typeof body.vision.maxDescriptionsPerTurn === "number") {
+        config.visionSidecar.maxDescriptionsPerTurn = body.vision.maxDescriptionsPerTurn;
+      }
     }
     saveConfig(config);
     const ws = config.webSearchSidecar ?? {};
     const vs = config.visionSidecar ?? {};
     return jsonResponse({
       ok: true,
-      webSearch: { model: ws.model ?? "gpt-5.6-luna", reasoning: ws.reasoning ?? "low" },
-      vision: { model: vs.model ?? "gpt-5.6-luna" },
+      webSearch: { model: ws.model ?? "gpt-5.6-luna", backend: ws.backend },
+      vision: {
+        model: vs.model ?? "gpt-5.6-luna",
+        backend: vs.backend,
+        maxDescriptionsPerTurn: vs.maxDescriptionsPerTurn,
+      },
     });
   }
 
@@ -241,6 +297,11 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     return jsonResponse({ enabled: isClaudeDebugEnabled(), entries: getClaudeInboundDebugEntries() });
   }
 
+  if (url.pathname === "/api/debug/injection-logs" && req.method === "GET") {
+    const { after, limit } = parseDebugLogQuery(url);
+    return jsonResponse(getInjectionDebugLogEntries({ after, limit }));
+  }
+
   if (url.pathname === "/api/debug" && req.method === "PUT") {
     let body: { debug?: unknown; usage?: unknown; injection?: unknown; claude?: unknown; reset?: unknown };
     try { body = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
@@ -309,6 +370,7 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     return jsonResponse(Object.entries(config.providers).map(([name, p]) => ({
       name, adapter: p.adapter, baseUrl: publicProviderBaseUrl(p.baseUrl), defaultModel: p.defaultModel,
       hasApiKey: !!p.apiKey,
+      allowPrivateNetwork: p.allowPrivateNetwork === true,
       disabled: p.disabled === true,
     })));
   }
@@ -329,6 +391,10 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     }
     const providerError = providerManagementConfigError(name, prov);
     if (providerError) return jsonResponse({ error: providerError }, 400);
+    // Hostname destinations additionally get a DNS-resolved SSRF check at write time —
+    // the sync check above only classifies literal IPs (review finding, PR #96).
+    const resolvedError = await providerDestinationResolvedError(name, prov);
+    if (resolvedError) return jsonResponse({ error: resolvedError }, 400);
     // Catalog providers (e.g. ollama-cloud) carry a models + vision/reasoning classification the GUI
     // doesn't send — merge it in so the sidecars are gated correctly.
     enrichProviderFromCatalog(name, prov);
@@ -694,6 +760,8 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
       aliases.push({ id: claudeCodeAlias(m.provider, m.id), display_name: `${m.id} (${m.provider})` });
     }
     const contextWindows = buildClaudeContextWindows([...visibleNativeSlugs(config)], models);
+    const webSearchOverride = config.claudeCode?.webSearchSidecar;
+    const visionOverride = config.claudeCode?.visionSidecar;
     return jsonResponse({
       enabled: config.claudeCode?.enabled !== false,
       model: config.claudeCode?.model ?? "",
@@ -707,6 +775,12 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
       autoCompactWindow: config.claudeCode?.autoCompactWindow ?? null,
       blockedSkills: config.claudeCode?.blockedSkills ?? null,
       injectAgents: config.claudeCode?.injectAgents !== false,
+      ...(webSearchOverride && Object.keys(webSearchOverride).length > 0
+        ? { webSearchSidecar: { backend: webSearchOverride.backend, model: webSearchOverride.model } }
+        : {}),
+      ...(visionOverride && Object.keys(visionOverride).length > 0
+        ? { visionSidecar: { backend: visionOverride.backend, model: visionOverride.model } }
+        : {}),
       fastMode: config.fastMode,
       contextWindows,
       effectiveModelEnv: effectiveModelEnv(config.claudeCode, contextWindows),
@@ -722,9 +796,44 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     // supersede tiers; auto-context supersedes the max-context pair; effort rides
     // regardless on 2.1.207). PUT keeps validating them so hand-written configs
     // and older GUIs stay safe; GUI saves omit them and the spread preserves them.
-    let body: { enabled?: unknown; model?: unknown; smallFastModel?: unknown; modelMap?: unknown; systemEnv?: unknown; fastMode?: unknown; maxContextTokens?: unknown; alwaysEnableEffort?: unknown; tierModels?: unknown; autoContext?: unknown; autoCompactWindow?: unknown; blockedSkills?: unknown; injectAgents?: unknown };
-    try { body = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
+    let parsedBody: unknown;
+    try { parsedBody = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
+    const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+      if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+      const prototype = Object.getPrototypeOf(value);
+      return prototype === Object.prototype || prototype === null;
+    };
+    if (!isPlainObject(parsedBody)) return jsonResponse({ error: "body must be an object" }, 400);
+    const body = parsedBody as { enabled?: unknown; model?: unknown; smallFastModel?: unknown; modelMap?: unknown; systemEnv?: unknown; fastMode?: unknown; maxContextTokens?: unknown; alwaysEnableEffort?: unknown; tierModels?: unknown; autoContext?: unknown; autoCompactWindow?: unknown; blockedSkills?: unknown; injectAgents?: unknown; webSearchSidecar?: unknown; visionSidecar?: unknown };
+    for (const field of ["webSearchSidecar", "visionSidecar"] as const) {
+      const section = body[field];
+      if (section === undefined || section === null) continue;
+      if (!isPlainObject(section)) return jsonResponse({ error: `${field} must be an object or null` }, 400);
+      if (section.backend !== undefined && section.backend !== null
+        && section.backend !== "openai" && section.backend !== "anthropic") {
+        return jsonResponse({ error: `${field}.backend must be openai, anthropic, or null` }, 400);
+      }
+      if (section.model !== undefined && typeof section.model !== "string") {
+        return jsonResponse({ error: `${field}.model must be a string` }, 400);
+      }
+    }
     const next = { ...(config.claudeCode ?? {}) };
+    for (const field of ["webSearchSidecar", "visionSidecar"] as const) {
+      const section = body[field];
+      if (section === undefined) continue;
+      if (section === null || Object.keys(section as Record<string, unknown>).length === 0) {
+        delete next[field];
+        continue;
+      }
+      const requested = section as { backend?: "openai" | "anthropic" | null; model?: string };
+      const override: NonNullable<OcxClaudeCodeConfig[typeof field]> = { ...next[field] };
+      if (requested.backend === null) delete override.backend;
+      else if (requested.backend !== undefined) override.backend = requested.backend;
+      if (requested.model === "") delete override.model;
+      else if (requested.model !== undefined) override.model = requested.model;
+      if (Object.keys(override).length > 0) next[field] = override;
+      else delete next[field];
+    }
     if (body.enabled !== undefined) {
       if (typeof body.enabled !== "boolean") return jsonResponse({ error: "enabled must be a boolean" }, 400);
       next.enabled = body.enabled;
@@ -785,18 +894,23 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     }
     if (body.tierModels !== undefined) {
       // CONFIG-ONLY back-compat (GUI pickers removed — roster agents supersede tiers).
-      if (!body.tierModels || typeof body.tierModels !== "object" || Array.isArray(body.tierModels)) {
-        return jsonResponse({ error: "tierModels must be an object" }, 400);
-      }
-      const tiers: Record<string, string> = {};
-      for (const tier of ["opus", "sonnet", "haiku", "fable"] as const) {
-        const value = (body.tierModels as Record<string, unknown>)[tier];
-        if (value === undefined || value === null) continue;
-        if (typeof value !== "string") return jsonResponse({ error: `tierModels.${tier} must be a string` }, 400);
-        if (value.trim() !== "") tiers[tier] = value.trim();
+      if (body.tierModels === null) {
+        delete next.tierModels;
+      } else if (!isPlainObject(body.tierModels)) {
+        return jsonResponse({ error: "tierModels must be an object with string values, or null" }, 400);
+      } else {
+        for (const [tier, value] of Object.entries(body.tierModels)) {
+          if (typeof value !== "string") return jsonResponse({ error: `tierModels.${tier} must be a string` }, 400);
+        }
+        const tierModels = body.tierModels as Record<string, string>;
+        const tiers: Record<string, string> = {};
+        for (const tier of ["opus", "sonnet", "haiku", "fable"] as const) {
+          const value = tierModels[tier];
+          if (value !== undefined && value.trim() !== "") tiers[tier] = value.trim();
+        }
+        if (Object.keys(tiers).length > 0) next.tierModels = tiers;
+        else delete next.tierModels;
       }
-      if (Object.keys(tiers).length > 0) next.tierModels = tiers;
-      else delete next.tierModels;
     }
     if (body.fastMode !== undefined) {
       if (body.fastMode !== true && body.fastMode !== false && body.fastMode !== null) {
@@ -812,26 +926,38 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
       else next[field] = value.trim();
     }
     if (body.modelMap !== undefined) {
-      if (!body.modelMap || typeof body.modelMap !== "object" || Array.isArray(body.modelMap)) {
-        return jsonResponse({ error: "modelMap must be an object of string->string" }, 400);
-      }
-      const map: Record<string, string> = {};
-      for (const [k, v] of Object.entries(body.modelMap as Record<string, unknown>)) {
-        if (typeof v !== "string" || k.trim() === "" || v.trim() === "") {
-          return jsonResponse({ error: "modelMap entries must be non-empty strings" }, 400);
+      if (body.modelMap === null) {
+        delete next.modelMap;
+      } else {
+        if (!isPlainObject(body.modelMap)) {
+          return jsonResponse({ error: "modelMap must be an object of string->string, or null" }, 400);
         }
-        map[k.trim()] = v.trim();
+        const map: Record<string, string> = {};
+        for (const [k, v] of Object.entries(body.modelMap)) {
+          if (typeof v !== "string" || k.trim() === "" || v.trim() === "") {
+            return jsonResponse({ error: "modelMap entries must be non-empty strings" }, 400);
+          }
+          map[k.trim()] = v.trim();
+        }
+        if (Object.keys(map).length > 0) next.modelMap = map;
+        else delete next.modelMap;
       }
-      if (Object.keys(map).length > 0) next.modelMap = map;
-      else delete next.modelMap;
     }
     config.claudeCode = next;
     const { saveConfig: save } = await import("../config");
     save(config);
+    const warnings: string[] = [];
+    if (body.systemEnv !== undefined) {
+      try {
+        await applySystemEnvToggle(config, config.port);
+      } catch (err) {
+        warnings.push(`Failed to apply system environment setting: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
     // Keep the file-backed live registry symmetric: OFF prunes immediately, while
     // ON and config changes restore definitions without requiring a restart.
     await syncClaudeAgentDefsBestEffort();
-    return jsonResponse({ ok: true, enabled: next.enabled !== false });
+    return jsonResponse({ ok: true, enabled: next.enabled !== false, warnings });
   }
 
   // Per-provider catalog allowlist (issue #52): when a provider has a non-empty selectedModels list,

package/src/server/request-decompress.ts

@@ -1,3 +1,5 @@
+import { gunzipSync, inflateRawSync, inflateSync, zstdDecompressSync } from "node:zlib";
+
 /**
  * Request-body decompression for the /v1/responses data plane.
  *
@@ -25,28 +27,59 @@ export class UnsupportedContentEncodingError extends Error {
 }
 
 export class DecompressedBodyTooLargeError extends Error {
-  constructor(readonly bytes: number) {
-    super(`Decompressed request body exceeds ${MAX_DECOMPRESSED_BODY_BYTES} bytes`);
+  constructor(readonly bytes: number, limit: number = MAX_DECOMPRESSED_BODY_BYTES) {
+    super(`Decompressed request body exceeds ${limit} bytes`);
   }
 }
 
-export function decodeRequestBody(raw: Uint8Array<ArrayBuffer>, contentEncoding: string | null): Uint8Array {
+function assertBodySizeWithinLimit(body: Uint8Array, maxBytes: number): Uint8Array {
+  if (body.byteLength > maxBytes) throw new DecompressedBodyTooLargeError(body.byteLength, maxBytes);
+  return body;
+}
+
+function inflateDeflateBody(compressed: Uint8Array<ArrayBuffer>, opts: { maxOutputLength: number }): Uint8Array {
+  // HTTP "deflate" appears both zlib-wrapped and raw in the wild (Bun.deflateSync emits raw,
+  // which the previous Bun.inflateSync accepted). Try zlib-wrapped first, fall back to raw —
+  // but never swallow the size-cap abort.
+  try {
+    return inflateSync(compressed, opts);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException | null)?.code === "ERR_BUFFER_TOO_LARGE") throw err;
+    return inflateRawSync(compressed, opts);
+  }
+}
+
+export function decodeRequestBody(
+  raw: Uint8Array,
+  contentEncoding: string | null,
+  maxBytes: number = MAX_DECOMPRESSED_BODY_BYTES,
+): Uint8Array {
   const encoding = (contentEncoding ?? "").trim().toLowerCase();
-  if (encoding === "" || encoding === "identity") return raw;
+  if (encoding === "" || encoding === "identity") return assertBodySizeWithinLimit(raw, maxBytes);
+  const compressed = raw as Uint8Array<ArrayBuffer>;
+  // `maxOutputLength` makes zlib abort DURING inflation (ERR_BUFFER_TOO_LARGE), so a
+  // decompression bomb never allocates beyond the cap — checking after the fact would
+  // already have paid the full allocation (review finding, PR #96).
+  const opts = { maxOutputLength: maxBytes };
   let decoded: Uint8Array;
-  if (encoding === "zstd") decoded = Bun.zstdDecompressSync(raw);
-  else if (encoding === "gzip" || encoding === "x-gzip") decoded = Bun.gunzipSync(raw);
-  else if (encoding === "deflate") decoded = Bun.inflateSync(raw);
-  // Multi-codings ("zstd, gzip") and unknown tokens are rejected rather than guessed.
-  else throw new UnsupportedContentEncodingError(encoding);
-  if (decoded.byteLength > MAX_DECOMPRESSED_BODY_BYTES) throw new DecompressedBodyTooLargeError(decoded.byteLength);
-  return decoded;
+  try {
+    if (encoding === "zstd") decoded = zstdDecompressSync(compressed, opts);
+    else if (encoding === "gzip" || encoding === "x-gzip") decoded = gunzipSync(compressed, opts);
+    else if (encoding === "deflate") decoded = inflateDeflateBody(compressed, opts);
+    // Multi-codings ("zstd, gzip") and unknown tokens are rejected rather than guessed.
+    else throw new UnsupportedContentEncodingError(encoding);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException | null)?.code === "ERR_BUFFER_TOO_LARGE") {
+      throw new DecompressedBodyTooLargeError(maxBytes + 1, maxBytes);
+    }
+    throw err;
+  }
+  return assertBodySizeWithinLimit(decoded, maxBytes);
 }
 
 /** Parse a JSON request body, transparently decoding compressed payloads. */
 export async function readJsonRequestBody(req: Request): Promise<unknown> {
   const encoding = req.headers.get("content-encoding");
-  if (!encoding || encoding.trim().toLowerCase() === "identity") return await req.json();
   const decoded = decodeRequestBody(new Uint8Array(await req.arrayBuffer()), encoding);
   return JSON.parse(new TextDecoder().decode(decoded));
 }

package/src/server/responses.ts

@@ -10,6 +10,7 @@ import { FORWARD_HEADERS } from "../adapters/openai-responses";
 import { expandPreviousResponseInput, previousResponseConversationId, rememberResponseState } from "../responses/state";
 import { routeModel } from "../router";
 import { isInjectionDebugEnabled } from "../lib/debug-settings";
+import { injectionDebugLog } from "../lib/injection-debug-log";
 import { modelInList, namespacedToolName } from "../types";
 import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig } from "../types";
 import {
@@ -40,6 +41,7 @@ import { isUsageDebugEnabled } from "../usage/debug";
 import { readJsonRequestBody, DecompressedBodyTooLargeError, UnsupportedContentEncodingError } from "./request-decompress";
 import { resolveAdapter, resolveWireProtocolOverride } from "./adapter-resolve";
 import { hasKeyPoolFailover, rotateKeyOn429 } from "../providers/key-failover";
+import { resolveProviderTransport } from "../providers/xai-transport";
 import type { WsData } from "./ws-bridge";
 import { registerTurn, trackStreamLifetime, unregisterTurn } from "./lifecycle";
 import { redactSecretString } from "../lib/redact";
@@ -505,9 +507,9 @@ export async function handleResponses(
     const guidance = await multiAgentGuidanceText(parsed, config.injectionModel, config.injectionEffort, config.subagentModels, config.injectionPrompt);
     if (guidance) {
       injectDeveloperMessage(parsed, guidance);
-      if (isInjectionDebugEnabled()) console.log(`[opencodex] ${route.modelId}: multi-agent guidance injected (surface=${collabSurface(parsed)}, ${guidance.length} chars)`);
+      if (isInjectionDebugEnabled()) injectionDebugLog(`[opencodex] ${route.modelId}: multi-agent guidance injected (surface=${collabSurface(parsed)}, ${guidance.length} chars)`);
     } else if (isInjectionDebugEnabled() && collabSurface(parsed) !== null) {
-      console.log(`[opencodex] ${route.modelId}: collab surface=${collabSurface(parsed)}, guidance silent (effort=${parsed.options.reasoning ?? "unset"}, injectionModel=${config.injectionModel ?? "unset"})`);
+      injectionDebugLog(`[opencodex] ${route.modelId}: collab surface=${collabSurface(parsed)}, guidance silent (effort=${parsed.options.reasoning ?? "unset"}, injectionModel=${config.injectionModel ?? "unset"})`);
     }
   }
 
@@ -530,11 +532,11 @@ export async function handleResponses(
       if (capped) {
         logCtx.requestedEffort = `${capped.from}->${capped.to}`;
         if (isInjectionDebugEnabled()) {
-          console.log(`[opencodex] ${route.modelId}: effort cap applied (${capped.from} -> ${capped.to}, ${capped.subagent ? "sub-agent" : "main"} turn)`);
+          injectionDebugLog(`[opencodex] ${route.modelId}: effort cap applied (${capped.from} -> ${capped.to}, ${capped.subagent ? "sub-agent" : "main"} turn)`);
         }
       }
     } else if (isInjectionDebugEnabled() && (config.effortCap || config.subagentEffortCap)) {
-      console.log(`[opencodex] ${route.modelId}: effort cap skipped (surface=${surface ?? "none"}, v2 feature only)`);
+      injectionDebugLog(`[opencodex] ${route.modelId}: effort cap skipped (surface=${surface ?? "none"}, v2 feature only)`);
     }
   }
 
@@ -611,14 +613,15 @@ export async function handleResponses(
       return formatErrorResponse(401, "authentication_error", err instanceof Error ? err.message : String(err));
     }
   }
+  route.provider = resolveProviderTransport(route.providerName, route.provider, parsed.options.promptCacheKey);
 
-  // Vision sidecar: the routed model can't see images (provider.noVisionModels). Give it "eyes" —
-  // describe each attached image with a gpt vision model via the ChatGPT passthrough and replace it
-  // with text BEFORE the main call, so the text-only model can reason about it.
+  // Vision sidecar: the routed model can't see images (provider.noVisionModels). Describe each
+  // attached image through the selected sidecar backend and replace it with text BEFORE the main
+  // call, so the text-only model can reason about it.
   const visionPlan = planVisionSidecar(config, route.provider, route.modelId, parsed, selectedForwardHeaders, authCtx);
   const recordSidecarOutcome = sidecarOutcomeRecorder(config, authCtx);
   if (visionPlan) {
-    await describeImagesInPlace(parsed, visionPlan.forwardProvider, selectedForwardHeaders, visionPlan.settings, options.abortSignal, recordSidecarOutcome);
+    await describeImagesInPlace(parsed, visionPlan, selectedForwardHeaders, options.abortSignal, recordSidecarOutcome);
   } else if (modelInList(route.provider.noVisionModels, route.modelId)) {
     // Sidecar-covered model but NO plan (no forward provider / missing forwarded auth / sidecar
     // disabled): fail closed — never forward raw images to a text-only upstream.
@@ -869,7 +872,9 @@ export async function handleResponses(
     parsed.context.tools = [...(parsed.context.tools ?? []), buildWebSearchTool()];
     const wsResponse = await runWithWebSearch({
       parsed, adapter,
+      backend: wsPlan.backend,
       forwardProvider: wsPlan.forwardProvider,
+      anthropicSidecar: wsPlan.anthropicSidecar,
       hostedTool: wsPlan.hostedTool,
       selectedForwardHeaders,
       settings: wsPlan.settings,
@@ -883,9 +888,11 @@ export async function handleResponses(
       on429: retryAfter => {
         const rotated = rotateKeyOn429(config, route.providerName, retryAfter, Date.now(), route.provider.apiKey);
         if (!rotated) return null;
-        route.provider = rotated;
+        // Re-resolve the auth-mode transport so the conv-id / subscription headers derived at
+        // line ~616 survive the key rotation (rotated providers come from raw config).
+        route.provider = resolveProviderTransport(route.providerName, rotated, parsed.options.promptCacheKey);
         return resolveAdapter(
-          resolveWireProtocolOverride(route.providerName, route.modelId, rotated),
+          resolveWireProtocolOverride(route.providerName, route.modelId, route.provider),
           config.cacheRetention,
         );
       },
@@ -939,9 +946,11 @@ export async function handleResponses(
       // 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;
+      // Same transport re-resolution as the streaming on429 path: keep conv-id + subscription
+      // headers on the retried request instead of silently reverting to the raw config provider.
+      route.provider = resolveProviderTransport(route.providerName, rotated, parsed.options.promptCacheKey);
       const retryAdapter = resolveAdapter(
-        resolveWireProtocolOverride(route.providerName, route.modelId, rotated),
+        resolveWireProtocolOverride(route.providerName, route.modelId, route.provider),
         config.cacheRetention,
       );
       const retryRequest = await retryAdapter.buildRequest(parsed, { headers: selectedForwardHeaders });