@bitkyc08/opencodex 2.43.0 → 2.44.0

package/src/responses/function-call-compat.ts

@@ -0,0 +1,173 @@
+import { coerceIntegerToolArguments } from "../lib/tool-argument-integers";
+import { namespacedToolName } from "../types/tools";
+import { rewriteRoutedNamespaceToolsForUpstream } from "./namespace-tool-compat";
+import { collectResponsesToolGroups } from "./tool-groups";
+
+export interface FunctionCallRepairSchema {
+  name: string;
+  namespace?: string;
+  parameters?: Record<string, unknown>;
+}
+
+/** Keys are canonical original identities, never a bare-name fallback for a namespace. */
+export type FunctionCallRepairSchemas = ReadonlyMap<string, FunctionCallRepairSchema>;
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** JSON object member order is immaterial; array elements retain their exact order. */
+function sameSchemaValue(left: unknown, right: unknown): boolean {
+  if (left === right) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length
+      && left.every((value, index) => sameSchemaValue(value, right[index]));
+  }
+  if (!isObject(left) || !isObject(right)) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length
+    && keys.every(key => Object.hasOwn(right, key) && sameSchemaValue(left[key], right[key]));
+}
+
+function namespaceOf(value: unknown): string | undefined {
+  return typeof value === "string" && value !== "functions" ? value : undefined;
+}
+
+function selectorAllows(
+  selector: unknown,
+  lowered: unknown,
+  wireName: string,
+  identity: FunctionCallRepairSchema,
+): boolean {
+  if (!isObject(selector) || selector.type !== "function" || typeof selector.name !== "string") return false;
+  if ("namespace" in selector) {
+    if (typeof selector.namespace !== "string" || selector.namespace.length === 0) return false;
+    return namespaceOf(selector.namespace) === identity.namespace && selector.name === identity.name;
+  }
+  return isObject(lowered) && lowered.type === "function" && lowered.name === wireName;
+}
+
+/** Caller supplies currentTurnWireToolCatalogBody BEFORE provider schema lowering. */
+export function collectFunctionCallRepairSchemas(body: unknown): Map<string, FunctionCallRepairSchema> {
+  const schemas = new Map<string, FunctionCallRepairSchema>();
+  if (!isObject(body)) return schemas;
+  const groups = collectResponsesToolGroups(body);
+  if (Array.isArray(body.input)) {
+    for (const entry of body.input) {
+      if (isObject(entry) && entry.type === "tool_search_output" && Array.isArray(entry.tools)) groups.push(entry.tools);
+    }
+  }
+  // Reuse namespace selector resolution, retaining schemas from the original objects below.
+  // This local catalog view includes loaded definitions without revisiting replay history or
+  // teaching the shared tool-group collector a new transport-wide interpretation.
+  const lowered = rewriteRoutedNamespaceToolsForUpstream({ ...body, tools: groups.flat(), input: [] }).body;
+  const choice = body.tool_choice;
+  const loweredChoice = isObject(lowered) ? lowered.tool_choice : undefined;
+  const occupied = new Map<string, { kind: unknown; identity: FunctionCallRepairSchema } | null>();
+  const register = (tool: unknown, namespace?: string): void => {
+    if (!isObject(tool) || typeof tool.name !== "string" || tool.name.length === 0) return;
+    const identity: FunctionCallRepairSchema = {
+      name: tool.name,
+      ...(namespace ? { namespace } : {}),
+      ...(isObject(tool.parameters) ? { parameters: tool.parameters } : {}),
+    };
+    const key = namespacedToolName(namespace, tool.name);
+    if (occupied.has(key)) {
+      const previous = occupied.get(key);
+      // Conflicting duplicate declarations cannot choose a schema by insertion order.
+      if (!previous || previous.kind !== tool.type
+        || previous.identity.namespace !== namespace
+        || previous.identity.name !== tool.name
+        || !sameSchemaValue(previous.identity.parameters, identity.parameters)) {
+        occupied.set(key, null);
+      }
+    } else occupied.set(key, { kind: tool.type, identity });
+  };
+  for (const group of groups) {
+    for (const tool of group) {
+      if (!isObject(tool)) continue;
+      if (tool.type === "namespace") {
+        if (typeof tool.name !== "string" || !tool.name || !Array.isArray(tool.tools)) continue;
+        for (const child of tool.tools) register(child, namespaceOf(tool.name));
+      } else if (tool.type === "function" && isObject(tool.function)) {
+        register({ ...tool.function, type: "function" });
+      } else register(tool);
+    }
+  }
+  for (const [key, entry] of occupied) {
+    if (!entry || entry.kind !== "function") continue;
+    let allowed = choice === undefined || choice === "auto" || choice === "required";
+    if (isObject(choice)) {
+      if (choice.type === "allowed_tools" && Array.isArray(choice.tools)) {
+        const selectors = isObject(loweredChoice) && Array.isArray(loweredChoice.tools) ? loweredChoice.tools : [];
+        allowed = choice.tools.some((selector, index) => selectorAllows(selector, selectors[index], key, entry.identity));
+      } else allowed = selectorAllows(choice, loweredChoice, key, entry.identity);
+    }
+    if (allowed) schemas.set(key, entry.identity);
+  }
+  return schemas;
+}
+
+function repairItem(item: unknown, schemas: FunctionCallRepairSchemas, completed: boolean): unknown {
+  if (!isObject(item) || item.type !== "function_call" || typeof item.name !== "string"
+    || typeof item.arguments !== "string") return item;
+  if (item.status !== "completed" && !(item.status === undefined && completed)) return item;
+  if ("namespace" in item && (typeof item.namespace !== "string" || !item.namespace)) return item;
+  const namespace = namespaceOf(item.namespace);
+  const schema = schemas.get(namespacedToolName(namespace, item.name));
+  if (!schema) return item;
+  // An explicit namespace is an identity coordinate, not another spelling to guess at.
+  if ("namespace" in item && (schema.namespace !== namespace || schema.name !== item.name)) return item;
+  const raw = item.arguments;
+  if (raw !== "") {
+    try {
+      let unsafe = false;
+      JSON.parse(raw, (_key, value: unknown) => {
+        if (typeof value === "number" && (!Number.isFinite(value)
+          || (Number.isInteger(value) && !Number.isSafeInteger(value)))) unsafe = true;
+        return value;
+      });
+      // Re-stringifying another repaired field must not round an unsafe sibling number.
+      if (unsafe) return item;
+    } catch { return item; }
+  }
+  const argumentsText = coerceIntegerToolArguments(raw || "{}", schema.parameters, schema.namespace ? undefined : schema.name);
+  return argumentsText === raw ? item : { ...item, arguments: argumentsText };
+}
+
+/** Only executable completion slots are visited; metadata and custom input are opaque. */
+export function repairFunctionCalls(
+  value: unknown,
+  schemas: FunctionCallRepairSchemas,
+): { value: unknown; changed: boolean } {
+  if (schemas.size === 0 || !isObject(value)) return { value, changed: false };
+  if (typeof value.status === "string" && ["failed", "incomplete", "cancelled", "in_progress", "queued"].includes(value.status)) return { value, changed: false };
+  let next: unknown = value;
+  if (value.type === "function_call") next = repairItem(value, schemas, false);
+  else if (value.type === "response.output_item.done") {
+    const item = repairItem(value.item, schemas, true);
+    if (item !== value.item) next = { ...value, item };
+  } else if (value.type === "response.completed" && isObject(value.response)) {
+    const response = value.response;
+    if ((response.status === undefined || response.status === "completed") && Array.isArray(response.output)) {
+      const original = response.output;
+      const output = original.map(item => repairItem(item, schemas, true));
+      if (output.some((item, index) => item !== original[index])) next = { ...value, response: { ...response, output } };
+    }
+  } else if (typeof value.type !== "string" || !value.type.startsWith("response.")) {
+    if (Array.isArray(value.output)) {
+      const original = value.output;
+      const output = original.map(item => repairItem(item, schemas, value.status === "completed"));
+      if (output.some((item, index) => item !== original[index])) next = { ...value, output };
+    }
+  }
+  return { value: next, changed: next !== value };
+}
+
+export function repairFunctionCallsInJson(text: string, schemas: FunctionCallRepairSchemas): string {
+  if (schemas.size === 0) return text;
+  let payload: unknown;
+  try { payload = JSON.parse(text); } catch { return text; }
+  const repaired = repairFunctionCalls(payload, schemas);
+  return repaired.changed ? JSON.stringify(repaired.value) : text;
+}

package/src/responses/namespace-tool-compat.ts

@@ -1,5 +1,6 @@
-import { namespacedToolName } from "../types";
+import { dottedToolName, namespacedToolName } from "../types";
 import { collectResponsesToolGroups } from "./tool-groups";
+import { collectAmbiguousDottedAliases, dottedAliasIsUnambiguous } from "./tool-name-aliases";
 
 export interface RoutedNamespaceToolIdentity {
   namespace: string;
@@ -340,7 +341,10 @@ function rewriteInputItem(item: unknown, plan: NamespaceRewritePlan, emitted: Se
  * `<namespace>__<name>` wire identity as the chat adapters. The returned request-local aliases
  * are the only names response restoration is allowed to expand.
  */
-export function rewriteRoutedNamespaceToolsForUpstream(body: unknown): {
+export function rewriteRoutedNamespaceToolsForUpstream(
+  body: unknown,
+  convertedCustomToolNames?: ReadonlySet<string>,
+): {
   body: unknown;
   aliases: Map<string, RoutedNamespaceToolIdentity>;
 } {
@@ -365,6 +369,21 @@ export function rewriteRoutedNamespaceToolsForUpstream(body: unknown): {
   }
 
   const toolChoice = rewriteToolChoice(body.tool_choice, plan);
+  const aliases = authorizedAliases(plan.aliases, toolChoice);
+  const ambiguousDotted = collectAmbiguousDottedAliases(groups);
+  // Authorize canonical identities first, then add only unambiguous spellings.
+  // Selection cannot hide a collision elsewhere in the original declaration set.
+  for (const identity of [...aliases.values()]) {
+    const dotted = dottedToolName(identity.namespace, identity.name);
+    if (dottedAliasIsUnambiguous(identity.namespace, identity.name)
+      && !ambiguousDotted.has(dotted) && !plan.bareWireNames.has(dotted)
+      && !aliases.has(dotted)) aliases.set(dotted, identity);
+  }
+  // The adapter lowers custom tools before namespaces. Preserve their declared
+  // kind only in already-authorized response aliases; wire selectors remain lowered.
+  for (const identity of aliases.values()) {
+    if (convertedCustomToolNames?.has(namespacedToolName(identity.namespace, identity.name))) identity.kind = "custom";
+  }
   return {
     body: {
       ...body,
@@ -372,7 +391,7 @@ export function rewriteRoutedNamespaceToolsForUpstream(body: unknown): {
       ...(input !== body.input ? { input } : {}),
       ...(toolChoice !== body.tool_choice ? { tool_choice: toolChoice } : {}),
     },
-    aliases: authorizedAliases(plan.aliases, toolChoice),
+    aliases,
   };
 }
 
@@ -404,7 +423,11 @@ export function restoreRoutedNamespaceCalls(
     && typeof value.name === "string"
   ) {
     const identity = aliases.get(value.name);
-    if (identity) {
+    if (identity
+      // Custom declarations may be lowered to function calls upstream, but an
+      // ordinary function declaration never authorizes a custom call payload.
+      && (value.type !== "custom_tool_call" || identity.kind === "custom")
+      && (!Object.hasOwn(value, "namespace") || value.namespace === identity.namespace)) {
       restored.name = identity.name;
       restored.namespace = identity.namespace;
       changed = true;

package/src/responses/parser.ts

@@ -25,6 +25,7 @@ import { toolSearchDescription, toolSearchParameters } from "./tool-search-compa
 import { isObj, inputContentParts, outputTextOf, outputToToolResultContent, toolOutputContainsEncryptedContent } from "./parser-content";
 import { mapToolChoice, buildTools, customToolNamespaces } from "./parser-tools";
 import { parseTextFormat } from "./parser-text-format";
+import { externalTaskInputContent } from "./task-input";
 
 /**
  * Wrap a remembered proxy-side signature as provider metadata for a replayed tool call.
@@ -146,6 +147,7 @@ export function parseRequest(
       const item = data.input[inputIndex];
       const effectiveType = (item as { type?: string }).type ?? ("role" in item ? "message" : undefined);
       const itemRole = (item as { role?: string }).role;
+      const externalTaskInput = effectiveType === "function_call_output" ? externalTaskInputContent(item) : undefined;
       // Raw protocol items do not map one-to-one onto context messages. Capture the boundary while
       // both representations are available so later metadata can stay before conversation in both.
       if (
@@ -154,6 +156,7 @@ export function parseRequest(
         && continuationConversationMessageIndex === undefined
         && (
           effectiveType === "agent_message"
+          || externalTaskInput !== undefined
           || (effectiveType === "message" && (itemRole === "user" || itemRole === "assistant"))
         )
       ) {
@@ -429,6 +432,11 @@ export function parseRequest(
       }
 
       if (effectiveType === "function_call_output") {
+        if (externalTaskInput !== undefined) {
+          pendingReasoning.length = 0;
+          messages.push({ role: "user", content: externalTaskInput, timestamp: now });
+          continue;
+        }
         const output = item as { call_id: string; output?: string | unknown[] };
         attachPendingReasoningToCallOwner(messages, output.call_id, pendingReasoning);
         pendingReasoning.length = 0;

package/src/responses/task-input.ts

@@ -0,0 +1,36 @@
+import type { OcxContentPart } from "../types";
+import { inputContentParts, isObj } from "./parser-content";
+
+type TaskInputBlock =
+  | { type: "input_text" | "output_text" | "text"; text: string }
+  | { type: "input_image"; image_url: string; detail?: string };
+
+const imageDetails = new Set(["auto", "low", "high", "original"]);
+
+function nonBlank(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function supportedBlock(value: unknown): value is TaskInputBlock {
+  if (!isObj(value)) return false;
+  if (value.type === "input_text" || value.type === "output_text" || value.type === "text") {
+    return typeof value.text === "string";
+  }
+  if (value.type !== "input_image" || !nonBlank(value.image_url)) return false;
+  return value.detail === undefined || (typeof value.detail === "string" && imageDetails.has(value.detail));
+}
+
+/** Recognize Codex external task input without repairing ordinary orphaned tool results. */
+export function externalTaskInputContent(item: unknown): string | OcxContentPart[] | undefined {
+  if (!isObj(item) || item.type !== "function_call_output" || "call_id" in item) return undefined;
+  if (!nonBlank(item.id) || !nonBlank(item.name) || !nonBlank(item.namespace)) return undefined;
+  const output = item.output;
+  if (typeof output === "string") return nonBlank(output) ? output : undefined;
+  if (!Array.isArray(output) || output.length === 0 || !output.every(supportedBlock)) return undefined;
+  if (!output.some(block => block.type === "input_image" || nonBlank(block.text))) return undefined;
+  // Validate the entire array first: the general converter intentionally drops unknown
+  // blocks, while a partial external task would silently lose the caller's input.
+  return inputContentParts(output.map(block =>
+    block.type === "output_text" ? { ...block, type: "input_text" } : block,
+  ));
+}

package/src/responses/tool-name-aliases.ts

@@ -0,0 +1,79 @@
+import { dottedToolName, namespacedToolName } from "../types";
+
+const BUILTIN_FUNCTIONS_NAMESPACE = "functions";
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * A dotted spelling is a safe alias only when it cannot ALSO be read as some other identity's
+ * canonical `ns__name`.
+ *
+ * `{namespace: "x__y", name: "z"}` produces the dotted spelling "x__y.z", which is exactly the
+ * canonical wire name of `{namespace: "x", name: "y.z"}`. If only the latter is declared, an
+ * echoed call for the former would still find "x__y.z" in the declared set and be authorized as
+ * a tool the caller never granted. Requiring both halves to be free of the `__` separator keeps
+ * a dotted alias from ever impersonating a canonical name.
+ */
+export function dottedAliasIsUnambiguous(namespace: string, name: string): boolean {
+  return !namespace.includes("__") && !name.includes("__");
+}
+
+export function wireToolInnerName(tool: unknown): string | undefined {
+  if (!isPlainObject(tool)) return undefined;
+  const nestedFunction = tool.type === "function" && isPlainObject(tool.function)
+    ? tool.function
+    : undefined;
+  return typeof tool.name === "string" && tool.name.length > 0
+    ? tool.name
+    : typeof nestedFunction?.name === "string" && nestedFunction.name.length > 0
+      ? nestedFunction.name
+      : undefined;
+}
+
+/**
+ * Dotted aliases that more than one declared identity would claim, plus dotted aliases that
+ * collide with a canonical or bare declared name.
+ *
+ * Resolved over the WHOLE catalog before any name is registered, so which identity "wins" can
+ * never depend on declaration order -- an order the caller controls.
+ */
+export function collectAmbiguousDottedAliases(specGroups: readonly unknown[]): Set<string> {
+  const owners = new Map<string, string | null>();
+  const claim = (alias: string, identity: string): void => {
+    const owner = owners.get(alias);
+    if (owner === undefined) owners.set(alias, identity);
+    else if (owner !== identity) owners.set(alias, null);
+  };
+  for (const specs of specGroups) {
+    if (!Array.isArray(specs)) continue;
+    for (const spec of specs) {
+      if (!isPlainObject(spec)) continue;
+      if (spec.type === "namespace" && Array.isArray(spec.tools)) {
+        const namespace = typeof spec.name === "string" ? spec.name : undefined;
+        if (!namespace) continue;
+        for (const inner of spec.tools) {
+          const name = wireToolInnerName(inner);
+          if (!name) continue;
+          if (namespace === BUILTIN_FUNCTIONS_NAMESPACE) {
+            claim(name, JSON.stringify([undefined, name]));
+            continue;
+          }
+          const identity = JSON.stringify([namespace, name]);
+          claim(dottedToolName(namespace, name), identity);
+          // A canonical or bare name already owned by a different identity poisons the dotted
+          // alias that would shadow it.
+          claim(namespacedToolName(namespace, name), identity);
+          claim(name, identity);
+        }
+        continue;
+      }
+      const name = wireToolInnerName(spec);
+      if (name) claim(name, JSON.stringify([undefined, name]));
+    }
+  }
+  const ambiguous = new Set<string>();
+  for (const [alias, owner] of owners) if (owner === null) ambiguous.add(alias);
+  return ambiguous;
+}
+

package/src/router.ts

@@ -10,6 +10,7 @@ import {
 import type { NormalizedComboConfig } from "./combos/types";
 import { hasOwnProvider } from "./config/provider-name";
 import { providerUsesKeyAuthOverride, resolveProviderApiKey } from "./providers/key-store";
+import { captureProviderApiKeySelection } from "./providers/api-key-selection";
 import { assertProviderDestinationAllowed } from "./lib/destination-policy";
 import { redactSecretString, redactUrlForLog } from "./lib/redact";
 import {
@@ -297,6 +298,7 @@ function usableResolvedApiKey(apiKey: string | undefined): string | undefined {
 }
 
 export function routedProviderConfig(providerName: string, provider: OcxProviderConfig): OcxProviderConfig {
+  provider = { ...provider, _apiKeyAttempt: provider._apiKeyAttempt ?? captureProviderApiKeySelection(provider) };
   const registryEntry = PROVIDER_REGISTRY.find(entry => entry.id === providerName);
   if (!registryEntry || !providerMatchesRegistryTransportWithStaticGuards(providerName, provider)) {
     assertProviderDestinationAllowed(providerName, provider);

package/src/routing/capability.ts

@@ -10,7 +10,7 @@
  * how that affects eligibility.
  */
 
-import { modelInList, type OcxConfig } from "../types";
+import { modelInList, type OcxConfig, type OcxProviderConfig } from "../types";
 import { isCanonicalOpenAiForwardProvider, OPENAI_CODEX_PROVIDER_ID } from "../providers/openai-tiers";
 import { serviceTierSupportForModel } from "../providers/service-tier";
 import { PROVIDER_REGISTRY } from "../providers/registry";
@@ -149,14 +149,20 @@ function localRemoteEvidence(baseUrl: string | undefined): Pick<RouteCapabilityE
  * Assemble canonical capability evidence for one `provider/model` candidate.
  * Sources (in priority order): provider config maps, provider registry hints,
  * cached Codex catalog row, native-model metadata.
+ * Policy assembly supplies the resolved provider so every transport capability
+ * describes the destination dispatch will use. Its maps already include applicable
+ * registry defaults; name-only registry fallbacks must not override that authority.
  */
 export function candidateCapabilityEvidence(
   config: OcxConfig,
   providerName: string,
   modelId: string,
+  resolvedProvider?: OcxProviderConfig,
 ): RouteCapabilityEvidence {
-  const provider = config.providers[providerName];
-  const registryEntry = PROVIDER_REGISTRY.find(entry => entry.id === providerName);
+  const provider = resolvedProvider ?? config.providers[providerName];
+  const registryEntry = resolvedProvider === undefined
+    ? PROVIDER_REGISTRY.find(entry => entry.id === providerName)
+    : undefined;
   const catalogRow = cachedCatalogModels().find(model => model.provider === providerName && model.id === modelId);
   const isNative = providerName === OPENAI_CODEX_PROVIDER_ID && !modelId.includes("/");
 
@@ -224,6 +230,7 @@ export function candidateCapabilityEvidence(
     ? []
     : modelRecordValue(provider?.modelReasoningEfforts, modelId)
       ?? modelRecordValue(registryEntry?.modelReasoningEfforts, modelId)
+      ?? provider?.reasoningEfforts
       ?? (isNative ? nativeReasoningEfforts(modelId) : undefined);
 
   const tierSupport = provider

package/src/routing/compatibility/assemble.ts

@@ -52,11 +52,26 @@ export function assemblePolicyCandidateEvidence(
   return profile.candidates.map(candidate => {
     const key = `${candidate.provider}/${candidate.model}`;
     const compatibility = compatibilityByCandidate?.get(key);
+    const provider = config.providers[candidate.provider];
+    let routed: OcxProviderConfig | undefined;
+    let routeResolutionFailed = !provider || provider.disabled === true;
+    if (provider && provider.disabled !== true) {
+      try {
+        routed = options.routedProviderConfig(candidate.provider, provider);
+      } catch {
+        // This is known unavailability, not unknown capability evidence. Keep
+        // the failure separate so permissive unknown policies cannot select it.
+        routeResolutionFailed = true;
+      }
+    }
 
     return {
       provider: candidate.provider,
       model: candidate.model,
-      capability: candidateCapabilityEvidence(config, candidate.provider, candidate.model),
+      ...(routeResolutionFailed ? { routeResolutionFailed: true } : {}),
+      capability: routed
+        ? candidateCapabilityEvidence(config, candidate.provider, candidate.model, routed)
+        : undefined,
       health: policyCandidateHealthEvidence(config, candidate, now),
       quota: quotaEvidenceForCandidate({
         provider: candidate.provider,

package/src/routing/evaluator.ts

@@ -54,6 +54,8 @@ export interface PolicyCandidateEvidence {
   accountRef?: string;
   /** Codex pool account id (provider "openai"); used to derive account-scoped quota evidence. */
   codexAccountId?: string;
+  /** A failed effective-transport resolution excludes the candidate under every unknown policy. */
+  routeResolutionFailed?: boolean;
   capability?: RouteCapabilityEvidence;
   health?: RouteHealthEvidence;
   quota?: RouteQuotaEvidence;
@@ -278,6 +280,8 @@ export function evaluatePolicyProfile(
       ...requestRequirementFor(requestEvidence, evidence.capability),
     ];
     const exclusions: RouteExclusionReason[] = [];
+    const routeUnavailable = evidence.routeResolutionFailed === true;
+    if (routeUnavailable) exclusions.push({ code: "route-unavailable" });
     const bad = unsatisfiedOrUnknown(requirements);
     for (const requirement of bad) {
       if (requirement.outcome === "unsatisfied") {
@@ -310,7 +314,7 @@ export function evaluatePolicyProfile(
     if (unknownCostBlocked) {
       exclusions.push({ code: "cost-limit-unknown", detail: "maxEstimatedCostUsd" });
     }
-    let eligible = !unsatisfied && !excludedByUnknown && !overCostLimit && !unknownCostBlocked;
+    let eligible = !routeUnavailable && !unsatisfied && !excludedByUnknown && !overCostLimit && !unknownCostBlocked;
 
     // Trace/dry-run copy only: report the profile cap that was applied and the
     // operator-visible outcome. Do not feed this copy into costScore() — that

package/src/server/auth-cors.ts

@@ -530,6 +530,7 @@ export function requireResponsesApiAuth(req: Request, config: RequestPolicyView)
 const FORBIDDEN_PROVIDER_RUNTIME_FIELDS = [
   "virtualModels", "codexAuthContext", "selectedForwardHeaders",
   "sidecarOutcomeRecorder", "_codexAccountOverride", "_codexAccountRequired",
+  "_apiKeyAttempt",
 ] as const;
 
 function sameCanonicalProviderSeed(actual: Record<string, unknown>, expected: OcxProviderConfig): boolean {
@@ -795,6 +796,8 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   apiKey: "redacted",
   apiKeyTransport: "editor",
   apiKeyPool: "redacted",
+  apiKeySelectionRevision: "runtime",
+  _apiKeyAttempt: "runtime",
   defaultModel: "editor",
   models: "editor",
   liveModels: "editor",

package/src/server/chat-native.ts

@@ -37,6 +37,8 @@ import {
   transientRetryPolicyFor,
 } from "../providers/key-failover";
 import { fastPolicyForModel } from "../providers/service-tier";
+import { providerApiKeySelectionIsCurrent, resolveCurrentProviderApiKeyTransport } from "../providers/api-key-selection";
+import type { OcxProviderTransport } from "../providers/xai-transport";
 import type { RouteResult } from "../router";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 import { fetchWithHeaderTimeout, providerFetch, safeHostLabel } from "./responses/fetch-helpers";
@@ -46,6 +48,7 @@ import {
   beginRequestAttempt,
   noteAttemptSend,
   recordFirstOutput,
+  recordAttemptCredentialSource,
   sealRequestAttemptIdentity,
   type RequestLogContext,
 } from "./request-log";
@@ -183,14 +186,17 @@ export async function handleNativeChatCompletions(options: HandleNativeChatOptio
     translatorBudget.chargeRetained(bytes, { kind: "request_copies" });
     retainedRequestBytes = bytes;
   };
-  const buildActiveRequest = () => buildOpenAIChatPassthroughRequest(
-    activeProvider,
-    options.chatBody,
-    route.modelId,
-    requestedStream,
-    fastPolicyForModel(activeProvider, route.modelId, route.providerName, "chat"),
-    config.fastMode,
-  );
+  const buildActiveRequest = () => {
+    recordAttemptCredentialSource(attempt, route.providerName, activeProvider, activeAdapter.name);
+    return buildOpenAIChatPassthroughRequest(
+      activeProvider,
+      options.chatBody,
+      route.modelId,
+      requestedStream,
+      fastPolicyForModel(activeProvider, route.modelId, route.providerName, "chat"),
+      config.fastMode,
+    );
+  };
   try {
     activeRequest = buildActiveRequest();
     retainRequest(activeRequest);
@@ -224,7 +230,6 @@ export async function handleNativeChatCompletions(options: HandleNativeChatOptio
       const fetchWithPolicy = requestTransientPolicy ? fetchWithTransientRetry : fetchWithResetRetry;
       return await fetchWithPolicy(
         (transportRecovery?: UpstreamSendRecovery) => {
-          noteAttemptSend(attempt, logCtx.usageLogInputTokens, transportRecovery ?? recovery);
           return fetchWithHeaderTimeout(
             request.url,
             applyUpstreamRecoveryInit({
@@ -238,6 +243,32 @@ export async function handleNativeChatCompletions(options: HandleNativeChatOptio
             providerFetch(activeProvider, undefined, {
               providerName: route.providerName,
               modelId: route.modelId,
+              dispatchOverride: async (_input, init, execute) => {
+                if (!providerApiKeySelectionIsCurrent(config, route.providerName, activeProvider)) {
+                  const current = resolveCurrentProviderApiKeyTransport(config, route.providerName, activeProvider);
+                  if (!current || !isNativeChatRouteEligible({ ...route, provider: current }, options.chatBody)) {
+                    throw new Error("Provider key selection is no longer available for native Chat");
+                  }
+                  activeProvider = current;
+                  activeAdapter = createOpenAIChatAdapter(current);
+                  activeRequest.releaseBodyObservation?.();
+                  releaseRetainedRequest();
+                  activeRequest = buildActiveRequest();
+                  try { retainRequest(activeRequest); }
+                  catch (error) { activeRequest.releaseBodyObservation?.(); throw error; }
+                }
+                // The retry closure may still hold a pre-pacing request. Replace its entire
+                // wire shape, not just Authorization, and retain transport recovery flags.
+                request = activeRequest;
+                const headers = new Headers(request.headers);
+                const encoding = new Headers(init.headers).get("accept-encoding");
+                if (!headers.has("accept-encoding") && encoding) headers.set("accept-encoding", encoding);
+                if (init.signal?.aborted) throw init.signal.reason;
+                noteAttemptSend(attempt, logCtx.usageLogInputTokens, transportRecovery ?? recovery);
+                return ((activeProvider as OcxProviderTransport).fetch ?? execute)(request.url, applyUpstreamRecoveryInit({
+                  ...init, method: request.method, headers, body: request.body,
+                }, transportRecovery));
+              },
             }),
           );
         },
@@ -282,6 +313,7 @@ export async function handleNativeChatCompletions(options: HandleNativeChatOptio
         retryAfter: response.headers.get("retry-after"),
         now: Date.now(),
         attemptedKey: activeProvider.apiKey,
+        attemptedSelection: activeProvider._apiKeyAttempt,
         promptCacheKey: typeof options.chatBody.prompt_cache_key === "string" ? options.chatBody.prompt_cache_key : undefined,
       });
       if (!rotated) break;
@@ -302,6 +334,9 @@ export async function handleNativeChatCompletions(options: HandleNativeChatOptio
     cleanupAbort();
     upstream.abort();
     if (req.signal.aborted) return fail(499, "Client cancelled request", "client_cancelled");
+    if (isTranslatorBudgetExceededError(error)) {
+      return fail(413, "request translation buffer exceeded the safe limit", "request_too_large", "translation_buffer_limit");
+    }
     return fail(502, error instanceof Error ? error.message : String(error), "server_error");
   }
   releaseRetainedRequest();