@bitkyc08/opencodex 2.7.17 → 2.7.18

package/src/adapters/cursor/protobuf-request.ts

@@ -108,12 +108,13 @@ function rootPromptMessages(request: CursorRunRequest): Uint8Array[] {
     } else if (message.role === "assistant") {
       const text = assistantRootText(message).trim();
       if (text.length > 0) entries.push(storeCursorBlob(jsonBlob({ role: "assistant", content: [{ type: "text", text }] })));
-      for (const part of message.content) {
-        if (typeof part === "string" || part.type !== "toolCall") continue;
-        const toolName = namespacedToolName(part.namespace, part.name);
-        const callText = `[Tool Call]\ncall_id: ${part.id}\nname: ${toolName}\narguments:\n${JSON.stringify(part.arguments ?? {})}`;
-        entries.push(storeCursorBlob(jsonBlob({ role: "assistant", content: [{ type: "text", text: callText }] })));
-      }
+      // Assistant tool CALLS are intentionally NOT replayed as visible "[Tool Call]" text here.
+      // rootPromptMessagesJson is the model-visible prompt, so a synthetic "[Tool Call]" marker in an
+      // assistant turn gets few-shot-mimicked: the model then emits later (esp. parallel/mixed) tool
+      // calls as inert text instead of real tool frames, halting multi-tool continuations. The paired
+      // tool result below ([Tool Result]/[Tool Error]) carries the call id/name/output Cursor needs to
+      // continue, and conversationTurns replays the native mcpToolCall step. Mirrors request-builder.ts
+      // contentPartToText() which returns undefined for toolCall for the same reason.
     } else if (message.role === "toolResult") {
       const prefix = message.isError ? "[Tool Error]" : "[Tool Result]";
       const text = `${prefix}\n${toolResultToText(message)}`;

package/src/adapters/kiro-images.ts

@@ -1,4 +1,5 @@
 import type { OcxContentPart } from "../types";
+import { normalizeImageTargets, type NormalizeOptions, type NormalizeTarget } from "./anthropic-image-normalize";
 
 // CodeWhisperer native image part (matches Kiro IDE wire format): the base64 bytes live directly in
 // userInputMessage.images, NOT in userInputMessageContext. Verified against kiro-gateway.
@@ -33,3 +34,96 @@ export function extractKiroImages(content: string | OcxContentPart[]): KiroImage
   }
   return out;
 }
+
+/**
+ * Conservative POLICY caps for the CodeWhisperer GenerateAssistantResponse payload,
+ * whose limits are undocumented. Derived from adjacent AWS surfaces
+ * (devlog/260714_image_normalization_pipeline/050): Bedrock `Message` allows 20 images
+ * per message (Converse), and `InvokeModel` caps requests at 25,000,000 bytes — 18MiB
+ * bounds the IMAGE share of the body with headroom for text/tools.
+ */
+export const KIRO_IMAGE_BASE64_BUDGET = 18 * 1024 * 1024;
+export const KIRO_MAX_IMAGES_PER_MESSAGE = 20;
+
+const COUNT_CAP_NOTE = "[image omitted: exceeded the 20-image per-message cap; oldest images in this message were dropped]";
+
+/** A kiro wire message that can carry images (history userInputMessage or currentMessage). */
+interface KiroImageCarrier {
+  content?: string;
+  images?: KiroImage[];
+}
+
+function isCarrier(v: unknown): v is KiroImageCarrier {
+  return typeof v === "object" && v !== null;
+}
+
+/** Collect image-bearing userInputMessages in wire order (history oldest-first, then current). */
+function collectKiroImageCarriers(payload: unknown): KiroImageCarrier[] {
+  const state = (payload as { conversationState?: { history?: unknown[]; currentMessage?: { userInputMessage?: unknown } } })?.conversationState;
+  if (!state) return [];
+  const carriers: KiroImageCarrier[] = [];
+  for (const entry of state.history ?? []) {
+    const uim = (entry as { userInputMessage?: unknown })?.userInputMessage;
+    if (isCarrier(uim)) carriers.push(uim);
+  }
+  const current = state.currentMessage?.userInputMessage;
+  if (isCarrier(current)) carriers.push(current);
+  return carriers;
+}
+
+function appendNote(carrier: KiroImageCarrier, note: string): void {
+  carrier.content = carrier.content ? `${carrier.content}\n${note}` : note;
+}
+
+/**
+ * Apply the generous image pipeline to a built CodeWhisperer payload (mutates in
+ * place): per-message 20-image cap first (oldest dropped), then the shared tier
+ * machinery with the kiro budget and terminal-overflow DROP (kiro has no downstream
+ * guard). Test seams (encode/validate) forward into the core.
+ */
+export async function normalizeKiroImages(
+  payload: unknown,
+  opts?: Pick<NormalizeOptions, "encode" | "validate">,
+): Promise<void> {
+  const carriers = collectKiroImageCarriers(payload);
+  if (carriers.length === 0) return;
+
+  // Pre-pass: per-message count cap (drop oldest within the message).
+  for (const carrier of carriers) {
+    const images = carrier.images;
+    if (!images || images.length <= KIRO_MAX_IMAGES_PER_MESSAGE) continue;
+    images.splice(0, images.length - KIRO_MAX_IMAGES_PER_MESSAGE);
+    appendNote(carrier, COUNT_CAP_NOTE);
+  }
+
+  // Targets over the survivors, oldest→newest across carriers. Drops resolve the image
+  // by OBJECT IDENTITY at execution time (indices go stale after earlier splices) and
+  // delete an emptied images field per the builder's omission contract.
+  const targets: NormalizeTarget[] = [];
+  for (const carrier of carriers) {
+    for (const img of carrier.images ?? []) {
+      targets.push({
+        base64: typeof img.source?.bytes === "string" && img.source.bytes.length > 0 ? img.source.bytes : null,
+        mediaType: `image/${(img.format || "jpeg").toLowerCase()}`,
+        replace: (data: string, mediaType: string) => {
+          img.source.bytes = data;
+          img.format = (mediaType.split("/")[1] ?? "jpeg").toLowerCase();
+        },
+        drop: (note: string) => {
+          const arr = carrier.images;
+          if (arr) {
+            const idx = arr.indexOf(img);
+            if (idx !== -1) arr.splice(idx, 1);
+            if (arr.length === 0) delete carrier.images;
+          }
+          appendNote(carrier, note);
+        },
+      });
+    }
+  }
+  await normalizeImageTargets(targets, {
+    budget: KIRO_IMAGE_BASE64_BUDGET,
+    overflowAction: "drop",
+    ...(opts ?? {}),
+  });
+}

package/src/adapters/kiro.ts

@@ -25,7 +25,7 @@ import type {
 } from "../types";
 import type { ProviderAdapter } from "./base";
 import type { AdapterFetchContext, AdapterRequest } from "./base";
-import { extractKiroImages, type KiroImage } from "./kiro-images";
+import { extractKiroImages, normalizeKiroImages, type KiroImage } from "./kiro-images";
 import { fetchKiroWithRetry } from "./kiro-retry";
 import { convertKiroToolContext } from "./kiro-tools";
 import { neutralizeIdentity } from "./identity";
@@ -497,7 +497,7 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
   let toolNameMap: Map<string, string> | undefined;
   return {
     name: "kiro",
-    buildRequest(parsed: OcxParsedRequest) {
+    async buildRequest(parsed: OcxParsedRequest) {
       if (typeof provider.apiKey !== "string" || provider.apiKey.trim() === "") {
         throw new Error("kiro token missing — run ocx login kiro");
       }
@@ -520,6 +520,10 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
       // fake-reasoning contract by injecting effort-derived thinking tags into only the current user turn.
       const built = buildKiroPayload(parsed, profileArn);
       toolNameMap = built.nameMap;
+      // Generous image pipeline (devlog/260714_image_normalization_pipeline/050):
+      // tier-normalize + cap images before serialization so bodyBytes below reflects
+      // the normalized size.
+      await normalizeKiroImages(built.payload);
       const body = JSON.stringify(built.payload);
       debugProviderDiagnostic("kiro", "request", {
         region,

package/src/adapters/openai-chat.ts

@@ -2,6 +2,7 @@ import type { ProviderAdapter } from "./base";
 import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxThinkingContent, OcxToolCall, OcxUsage } from "../types";
 import { isAllowedToolChoice, modelInList, namespacedToolName, resolveToolChoiceWireName, toolAllowedByChoice } from "../types";
 import { mapReasoningEffort } from "../reasoning-effort";
+import { redactSecretString } from "../lib/redact";
 import { contentPartsToText } from "./image";
 import { neutralizeIdentity } from "./identity";
 import { buildNonOpenAIToolCatalogNudgeForTools, shouldInjectNonOpenAIToolCatalogNudge } from "./tool-catalog-nudge";
@@ -13,6 +14,52 @@ export function stripBracketedModelSuffix(modelId: string): string {
   return modelId.replace(/\[[^\]]*\]\s*$/, "");
 }
 
+// 260715 (issue #126): surface upstream error detail through the web-search sidecar loop.
+// loop.ts only appends a suffix to "Provider error N" when the adapter exposes
+// formatErrorBody; without it, strict OpenAI-compatible backends (NVIDIA NIM pydantic
+// validation, "This model only supports single tool-calls at once!", etc.) were reduced
+// to a bare status code. JSON-only extraction: recognized string fields are returned,
+// HTML/non-JSON bodies yield "" so raw markup is never echoed to the client.
+export function formatOpenAIChatErrorBody(status: number, _headers: Headers, payloadText: string): string {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(payloadText);
+  } catch {
+    return "";
+  }
+  const detail = extractErrorDetail(parsed);
+  if (!detail) return "";
+  return redactSecretString(detail).slice(0, 400);
+}
+
+function extractErrorDetail(parsed: unknown): string | undefined {
+  if (typeof parsed === "string") return parsed.trim() || undefined;
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+  const obj = parsed as Record<string, unknown>;
+  // OpenAI shape: { error: { message } } or { error: "..." }
+  const err = obj.error;
+  if (typeof err === "string" && err.trim()) return err.trim();
+  if (err !== null && typeof err === "object" && !Array.isArray(err)) {
+    const msg = (err as Record<string, unknown>).message;
+    if (typeof msg === "string" && msg.trim()) return msg.trim();
+  }
+  // FastAPI/pydantic shape (NVIDIA NIM): { detail: "..." } or { detail: [{ msg, loc }, ...] }
+  const det = obj.detail;
+  if (typeof det === "string" && det.trim()) return det.trim();
+  if (Array.isArray(det)) {
+    const msgs = det
+      .map(item => (item !== null && typeof item === "object" && typeof (item as Record<string, unknown>).msg === "string"
+        ? ((item as Record<string, unknown>).msg as string).trim()
+        : ""))
+      .filter(m => m.length > 0);
+    if (msgs.length > 0) return msgs.join("; ");
+  }
+  // Generic fallbacks: { message } / RFC7807 { title }
+  if (typeof obj.message === "string" && obj.message.trim()) return obj.message.trim();
+  if (typeof obj.title === "string" && obj.title.trim()) return obj.title.trim();
+  return undefined;
+}
+
 function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig): unknown[] {
   const out: unknown[] = [];
   const { context, options } = parsed;
@@ -231,6 +278,8 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
   return {
     name: "openai-chat",
 
+    formatErrorBody: formatOpenAIChatErrorBody,
+
     buildRequest(parsed: OcxParsedRequest) {
       const hasCredential = typeof provider.apiKey === "string" && provider.apiKey.trim().length > 0;
       if ((provider.authMode === "key" || provider.authMode === "oauth") && !provider.keyOptional && !hasCredential) {

package/src/adapters/openai-responses.ts

@@ -136,9 +136,135 @@ function scrubOcxCompactionItems(body: unknown): unknown {
  * Extend this when another native slug rejects a hosted tool (e.g. `code_interpreter`).
  */
 const UNSUPPORTED_HOSTED_TOOLS: ReadonlyArray<{ match: (model: string) => boolean; tools: ReadonlySet<string> }> = [
-  { match: model => model.includes("codex-spark"), tools: new Set(["image_generation"]) },
+  { match: model => model.includes("codex-spark"), tools: new Set(["image_generation", "tool_search"]) },
 ];
 
+/**
+ * Strip unsupported `reasoning` sub-parameters for native slugs that reject them (e.g. Spark).
+ * codex-rs injects `reasoning.context` and `reasoning.summary` based on catalog flags; Spark's
+ * backend rejects both. The catalog fix prevents `use_responses_lite` from being set, but this
+ * is a defense-in-depth guard so stale on-disk catalogs don't break until the user runs `ocx sync`.
+ */
+function stripUnsupportedReasoningParams(body: unknown): unknown {
+  if (!isPlainObject(body)) return body;
+  const model = typeof body.model === "string" ? body.model : "";
+  if (!model.includes("codex-spark")) return body;
+  if (!isPlainObject(body.reasoning)) return body;
+  const reasoning = body.reasoning as Record<string, unknown>;
+  // Spark supports reasoning.effort but rejects context, summary, and generate_summary.
+  const { context: _ctx, summary: _sum, generate_summary: _gs, ...rest } = reasoning;
+  if (_ctx === undefined && _sum === undefined && _gs === undefined) return body;
+  return { ...body, reasoning: Object.keys(rest).length > 0 ? rest : undefined };
+}
+
+/**
+ * Comprehensive Spark compatibility layer. codex-rs emits five tool types (function,
+ * namespace, tool_search, web_search, custom) plus extensions (defer_loading,
+ * parallel_tool_calls, tool_search_call/output items). Spark's serving path only
+ * supports flat function tools and hosted web_search. This function:
+ * - Flattens namespace tools → promotes inner functions to top level
+ * - Drops unsupported tool types (tool_search, custom)
+ * - Strips defer_loading from function tools
+ * - Strips namespace from input items
+ * - Drops tool_search_call/tool_search_output input items
+ * - Sets parallel_tool_calls to false
+ */
+function stripSparkCompatibility(body: unknown): unknown {
+  if (!isPlainObject(body)) return body;
+  const model = typeof body.model === "string" ? body.model : "";
+  if (!model.includes("codex-spark")) return body;
+
+  let changed = false;
+
+  const SPARK_SAFE_TOOL_TYPES = new Set(["function", "web_search", "web_search_preview"]);
+
+  let tools = body.tools;
+  if (Array.isArray(tools)) {
+    const flattened: unknown[] = [];
+    for (const t of tools) {
+      if (isPlainObject(t) && t.type === "namespace") {
+        changed = true;
+        if (Array.isArray(t.tools)) {
+          for (const inner of t.tools) flattened.push(inner);
+        }
+      } else if (isPlainObject(t) && typeof t.type === "string" && !SPARK_SAFE_TOOL_TYPES.has(t.type)) {
+        changed = true;
+      } else {
+        flattened.push(t);
+      }
+    }
+    // Strip defer_loading from promoted/remaining function tools.
+    tools = flattened.map(t => {
+      if (isPlainObject(t) && t.type === "function" && "defer_loading" in t) {
+        const { defer_loading: _, ...rest } = t;
+        changed = true;
+        return rest;
+      }
+      return t;
+    });
+  }
+
+  // Clean input items: strip namespace, drop tool_search_call/tool_search_output.
+  const SPARK_UNSUPPORTED_INPUT_TYPES = new Set([
+    "tool_search_call", "tool_search_output",
+    "custom_tool_call", "custom_tool_call_output",
+  ]);
+  let input = body.input;
+  if (Array.isArray(input)) {
+    const cleaned: unknown[] = [];
+    for (const item of input) {
+      if (isPlainObject(item) && typeof item.type === "string" && SPARK_UNSUPPORTED_INPUT_TYPES.has(item.type)) {
+        changed = true;
+        continue;
+      }
+      // Process additional_tools items: filter their inner tools array the same way.
+      if (isPlainObject(item) && item.type === "additional_tools" && Array.isArray(item.tools)) {
+        const innerTools = item.tools as unknown[];
+        const filteredInner: unknown[] = [];
+        for (const t of innerTools) {
+          if (isPlainObject(t) && t.type === "namespace") {
+            changed = true;
+            if (Array.isArray(t.tools)) {
+              for (const fn of t.tools) filteredInner.push(fn);
+            }
+          } else if (isPlainObject(t) && typeof t.type === "string" && !SPARK_SAFE_TOOL_TYPES.has(t.type)) {
+            changed = true; // drop custom, tool_search, etc.
+          } else {
+            filteredInner.push(t);
+          }
+        }
+        // Strip defer_loading from remaining function tools.
+        const cleanedInner = filteredInner.map(t => {
+          if (isPlainObject(t) && t.type === "function" && "defer_loading" in t) {
+            const { defer_loading: _, ...rest } = t;
+            changed = true;
+            return rest;
+          }
+          return t;
+        });
+        cleaned.push({ ...item, tools: cleanedInner });
+        continue;
+      }
+      if (isPlainObject(item) && "namespace" in item) {
+        const { namespace: _, ...rest } = item;
+        changed = true;
+        cleaned.push(rest);
+      } else {
+        cleaned.push(item);
+      }
+    }
+    if (changed) input = cleaned;
+  }
+
+  // Force parallel_tool_calls off for Spark.
+  const extraOverrides: Record<string, unknown> = {};
+  if (body.parallel_tool_calls === true) { extraOverrides.parallel_tool_calls = false; changed = true; }
+
+  return changed
+    ? { ...body, ...(tools !== body.tools ? { tools } : {}), ...(input !== body.input ? { input } : {}), ...extraOverrides }
+    : body;
+}
+
 function isPlainObject(v: unknown): v is Record<string, unknown> {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
@@ -331,7 +457,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         url,
         method: "POST",
         headers,
-        body: JSON.stringify(stripItemIdsWhenUnstored(stripInvalidItemIds(stripUnsupportedHostedTools(sanitizeReasoningInputContent(scrubOcxCompactionItems(outBody)))))),
+        body: JSON.stringify(stripSparkCompatibility(stripUnsupportedReasoningParams(stripItemIdsWhenUnstored(stripInvalidItemIds(stripUnsupportedHostedTools(sanitizeReasoningInputContent(scrubOcxCompactionItems(outBody)))))))),
       };
     },
 

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/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 defaults to codex-sandbox mode (auto-enabled when the request declares Codex danger-full-access sandbox); override with \"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));
   }