@bitkyc08/opencodex 2.54.0 → 2.55.0-preview.20260914

package/src/oauth/devin.ts

@@ -20,9 +20,28 @@ import { registerUser } from "./devin/register-user";
 import { DEVIN_DEFAULT_API_SERVER, resolveDevinApiBaseUrl, validateDevinApiBaseUrl } from "./devin/api-base";
 import { readDevinCliCredentialOutcome } from "./devin/cli-import";
 import { getCredential } from "./store";
+import { DEPRECATED_OAUTH_PROVIDER_ALIASES } from "./index";
 
 export { DEVIN_DEFAULT_API_SERVER } from "./devin/api-base";
 
+/**
+ * Credential slots the deprecated-alias map ties to `providerId`, in both
+ * directions: a deprecated id also reads its destination's slot, and a merge
+ * destination also reads every deprecated source slot pointing at it. Derived
+ * from DEPRECATED_OAUTH_PROVIDER_ALIASES rather than a second "devin-cli"
+ * literal so the map stays the single source of truth — a hard-coded pair here
+ * would drift the day another alias is added.
+ */
+function devinAliasCredentialSlots(providerId: string): string[] {
+  const slots: string[] = [];
+  const destination = DEPRECATED_OAUTH_PROVIDER_ALIASES[providerId];
+  if (destination !== undefined) slots.push(destination);
+  for (const [alias, target] of Object.entries(DEPRECATED_OAUTH_PROVIDER_ALIASES)) {
+    if (target === providerId && alias !== providerId) slots.push(alias);
+  }
+  return slots;
+}
+
 /**
  * The api-server host this account must talk to.
  *
@@ -33,18 +52,44 @@ export { DEVIN_DEFAULT_API_SERVER } from "./devin/api-base";
  * network value.
  */
 export function resolveDevinApiServer(configuredBaseUrl?: string, providerId = "devin"): string {
-  return (
-    // Provider-scoped, keyed by the configured provider id verbatim. `devin-cli`
-    // is a deprecated alias for `devin`, but an unmigrated config row still owns
-    // its old credential slot until the startup migration rekeys the row and the
-    // slot together — normalizing the id here would read the wrong slot for that
-    // window. An EU or FedStart tenant is recorded on the credential rather than
-    // in the registry, so a fixed "devin" slot would send the key to the wrong
-    // host either way.
-    validateDevinApiBaseUrl(getCredential(providerId)?.apiBaseUrl) ??
-    validateDevinApiBaseUrl(configuredBaseUrl) ??
-    DEVIN_DEFAULT_API_SERVER
-  );
+  // Provider-scoped, keyed by the configured provider id verbatim and consulted
+  // FIRST. `devin-cli` is a deprecated alias for `devin`, but an unmigrated
+  // config row still owns its old credential slot until the startup migration
+  // rekeys the row and the slot together — normalizing the id here would read
+  // the wrong slot for that window. An EU or FedStart tenant is recorded on the
+  // credential rather than in the registry, so a fixed "devin" slot would send
+  // the key to the wrong host either way.
+  const literalCredential = getCredential(providerId);
+  const literal = validateDevinApiBaseUrl(literalCredential?.apiBaseUrl);
+  if (literal !== undefined) return literal;
+
+  // The startup merge saves providers["devin"] synchronously but fires the
+  // credential rekey detached — runDevinProviderMergeStartupMigration cannot
+  // await inside the synchronous startServer window — so the row can already
+  // say "devin" while the credential still sits in the "devin-cli" slot, and it
+  // stays that way for the whole process when the rekey fails or refuses on an
+  // occupied destination slot. Reading the alias-linked slots in both
+  // directions closes that window: "devin" finds the not-yet-rekeyed
+  // "devin-cli" credential, and a lingering "devin-cli" row finds a credential
+  // already rekeyed to "devin". Every candidate passes the same allowlist — an
+  // alias slot is not trusted more than the literal one.
+  // Only when this id owns no credential at all. A present credential whose
+  // apiBaseUrl is missing or off-allowlist is a different situation: the rekey
+  // refuses an occupied destination slot, so both ids can hold credentials that
+  // belong to two different accounts. Borrowing a tenant across that pair would
+  // send this account's key to the other account's EU or FedStart host, which
+  // is the exact misdirection the provider-scoped lookup exists to prevent. An
+  // unusable host on a credential that does exist falls through to the
+  // configured base URL and then the default, as it did before this window was
+  // closed.
+  if (literalCredential === null || literalCredential === undefined) {
+    for (const slot of devinAliasCredentialSlots(providerId)) {
+      const host = validateDevinApiBaseUrl(getCredential(slot)?.apiBaseUrl);
+      if (host !== undefined) return host;
+    }
+  }
+
+  return validateDevinApiBaseUrl(configuredBaseUrl) ?? DEVIN_DEFAULT_API_SERVER;
 }
 
 function decodeJwtPayload(token: string): Record<string, unknown> | undefined {

package/src/providers/quota.ts

@@ -2951,7 +2951,26 @@ function unavailableAntigravityQuota(failure: QuotaFailureCode): AntigravityQuot
   return { kind: "unavailable", failure, legacy: { kind: "null" } };
 }
 
-/** Final attempt determines the safe diagnosis; a successful fallback clears the first failure. */
+/**
+ * Prefer a summary network-policy diagnosis over a vaguer fallback. A blocked
+ * destination is an actionable local-network fact, while "upstream_error" tells
+ * the operator to go look at Google. A successful models probe still clears
+ * the first failure completely.
+ */
+function antigravityUnavailableFailure(
+  summaryFailure: QuotaFailureCode | undefined,
+  fallbackFailure: QuotaFailureCode,
+): QuotaFailureCode {
+  if (
+    (summaryFailure === "destination_blocked" || summaryFailure === "dns_failed")
+    && fallbackFailure !== "destination_blocked"
+    && fallbackFailure !== "dns_failed"
+  ) {
+    return summaryFailure;
+  }
+  return fallbackFailure;
+}
+
 async function probeAntigravityUsageQuota(accessToken: string, projectId: string): Promise<AntigravityQuotaProbeResult> {
   const fetchQuota = (url: string) => providerOutboundPost("google-antigravity", { baseUrl: ANTIGRAVITY_ACCOUNT_QUOTA_BASE }, url, {
     headers: {
@@ -2960,6 +2979,7 @@ async function probeAntigravityUsageQuota(accessToken: string, projectId: string
     },
     body: JSON.stringify({ project: projectId }), signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
   }, antigravityOutboundDependencies);
+  let summaryFailure: QuotaFailureCode | undefined;
   try {
     const response = await fetchQuota(ANTIGRAVITY_QUOTA_SUMMARY_URL);
     if (await providerRedirectError(response, ANTIGRAVITY_QUOTA_SUMMARY_URL)) return unavailableAntigravityQuota("redirect_blocked");
@@ -2968,19 +2988,30 @@ async function probeAntigravityUsageQuota(accessToken: string, projectId: string
       const quota = parseAntigravityQuotaSummary(asRecord(await readQuotaJson(response)));
       if (quota) return { kind: "available", quota, source: "google-antigravity:retrieveUserQuotaSummary" };
     }
-  } catch {
+  } catch (error) {
     // Existing behavior: summary transport/parse failure may recover through the models probe.
+    summaryFailure = quotaTransportFailure(error);
   }
   try {
     const response = await fetchQuota(ANTIGRAVITY_QUOTA_MODELS_URL);
-    if (await providerRedirectError(response, ANTIGRAVITY_QUOTA_MODELS_URL)) return unavailableAntigravityQuota("redirect_blocked");
-    if (!response.ok) return unavailableAntigravityQuota(quotaHttpFailure(response.status));
+    if (await providerRedirectError(response, ANTIGRAVITY_QUOTA_MODELS_URL)) {
+      return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, "redirect_blocked"));
+    }
+    if (!response.ok) {
+      return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, quotaHttpFailure(response.status)));
+    }
     const customWindows = antigravityWindowsFromModels(asRecord(await readQuotaJson(response)));
-    if (!customWindows.length) return unavailableAntigravityQuota("response_unusable");
+    if (!customWindows.length) {
+      return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, "response_unusable"));
+    }
     return { kind: "available", quota: { customWindows, updatedAt: Date.now() }, source: "google-antigravity:fetchAvailableModels" };
   } catch (error) {
     // The public compatibility wrapper still rejects this exact fallback error; it never enters a DTO.
-    return { kind: "unavailable", failure: quotaTransportFailure(error), legacy: { kind: "throw", error } };
+    return {
+      kind: "unavailable",
+      failure: antigravityUnavailableFailure(summaryFailure, quotaTransportFailure(error)),
+      legacy: { kind: "throw", error },
+    };
   }
 }
 

package/src/providers/registry.ts

@@ -707,9 +707,35 @@ const COMMAND_CODE_IMAGE_MODELS = [
   "meta/muse-spark-1.3-contributor",
   "meta/muse-spark-1.2",
   "meta/muse-spark-1.2-contributor",
+  // Native Z.AI VLM (docs.z.ai/guides/vlm/glm-5.3-flash). This exact id is already
+  // classified as natively vision-capable in NVIDIA_NIM_VISION_MODELS in this file;
+  // it is not one of the verified-negative ids the header names (those are
+  // deepseek/deepseek-v4-flash, zai-org/GLM-5.2, zai-org/GLM-5.3, xai/grok-4.6 —
+  // different ids). Adding it on the shared GLM-5.3 prefix would be the family-
+  // resemblance mistake the header forbids; the VLM docs are the evidence (#4505).
+  "z-ai/glm-5.3-flash",
+] as const;
+/**
+ * Native image stays sourced from COMMAND_CODE_IMAGE_MODELS. Text-only routes
+ * sit beside that list so the catalog can still advertise sidecar coverage
+ * without claiming the gateway itself accepts a picture.
+ *
+ * The gateway-prefixed DeepSeek V4.1 Flash route has no verified native image
+ * support, so declaring it image-capable would hand it a picture it drops. A
+ * positive text-only declaration makes it a vision-sidecar consumer
+ * (src/vision/eligibility.ts), so the catalog advertises image input on its
+ * behalf and the four-target combo in #4505 intersects to ["text","image"]
+ * instead of ["text"] — without claiming native vision. modelInputModalities
+ * is per-key filled, so this reaches an existing install even when
+ * noVisionModels was persisted before the id joined that list.
+ */
+const COMMAND_CODE_TEXT_ONLY_MODELS = [
+  "deepseek/deepseek-v4.1-flash",
 ] as const;
-const COMMAND_CODE_MODEL_INPUT_MODALITIES: Record<string, ["text", "image"]> =
-  Object.fromEntries(COMMAND_CODE_IMAGE_MODELS.map(id => [id, ["text", "image"]]));
+const COMMAND_CODE_MODEL_INPUT_MODALITIES: Record<string, ["text"] | ["text", "image"]> = {
+  ...Object.fromEntries(COMMAND_CODE_IMAGE_MODELS.map(id => [id, ["text", "image"] as ["text", "image"]])),
+  ...Object.fromEntries(COMMAND_CODE_TEXT_ONLY_MODELS.map(id => [id, ["text"] as ["text"]])),
+};
 const OPENCODE_FREE_DEEPSEEK_MODELS = ["deepseek-v4-flash-free"];
 /*
  * Zen free models that reject `image_url` upstream (#1043, and the reproducible
@@ -722,10 +748,9 @@ const OPENCODE_FREE_DEEPSEEK_MODELS = ["deepseek-v4-flash-free"];
  * `[404] No endpoints found that support image input` and `big-pickle` with the
  * exact deserialize error quoted in #1043.
  *
- * `mimo-v2.5-free` and `longcat-2.0-free` ACCEPT images and are deliberately
- * absent. Adding them would silently replace a working image with a caption,
- * which is worse than the loud 400 this list exists to prevent — see the negative
- * assertion in tests/providers/provider-registry-parity.test.ts.
+ * `mimo-v2.5-free` and `longcat-2.0-free` ACCEPT images. They remain absent
+ * from the blind list and are recorded separately as positive input-modality evidence,
+ * so capability-positive dispatch can forward images without relying on blacklist absence.
  *
  * Zen's roster is discovered live while this list is static, so it is a dated
  * exception list, not a capability model. Re-probe before extending it.
@@ -739,6 +764,7 @@ const OPENCODE_ZEN_TEXT_ONLY_MODELS = [
   "laguna-s-2.1-free",
   "deepseek-v4-flash-free",
 ];
+const OPENCODE_ZEN_IMAGE_MODELS = ["mimo-v2.5-free", "longcat-2.0-free"] as const;
 /*
  * DeepSeek's Codex ladder is low/high/max. With the V4 Pro GA release
  * (DeepSeek-V4-Pro-0813) the official thinking-mode table is IDENTICAL for both
@@ -1856,8 +1882,27 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     },
     modelInputModalities: {
       "kimi-k3": ["text", "image"],
+      // glm-5.3-flash is a native VLM (docs.z.ai/guides/vlm/glm-5.3-flash). It is
+      // deliberately absent from this preset's noVisionModels, which is the
+      // correct NEGATIVE half, but with no positive modelInputModalities entry
+      // configuredInputModalities returns undefined and the catalog falls through
+      // to the ["text"] floor. The same model is already declared ["text","image"]
+      // on the zai and zhipu-bigmodel-coding presets, so the registry described
+      // one model two ways (#4505).
+      "glm-5.3-flash": ["text", "image"],
       // Experimental DeepSeek vision preview — expected to merge into deepseek-v4-flash later.
       [DEEPSEEK_VISION_PREVIEW_MODEL]: ["text", "image"],
+      // This route is text-only upstream — it is already listed in this preset's
+      // noVisionModels, which routes images through the proxy's vision sidecar and
+      // makes the catalog advertise image input on its behalf. The positive
+      // text-only declaration is what reaches an EXISTING install: derive.ts fills
+      // noVisionModels all-or-nothing, so a config persisted before this id joined
+      // the list keeps a stale list, the sidecar predicate never matches, the row
+      // carries no modality at all, and any combo containing it collapses to
+      // ["text"] (#4505). modelInputModalities IS per-key filled, so this
+      // declaration lands on old configs. It states the route's real upstream
+      // capability and keeps the sidecar explicitly distinct from native vision.
+      "deepseek-v4.1-flash": ["text"],
       // Muse Spark Contributor is natively multimodal on Zen Go: it accepts input_image
       // parts over /responses (probed 2026-08-26). Without this declaration the catalog
       // advertises it text-only and the Codex app blocks image attachments client-side with
@@ -3209,6 +3254,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     },
     modelInputModalities: {
       [DEEPSEEK_VISION_PREVIEW_MODEL]: ["text", "image"],
+      ...Object.fromEntries(OPENCODE_ZEN_IMAGE_MODELS.map(id => [id, ["text", "image"] as string[]])),
     },
     noVisionModels: [...OPENCODE_ZEN_TEXT_ONLY_MODELS, ...DEEPSEEK_GATEWAY_THINKING_MODELS],
     // Same DeepSeek routes as the Go preset above, behind the same vendor, so they carry
@@ -3250,6 +3296,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     },
     modelInputModalities: {
       [DEEPSEEK_VISION_PREVIEW_MODEL]: ["text", "image"],
+      ...Object.fromEntries(OPENCODE_ZEN_IMAGE_MODELS.map(id => [id, ["text", "image"] as string[]])),
     },
     // Same Zen roster behind the same base URL, so it carries the same measured
     // text-only list rather than only its DeepSeek member (#1043).

package/src/responses/input-media.ts

@@ -0,0 +1,65 @@
+/** Input kinds for which the normalized request has no lossless content carrier. */
+export type UntranslatedInputMedia = "audio" | "file";
+
+type RecordValue = Record<string, unknown>;
+
+function isRecord(value: unknown): value is RecordValue {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function mediaKind(value: unknown): UntranslatedInputMedia | undefined {
+  if (!isRecord(value)) return undefined;
+  if (value.type === "input_audio" || value.type === "audio") return "audio";
+  if (value.type === "input_file" || value.type === "file" || value.type === "document") return "file";
+  // A file-id-only image is not pixels: translated adapters cannot dereference it.
+  if (value.type === "input_image" && typeof value.file_id === "string" && value.file_id.length > 0
+      && !(typeof value.image_url === "string" && value.image_url.length > 0)) return "file";
+  return undefined;
+}
+
+function contentMedia(content: unknown): UntranslatedInputMedia | undefined {
+  if (!Array.isArray(content)) return undefined;
+  for (const part of content) {
+    const kind = mediaKind(part);
+    if (kind) return kind;
+  }
+  return undefined;
+}
+
+/**
+ * Inspect only typed input items and their content arrays, never strings, tool
+ * arguments, schema properties, or arbitrary nested objects. No payload is copied,
+ * decoded, fetched or included in the returned value.
+ */
+export function untranslatedResponsesInputMedia(body: unknown): UntranslatedInputMedia | undefined {
+  if (!isRecord(body) || !Array.isArray(body.input)) return undefined;
+  for (const item of body.input) {
+    if (!isRecord(item)) continue;
+    const direct = mediaKind(item);
+    if (direct) return direct;
+    if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
+      const kind = contentMedia(item.output);
+      if (kind) return kind;
+    } else if (item.type === "message" || item.type === undefined) {
+      const kind = contentMedia(item.content);
+      if (kind) return kind;
+    }
+  }
+  return undefined;
+}
+
+/** Used only when Chat is actually projected, not on the native Chat fast path. */
+export function untranslatedChatInputMedia(body: unknown): UntranslatedInputMedia | undefined {
+  if (!isRecord(body) || !Array.isArray(body.messages)) return undefined;
+  for (const message of body.messages) {
+    if (!isRecord(message)) continue;
+    const kind = contentMedia(message.content);
+    if (kind) return kind;
+  }
+  return undefined;
+}
+
+/** Fixed vocabulary only: never interpolate filenames, URLs or client metadata. */
+export function untranslatedInputMediaMessage(kind: UntranslatedInputMedia): string {
+  return `OpenCodex cannot translate ${kind} input on this route. Use a native input wire that supports the attachment, or convert it to text first.`;
+}

package/src/responses/parser-content.ts

@@ -9,6 +9,8 @@ type InputBlock =
   | { type: "text"; text: string }
   | { type: "input_image"; image_url?: string; file_id?: string; detail?: string }
   | { type: "input_video"; video_url?: string }
+  // codex-rs protocol/src/models.rs sends audio as input_audio with an audio_url.
+  | { type: "input_audio"; audio_url?: string; format?: string }
   | { type: "input_file"; file_id?: string; filename?: string; file_data?: string };
 
 /** A usable reference string, or undefined. Empty strings and non-strings are not references. */
@@ -16,6 +18,19 @@ function nonEmptyString(value: unknown): string | undefined {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
+/**
+ * An audio format label safe to render into model-visible prose.
+ *
+ * `format` is caller-controlled and unbounded in the schema, so interpolating it
+ * verbatim would let a request park newlines, injected instructions, or a signed URL
+ * inside text the model reads as trusted proxy output. Only a short alphanumeric
+ * token is echoed; anything else degrades to the bare marker.
+ */
+function safeAudioFormat(value: unknown): string | undefined {
+  const raw = nonEmptyString(value);
+  return raw !== undefined && /^[a-z0-9]{1,12}$/i.test(raw) ? raw : undefined;
+}
+
 export function inputContentParts(blocks: unknown): string | OcxContentPart[] {
   if (typeof blocks === "string") return blocks;
   // The catch-all can also hand back a non-array `content` (an object, a number), which would
@@ -47,6 +62,26 @@ export function inputContentParts(blocks: unknown): string | OcxContentPart[] {
     } else if (block.type === "input_video") {
       const videoUrl = nonEmptyString(block.video_url);
       if (videoUrl) parts.push({ type: "video", videoUrl });
+    } else if (block.type === "input_audio") {
+      // Upstream Codex sends input_audio with an audio_url (codex-rs
+      // protocol/src/models.rs). The IR has no audio carrier and no adapter consumes
+      // one, so this part used to vanish with no trace at all.
+      //
+      // This records PRESENCE only and is NOT audio support: never the payload, which
+      // is large base64 and would explode the token count, and never the URL, which
+      // can carry a signed token. This parser must stay non-throwing — the native
+      // Responses passthrough also runs through parseRequest before the adapter
+      // forwards _rawBody, so refusing here would regress legitimate raw passthrough.
+      //
+      // No adapter refuses audio at its wire today: by this point the part is already a
+      // text marker, so downstream adapters see text and continue. A typed unsupported-
+      // modality carrier that survives to final adapter dispatch is a separate, recorded
+      // residual — do not describe this branch as a refusal.
+      const b = block as { audio_url?: string; format?: string };
+      const format = safeAudioFormat(b.format);
+      if (nonEmptyString(b.audio_url)) {
+        parts.push({ type: "text", text: format ? `[audio: ${format}]` : "[audio]" });
+      }
     } else if (block.type === "input_file") {
       const b = block as { file_id?: string; filename?: string; file_data?: string };
       const fileId = nonEmptyString(b.file_id);
@@ -111,6 +146,13 @@ export function outputToToolResultContent(output: string | unknown[] | undefined
       } else if (fileId) {
         parts.push({ type: "text", text: `[image: ${fileId}]` });
       }
+    } else if (raw.type === "input_audio") {
+      // Same presence-only contract as the user-content branch above: Codex returns
+      // audio in tool output too, and it previously disappeared without trace.
+      const format = safeAudioFormat(raw.format);
+      if (nonEmptyString(raw.audio_url)) {
+        parts.push({ type: "text", text: format ? `[audio: ${format}]` : "[audio]" });
+      }
     } else if (raw.type === "encrypted_content") {
       // codex-rs FunctionCallOutputContentItem::EncryptedContent — opaque to routed models.
       parts.push({ type: "text", text: "[encrypted content omitted]" });

package/src/responses/schema.ts

@@ -21,6 +21,16 @@ const inputFileBlockSchema = z.object({
   filename: z.string().optional(),
   file_data: z.string().optional(),
 });
+// codex-rs protocol/src/models.rs sends audio as input_audio with an audio_url, in
+// both user content and tool output. Accepting the block keeps a legitimate audio turn
+// out of the malformed-item catch-all. The translated IR records only its PRESENCE —
+// there is no audio carrier and no adapter-level refusal; a typed unsupported-modality
+// signal reaching final adapter dispatch remains a recorded residual.
+const inputAudioBlockSchema = z.object({
+  type: z.literal("input_audio"),
+  audio_url: z.string().min(1),
+  format: z.string().optional(),
+});
 const outputTextSchema = z.object({ type: z.literal("output_text"), text: z.string() });
 const outputRefusalSchema = z.object({ type: z.literal("refusal"), refusal: z.string() });
 const summaryTextSchema = z.object({ type: z.literal("summary_text"), text: z.string() });
@@ -28,12 +38,12 @@ const reasoningTextSchema = z.object({ type: z.literal("reasoning_text"), text:
 // codex-rs FunctionCallOutputContentItem (protocol/src/models.rs): input_text | input_image | encrypted_content.
 const encryptedContentBlockSchema = z.object({ type: z.literal("encrypted_content"), encrypted_content: z.string() });
 
-const inputContentBlockSchema = z.union([inputTextSchema, plainTextSchema, inputImageBlockSchema, inputVideoBlockSchema, inputFileBlockSchema]);
+const inputContentBlockSchema = z.union([inputTextSchema, plainTextSchema, inputImageBlockSchema, inputVideoBlockSchema, inputAudioBlockSchema, inputFileBlockSchema]);
 const outputContentBlockSchema = z.union([outputTextSchema, plainTextSchema, outputRefusalSchema]);
 // Tool outputs on the wire mix codex-rs FunctionCallOutputContentItem with legacy output blocks.
 const toolOutputContentBlockSchema = z.union([
   outputTextSchema, plainTextSchema, outputRefusalSchema,
-  inputTextSchema, inputImageBlockSchema, encryptedContentBlockSchema,
+  inputTextSchema, inputImageBlockSchema, inputAudioBlockSchema, encryptedContentBlockSchema,
 ]);
 const toolOutputSchema = z.union([z.string(), z.array(toolOutputContentBlockSchema)]);
 

package/src/server/audio-live.ts

@@ -100,7 +100,7 @@ export async function handleExternalLive(
       ? frameless ? forwardLiveUrl(relay.providerBaseUrl, false) : keyedLiveUrl(relay.providerBaseUrl)
       : forwardLiveUrl(relay.providerBaseUrl, true);
     const upstream = await fetch(url, { method: "POST", headers, body, signal: deadline.signal, redirect: "manual" });
-    outcome = upstream.ok ? 502 : upstream.status;
+    outcome = upstream.status;
     const detach = cancelBodyOnAbort(upstream.body, deadline.signal);
     let responseBody: ArrayBuffer | Response;
     try { responseBody = await readBodyCapped(upstream.body, LIVE_RESPONSE_MAX_BYTES, () => "Live answer too large", deadline.signal); }
@@ -122,7 +122,6 @@ export async function handleExternalLive(
       sidebandBaseUrl: config.experimentalRealtimeWsBaseUrl,
     });
     if (!alias) return formatErrorResponse(503, "server_busy", "Live call could not be registered");
-    outcome = upstream.status;
     return new Response(responseBody, { status: upstream.status, headers: {
       "content-type": upstream.headers.get("content-type") ?? "application/sdp",
       location: `/v1/${frameless ? "live" : "realtime/calls"}/${alias}`,

package/src/server/audio-transcriptions.ts

@@ -117,7 +117,7 @@ async function transcribeAdmitted(
       form.append("response_format", "json");
     }
     const upstream = await fetch(url, { method: "POST", headers, body: form, signal: signal.signal, redirect: "manual" });
-    outcome = upstream.ok ? 502 : upstream.status;
+    outcome = upstream.status;
     const detach = cancelBodyOnAbort(upstream.body, signal.signal);
     let body: ArrayBuffer | Response;
     try {
@@ -137,7 +137,6 @@ async function transcribeAdmitted(
     if (!payload || typeof payload !== "object" || !("text" in payload) || typeof payload.text !== "string") {
       return formatErrorResponse(502, "upstream_error", "Audio upstream response is missing text");
     }
-    outcome = upstream.status;
     return input.format === "text"
       ? new Response(payload.text, { headers: { "content-type": "text/plain; charset=utf-8" } })
       : Response.json({ text: payload.text });

package/src/server/auth-cors.ts

@@ -766,7 +766,7 @@ export function providerManagementConfigError(
   if (requestPacingError) {
     return `provider ${JSON.stringify(redactSecretString(name))} ${requestPacingError}`;
   }
-  const webSearchBridgeError = providerWebSearchBridgeConfigError(raw.webSearchBridge);
+  const webSearchBridgeError = providerWebSearchBridgeConfigError(raw.webSearchBridge, name, typed);
   if (webSearchBridgeError) {
     return `provider ${JSON.stringify(redactSecretString(name))} ${webSearchBridgeError}`;
   }

package/src/server/background-lifecycle.ts

@@ -11,6 +11,11 @@ import {
   stopStorageCleanupScheduler,
 } from "../storage/policy-scheduler";
 import { startQuotaResetPoller, stopQuotaResetPoller } from "../quota/reset-poller";
+import {
+  startCatalogAutoRefresh,
+  stopCatalogAutoRefresh,
+  syncCatalogAutoRefreshCadence,
+} from "../codex/catalog-auto-refresh";
 import {
   cancelQueuedStorageWorkerSpawns,
   drainStorageWorkers,
@@ -70,6 +75,17 @@ function startProcessLoops(applyPolicy: PolicyApply): ProcessLoops {
       .catch(() => {
         // The next tick adopts it.
       });
+    // Opt-in: the tick is a no-op unless catalogAutoRefresh.enabled is true, and the
+    // interval is unref'd, so a default install pays one dormant timer. The scheduler
+    // module keeps every heavy import inside its tick, so naming it statically here
+    // costs a module record and nothing else.
+    startCatalogAutoRefresh();
+    // The scheduler starts at its default cadence because resolving the operator's value
+    // reads the config barrel. Fire-and-forget: startup must not await an optional
+    // subsystem, and the next tick adopts the cadence anyway.
+    void syncCatalogAutoRefreshCadence().catch(() => {
+      // The next tick adopts it.
+    });
     // Install the delivery sink now rather than waiting out the first poll interval, which is 15
     // minutes by default. Without this, an enabled install would observe nothing for its first
     // quarter hour — including the live request path, which is gated on the sink existing.
@@ -85,6 +101,7 @@ function startProcessLoops(applyPolicy: PolicyApply): ProcessLoops {
     stateStoreSweeper?.stop();
     stopStorageCleanupScheduler();
     stopQuotaResetPoller();
+    stopCatalogAutoRefresh();
     setLivePolicyOwner(null);
     throw error;
   }
@@ -97,6 +114,7 @@ function stopProcessLoops(): void {
   loops?.stateStoreSweeper.stop();
   stopStorageCleanupScheduler();
   stopQuotaResetPoller();
+  stopCatalogAutoRefresh();
   setLivePolicyOwner(null);
 }
 

package/src/server/chat-completions.ts

@@ -11,6 +11,7 @@ import {
   ChatCompletionsRequestError,
   chatCompletionsToResponsesBody,
 } from "../chat/inbound";
+import { normalizeChatImageParts } from "../chat/image-parts";
 import {
   chatCompletionsErrorResponse,
   collectChatCompletion,
@@ -111,7 +112,11 @@ async function handleChatCompletionsWithBudget(
   try {
     const rawBody = await readChatBody(req, translatorBudget, resolveInboundBodyLimitBytes(config.maxInboundBodyBytes));
     assertChatCompletionsRoutingBody(rawBody);
-    chatBody = rawBody;
+    // Normalize foreign image shapes BEFORE routing. isNativeChatRouteEligible below
+    // decides the pipeline from the image parts it can see, and the native path then
+    // forwards this body as-is, so both must observe the same parts. A body with no
+    // foreign image part is returned by reference and stays byte-identical.
+    chatBody = normalizeChatImageParts(rawBody);
   } catch (err) {
     const overflow = isTranslatorBudgetExceededError(err);
     const status = overflow ? 413 : err instanceof ChatCompletionsRequestError ? 400 : 500;
@@ -165,7 +170,7 @@ async function handleChatCompletionsWithBudget(
       if (chatBody.tools !== undefined) parts.push(JSON.stringify(chatBody.tools));
       logCtx.usageLogInputTokens = Math.max(1, estimateTokens(parts.join("\n"), requestedModel));
     }
-    if (!effortRow && isNativeChatRouteEligible(route, chatBody)) chatNativeRoute = route;
+    if (!effortRow && isNativeChatRouteEligible(route, chatBody, config)) chatNativeRoute = route;
   } catch (err) {
     if (err instanceof UnknownRoutingPolicyError) {
       logCtx.requestedModel = requestedModel;
@@ -221,13 +226,23 @@ async function handleChatCompletionsWithBudget(
   // for non-streaming clients. Native Chat uses the caller's original stream bit.
   internalBody.stream = true;
   if (settledRoute?.provider.adapter === "openai-responses") {
-    // ChatGPT backend rejects store:true and unsupported sampling knobs.
+    // The proxy never wants upstream-side retention for a translated Chat turn, so
+    // store stays pinned for every Responses route.
+    //
+    // The sampling and output-cap restrictions used to be applied here too, keyed on
+    // the adapter string. That was wrong twice over. Seven providers share this
+    // adapter (openai, openai-apikey, meta-model, meta-muse, zai,
+    // zhipu-bigmodel-responses, volcengine-agent-plan), so a generic key gateway lost
+    // controls it accepts. And settledRoute is the route settled at INGRESS: a combo
+    // or policy route resolves its concrete child later in the Responses pipeline, so
+    // deciding here mutates shared intent before the real target is known — a
+    // canonical-first combo that falls back to a key gateway had already lost the
+    // caller's controls, while a non-canonical-first combo that falls back to
+    // canonical still shipped them.
+    //
+    // Canonical-backend sanitization now happens at the final outgoing body in
+    // src/adapters/openai-responses.ts, where the concrete provider is known.
     internalBody.store = false;
-    delete internalBody.max_output_tokens;
-    delete internalBody.temperature;
-    delete internalBody.top_p;
-    delete internalBody.stop;
-    delete internalBody.user;
   } else if (internalBody.store === undefined) {
     internalBody.store = false;
   }