@bitkyc08/opencodex 2.39.0 → 2.40.0

package/src/remote/protocol.ts

@@ -0,0 +1,109 @@
+import type { OcxConfig } from "../types/config";
+
+export const REMOTE_HUB_PROTOCOL = 1;
+export const MINIMUM_REMOTE_CLIENT_PROTOCOL = 1;
+
+export interface RemoteReadyMetadata {
+  protocol: number;
+  minimumClientProtocol: number;
+  managementUrl: string;
+  features?: string[];
+}
+
+export type RemoteProtocolCompatibility =
+  | { ok: true; metadata: RemoteReadyMetadata; features: Set<string> }
+  | { ok: false; reason: "invalid" | "hub-too-new" | "hub-too-old"; message: string };
+
+const INVALID_REMOTE_PROTOCOL_MESSAGE =
+  "OpenCodex hub returned invalid remote protocol metadata; upgrade or repair ocx on the hub.";
+
+function positiveSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+function managementOrigin(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+    if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) return null;
+    return parsed.origin;
+  } catch {
+    return null;
+  }
+}
+
+function observedManagementOrigin(req: Request): string | null {
+  try {
+    const requestUrl = new URL(req.url);
+    const host = req.headers.get("Host") ?? requestUrl.host;
+    return managementOrigin(`${requestUrl.protocol}//${host}`);
+  } catch {
+    return null;
+  }
+}
+
+export function readyProtocolMetadata(config: OcxConfig, req: Request): RemoteReadyMetadata {
+  const configured = config.runtimeRole === "hub"
+    ? managementOrigin(config.hub?.managementPublicOrigin)
+    : null;
+  const managementUrl = configured ?? observedManagementOrigin(req);
+  if (!managementUrl) throw new Error("Readiness request does not have an HTTP(S) management origin");
+  return {
+    protocol: REMOTE_HUB_PROTOCOL,
+    minimumClientProtocol: MINIMUM_REMOTE_CLIENT_PROTOCOL,
+    managementUrl,
+  };
+}
+
+export function parseRemoteReadyMetadata(value: unknown): RemoteReadyMetadata | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value as Record<string, unknown>;
+  if (!positiveSafeInteger(raw.protocol) || !positiveSafeInteger(raw.minimumClientProtocol)) return null;
+  if (raw.minimumClientProtocol > raw.protocol) return null;
+  const parsedManagementOrigin = managementOrigin(raw.managementUrl);
+  if (!parsedManagementOrigin) return null;
+  const features = raw.features;
+  if (features !== undefined && (
+    !Array.isArray(features)
+    || features.length > 64
+    || features.some(feature => typeof feature !== "string" || !feature || feature.length > 80 || /[\x00-\x1f\x7f]/.test(feature))
+    || new Set(features).size !== features.length
+  )) return null;
+  return {
+    protocol: raw.protocol,
+    minimumClientProtocol: raw.minimumClientProtocol,
+    managementUrl: parsedManagementOrigin,
+    ...(Array.isArray(features) ? { features: [...features] as string[] } : {}),
+  };
+}
+
+export function checkRemoteProtocolCompatibility(
+  value: unknown,
+  client: { protocol: number; minimumHubProtocol: number; features?: readonly string[] } = {
+    protocol: REMOTE_HUB_PROTOCOL,
+    minimumHubProtocol: MINIMUM_REMOTE_CLIENT_PROTOCOL,
+  },
+): RemoteProtocolCompatibility {
+  const metadata = parseRemoteReadyMetadata(value);
+  if (!metadata || !positiveSafeInteger(client.protocol) || !positiveSafeInteger(client.minimumHubProtocol)) {
+    return { ok: false, reason: "invalid", message: INVALID_REMOTE_PROTOCOL_MESSAGE };
+  }
+  if (client.protocol < metadata.minimumClientProtocol) {
+    return {
+      ok: false,
+      reason: "hub-too-new",
+      message: `OpenCodex hub requires remote protocol ${metadata.minimumClientProtocol}; this client supports protocol ${client.protocol}. Upgrade ocx on this client.`,
+    };
+  }
+  if (metadata.protocol < client.minimumHubProtocol) {
+    return {
+      ok: false,
+      reason: "hub-too-old",
+      message: `OpenCodex hub provides remote protocol ${metadata.protocol}; this client requires at least ${client.minimumHubProtocol}. Upgrade ocx on the hub.`,
+    };
+  }
+  const supported = new Set(client.features ?? []);
+  const features = new Set((metadata.features ?? []).filter(feature => supported.has(feature)));
+  return { ok: true, metadata, features };
+}

package/src/responses/citation-markers.ts

@@ -0,0 +1,101 @@
+/**
+ * ChatGPT-backend citation markers.
+ *
+ * The ChatGPT backend delimits inline citations with Unicode private-use characters:
+ *
+ *     \uE200 cite \uE202 turn1view0 \uE202 turn1view1 \uE201
+ *
+ * The desktop client renders that as source chips. The Codex TUI does not: it prints the
+ * codepoints literally, so the user sees "citeturn1view0turn1view1" in the answer and in
+ * the saved transcript (#3150).
+ *
+ * OpenCodex neither produces nor understands this grammar — it arrives as ordinary
+ * assistant text from a ChatGPT-derived backend (GitHub Copilot in the report). The proxy
+ * is the last place that can remove it before a client that cannot render it.
+ *
+ * Strip, do not translate. The `turnNviewN` ids are turn-scoped and opaque, and the
+ * response carries no mapping from them to a URL, so there is nothing to convert them
+ * into. Structured `url_citation` annotations are a separate path and are untouched.
+ */
+
+/** Opens a citation span. */
+export const CITATION_MARKER_START = "\uE200";
+/** Separates the `cite` keyword and each source reference inside a span. */
+export const CITATION_MARKER_SEPARATOR = "\uE202";
+/** Closes a citation span. */
+export const CITATION_MARKER_END = "\uE201";
+
+/** True when the text contains any of the three delimiters. Cheap pre-check. */
+export function hasCitationMarker(text: string): boolean {
+  return text.includes(CITATION_MARKER_START)
+    || text.includes(CITATION_MARKER_SEPARATOR)
+    || text.includes(CITATION_MARKER_END);
+}
+
+/**
+ * Remove every complete `START … END` span from a whole string.
+ *
+ * A START with no END is left alone rather than truncating the remainder: an unterminated
+ * marker is malformed input, and dropping everything after it would delete real answer
+ * text. A stray SEPARATOR or END outside a span is also left alone for the same reason —
+ * this function only removes what it can prove is a citation span.
+ */
+export function stripCitationMarkers(text: string): string {
+  if (!text.includes(CITATION_MARKER_START)) return text;
+  let out = "";
+  let index = 0;
+  for (;;) {
+    const start = text.indexOf(CITATION_MARKER_START, index);
+    if (start === -1) {
+      out += text.slice(index);
+      return out;
+    }
+    const end = text.indexOf(CITATION_MARKER_END, start + 1);
+    if (end === -1) {
+      // Unterminated: keep the rest verbatim.
+      out += text.slice(index);
+      return out;
+    }
+    out += text.slice(index, start);
+    index = end + 1;
+  }
+}
+
+export interface CitationMarkerFilter {
+  /** Feed one streaming delta; returns the portion safe to emit now. */
+  push(delta: string): string;
+  /** Release anything still held when the message closes. */
+  flush(): string;
+}
+
+/**
+ * Streaming filter.
+ *
+ * A marker can straddle a delta boundary — `\uE200cite` in one chunk and the rest in the
+ * next — so a stateless per-delta strip would emit the tail of a span it never recognized.
+ * This holds back the text from an unterminated START and releases it once the END arrives
+ * (removed) or the stream ends (verbatim, so nothing the model actually said is lost).
+ */
+export function createCitationMarkerFilter(): CitationMarkerFilter {
+  // Text from an open START that has not been terminated yet.
+  let held = "";
+  return {
+    push(delta: string): string {
+      const combined = held + delta;
+      held = "";
+      const start = combined.lastIndexOf(CITATION_MARKER_START);
+      if (start === -1) return stripCitationMarkers(combined);
+      const endAfterStart = combined.indexOf(CITATION_MARKER_END, start + 1);
+      if (endAfterStart !== -1) return stripCitationMarkers(combined);
+      // The trailing span is still open: emit everything before it, hold the rest.
+      held = combined.slice(start);
+      return stripCitationMarkers(combined.slice(0, start));
+    },
+    flush(): string {
+      const rest = held;
+      held = "";
+      return rest;
+    },
+  };
+}
+

package/src/responses/parser.ts

@@ -19,7 +19,7 @@ import { compactionItemToText, isCompactionItemType } from "./compaction";
 import { previousResponseReplayPrefixLength } from "./state";
 import { decodeReasoningEnvelope } from "./reasoning-envelope";
 import { extractHostedWebSearch, WEB_SEARCH_TOOL_NAME } from "../web-search/synthetic-tool";
-import { extractHostedImageGeneration, IMAGE_GEN_TOOL_NAME } from "../images/synthetic-tool";
+import { buildImageTool, extractHostedImageGeneration, IMAGE_GEN_TOOL_NAME } from "../images/synthetic-tool";
 import { toolSearchDescription, toolSearchParameters } from "./tool-search-compat";
 
 function isObj(v: unknown): v is Record<string, unknown> {
@@ -165,6 +165,15 @@ function buildTools(tools: unknown[] | undefined): OcxTool[] | undefined {
     return { ...(isObj(raw) ? raw : {}), type: "object" };
   };
   const pushFn = (t: Record<string, unknown>, namespace?: string) => {
+    // Hosted image_generation already installed the synthetic root tool. A later
+    // ordinary root `image_gen` must not create a second un-namespaced identity.
+    if (
+      !namespace
+      && t.name === IMAGE_GEN_TOOL_NAME
+      && out.some(tool => tool.name === IMAGE_GEN_TOOL_NAME && !tool.namespace && tool.imageGeneration)
+    ) {
+      return;
+    }
     const tool: OcxTool = {
       name: t.name as string,
       description: (t.description as string) ?? "",
@@ -175,6 +184,16 @@ function buildTools(tools: unknown[] | undefined): OcxTool[] | undefined {
     out.push(tool);
   };
   const pushCustom = (t: Record<string, unknown>, namespace?: string) => {
+    // Hosted image_generation already installed the synthetic root tool. A later
+    // root custom `image_gen` would collide on the same wire name with a different
+    // `freeform` flag and throw `ambiguous tool catalog`.
+    if (
+      !namespace
+      && t.name === IMAGE_GEN_TOOL_NAME
+      && out.some(tool => tool.name === IMAGE_GEN_TOOL_NAME && !tool.namespace && tool.imageGeneration)
+    ) {
+      return;
+    }
     // Freeform custom tools are lowered to a single string `input` because chat models cannot
     // emit Responses grammar payloads directly. Keep tool-specific input guidance scoped to the
     // tool that owns it: leaking apply_patch syntax into `exec` or another freeform tool teaches
@@ -224,6 +243,28 @@ function buildTools(tools: unknown[] | undefined): OcxTool[] | undefined {
         toolSearch: true,
       });
     }
+    else if (t.type === "image_generation" || t.type === "image_gen") {
+      // Keep Codex's image_gen visible to routed chat models. The hosted OpenAI tool
+      // cannot execute on Grok; the model still has to see a callable image_gen so
+      // Codex's client-side /v1/images request can fire and be relayed to xAI.
+      // Identity is the un-namespaced synthetic root (`imageGeneration: true`), not
+      // the bare name: a namespaced ordinary `image_gen` must not suppress it.
+      const synthetic = buildImageTool();
+      // Every un-namespaced `image_gen` collides on one wire name, so removing only
+      // the first leaves a second root behind and the catalog stays ambiguous.
+      // Drop all root collisions, keep namespaced entries, then insert exactly one
+      // synthetic root — at the earliest colliding position so declaration order is
+      // preserved for models that read the catalog positionally.
+      let insertAt = -1;
+      for (let i = out.length - 1; i >= 0; i -= 1) {
+        const tool = out[i]!;
+        if (tool.name !== IMAGE_GEN_TOOL_NAME || tool.namespace) continue;
+        out.splice(i, 1);
+        insertAt = i;
+      }
+      if (insertAt >= 0) out.splice(insertAt, 0, synthetic);
+      else out.push(synthetic);
+    }
     else if (typeof t.name === "string" && t.type !== "web_search" && t.type !== "image_generation") {
       // Any OTHER named tool (e.g. a native/computer-use tool type opencodex doesn't explicitly
       // model) is client-executed — pass it through as a function so the routed model can read and
@@ -231,8 +272,7 @@ function buildTools(tools: unknown[] | undefined): OcxTool[] | undefined {
       // silently dropped, so the model never saw them.
       pushFn(t);
     }
-    // Only the OpenAI-hosted server-side tools (web_search, image_generation) are intentionally
-    // dropped — they're executed by OpenAI and can't be relayed to a routed chat model.
+    // Hosted web_search is still dropped here — the web-search sidecar re-injects it.
   }
   return out.length > 0 ? out : undefined;
 }

package/src/responses/spill-store.ts

@@ -215,7 +215,9 @@ function isErrno(error: unknown, code: string): boolean {
 }
 
 function canUseExclusiveCopyFallback(error: unknown): boolean {
-  return process.platform === "win32" || ["EPERM", "EACCES", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EXDEV"]
+  // Same platform seam as harden(): a fixture pinned to the POSIX lane on a Windows host must
+  // see a link failure as a failure, not as a cue to copy.
+  return windowsSecretAclApplies() || ["EPERM", "EACCES", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EXDEV"]
     .some(code => isErrno(error, code));
 }
 
@@ -235,7 +237,9 @@ function nextSpillHardenDeadlineMs(budget: SpillAclBudget | undefined): number |
 }
 
 function harden(path: string, mode: number, budget?: SpillAclBudget): void {
-  const aclApplies = budget ? windowsSecretAclApplies() : process.platform === "win32";
+  // One predicate for both lanes: the test seam that forces a platform must reach the
+  // sync harden too, or a fixture pinned to "linux" on a Windows host still spawns icacls.
+  const aclApplies = windowsSecretAclApplies();
   try {
     chmodSync(path, mode);
   } catch {
@@ -384,7 +388,8 @@ function publishNoReplace(
       else copyFileSync(tempPath, destinationPath, constants.COPYFILE_EXCL);
       copied = true;
       harden(destinationPath, 0o600, budget);
-      const copyFd = openSync(destinationPath, "r");
+      // "r+": a read-only handle cannot be fsynced on Windows (EPERM).
+      const copyFd = openSync(destinationPath, "r+");
       try {
         if (spillIoForTest?.fsync) spillIoForTest.fsync(copyFd);
         else fsyncSync(copyFd);
@@ -422,7 +427,7 @@ async function publishNoReplaceAsync(
       copied = true;
       await hardenAsync(destinationPath, 0o600, budget, retryTimedOutOnce);
       throwIfPublicationSuperseded(publicationControl);
-      const copyFd = openSync(destinationPath, "r");
+      const copyFd = openSync(destinationPath, "r+");
       try {
         if (spillIoForTest?.fsync) spillIoForTest.fsync(copyFd);
         else fsyncSync(copyFd);

package/src/router.ts

@@ -9,7 +9,7 @@ import {
 } from "./combos";
 import type { NormalizedComboConfig } from "./combos/types";
 import { hasOwnProvider } from "./config/provider-name";
-import { resolveEnvValue } from "./config";
+import { resolveProviderApiKey } from "./providers/key-store";
 import { assertProviderDestinationAllowed } from "./lib/destination-policy";
 import { redactSecretString, redactUrlForLog } from "./lib/redact";
 import {
@@ -265,8 +265,27 @@ function warnIfBaseUrlDiscarded(providerName: string, userBaseUrl: string, effec
   );
 }
 
+/**
+ * One notice per provider id: the destination is an operator-configured key
+ * (never a caller-supplied string), so the log carries no request content.
+ */
+const compactionFallbackWarnings = new Set<string>();
+function warnCompactionDefaultProviderFallbackOnce(providerName: string): void {
+  if (compactionFallbackWarnings.has(providerName)) return;
+  compactionFallbackWarnings.add(providerName);
+  console.warn(
+    `compaction: no enabled canonical "openai" provider for the native compaction model;`
+    + ` summarizing through default provider "${providerName}" instead (#2901).`,
+  );
+}
+
+/** Test seam: forget which compaction fallbacks have been announced. */
+export function resetCompactionFallbackWarningsForTests(): void {
+  compactionFallbackWarnings.clear();
+}
+
 function usableResolvedApiKey(apiKey: string | undefined): string | undefined {
-  const resolved = resolveEnvValue(apiKey);
+  const resolved = resolveProviderApiKey(apiKey);
   return typeof resolved === "string" && resolved.trim().length > 0 ? resolved : undefined;
 }
 
@@ -328,6 +347,7 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
   const preserveReasoningContentModels = mergeStringArray(registryEntry.preserveReasoningContentModels, provider.preserveReasoningContentModels);
   const requiresReasoningPlaceholderModels = mergeStringArray(registryEntry.requiresReasoningPlaceholderModels, provider.requiresReasoningPlaceholderModels);
   const reasoningSplitModels = mergeStringArray(registryEntry.reasoningSplitModels, provider.reasoningSplitModels);
+  const reasoningDetailsModels = mergeStringArray(registryEntry.reasoningDetailsModels, provider.reasoningDetailsModels);
   const thinkingToggleModels = mergeStringArray(registryEntry.thinkingToggleModels, provider.thinkingToggleModels);
   const thinkingBudgetModels = mergeStringArray(registryEntry.thinkingBudgetModels, provider.thinkingBudgetModels);
   const registryBaseUrlIsTemplate = /\{[^}]*\}/.test(registryEntry.baseUrl);
@@ -451,6 +471,7 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
     ...(preserveReasoningContentModels ? { preserveReasoningContentModels } : {}),
     ...(requiresReasoningPlaceholderModels ? { requiresReasoningPlaceholderModels } : {}),
     ...(reasoningSplitModels ? { reasoningSplitModels } : {}),
+    ...(reasoningDetailsModels ? { reasoningDetailsModels } : {}),
     ...(thinkingToggleModels ? { thinkingToggleModels } : {}),
     ...(thinkingBudgetModels ? { thinkingBudgetModels } : {}),
   };
@@ -576,6 +597,7 @@ function routeModelInternal(
   modelId: string,
   bypassCombos: boolean,
   policyEvidence?: PolicyRequestEvidence,
+  allowCompactionNativeFallback = false,
 ): RouteResult {
   const slash = modelId.indexOf("/");
   // Policy namespace is system-reserved: an explicit `policy/<id>` or a
@@ -701,6 +723,28 @@ function routeModelInternal(
     if (provider && provider.disabled !== true) {
       return routeResult(config, OPENAI_CODEX_PROVIDER_ID, provider, modelId, "native", "native-family");
     }
+    // Codex chooses a bare native model for compaction even when the operator's
+    // ordinary route is a third-party provider. Keep the native reservation
+    // unchanged for ordinary turns; only the explicit compaction surface may
+    // use the configured default as its summarizer destination.
+    if (allowCompactionNativeFallback
+      && config.defaultProvider !== OPENAI_CODEX_PROVIDER_ID
+      && config.defaultProvider !== LEGACY_CHATGPT_PROVIDER_ID
+      && config.defaultProvider !== LEGACY_OPENAI_MULTI_PROVIDER_ID
+      && hasOwnProvider(config.providers, config.defaultProvider)) {
+      const defaultProvider = config.providers[config.defaultProvider];
+      if (defaultProvider.disabled !== true) {
+        warnCompactionDefaultProviderFallbackOnce(config.defaultProvider);
+        return routeResult(
+          config,
+          config.defaultProvider,
+          defaultProvider,
+          modelId,
+          "default-provider",
+          "compaction-default-provider",
+        );
+      }
+    }
     throw new NoEnabledOpenAiProviderError(modelId);
   }
 
@@ -753,12 +797,7 @@ function routeModelInternal(
   throw new Error(`No provider configured for model: ${modelId}`);
 }
 
-export function routeModel(
-  config: OcxConfig,
-  modelId: string,
-  policyEvidence?: PolicyRequestEvidence,
-): RouteResult {
-  const route = routeModelInternal(config, modelId, false, policyEvidence);
+function routeWithDecisionTrace(config: OcxConfig, modelId: string, route: RouteResult): RouteResult {
   // Policy routes carry a full evaluation trace already; never rebuild it.
   if (route.routeDecision) return route;
   const accountRef = route.codexAccountNamespace;
@@ -783,6 +822,31 @@ export function routeModel(
   return route;
 }
 
+export function routeModel(
+  config: OcxConfig,
+  modelId: string,
+  policyEvidence?: PolicyRequestEvidence,
+): RouteResult {
+  const route = routeModelInternal(config, modelId, false, policyEvidence);
+  return routeWithDecisionTrace(config, modelId, route);
+}
+
+/**
+ * Route a client-selected compaction model. Codex may send a bare native model
+ * even when its ordinary turns are configured for another provider; in that
+ * one case the configured default provider is a safe summarizer destination.
+ * This helper is intentionally separate so ordinary requests retain the
+ * canonical OpenAI reservation and exact account selectors remain fail-closed.
+ */
+export function routeCompactionModel(
+  config: OcxConfig,
+  modelId: string,
+  policyEvidence?: PolicyRequestEvidence,
+): RouteResult {
+  const route = routeModelInternal(config, modelId, false, policyEvidence, true);
+  return routeWithDecisionTrace(config, modelId, route);
+}
+
 /** Resolve a combo-selected provider/model target without consulting public combo aliases again. */
 export function routeConcreteModel(config: OcxConfig, modelId: string): RouteResult {
   return routeModelInternal(config, modelId, true, undefined);

package/src/server/auth-cors.ts

@@ -121,7 +121,29 @@ export function managementRequestOrigin(req: Request, config: OcxConfig): string
   const host = req.headers.get("Host");
   const parsedHost = parseHttpHost(host);
   if (!host || !parsedHost) return null;
-  if (!isApiAuthRequired(config) && !isLoopbackHostname(parsedHost.hostname)) return null;
+  if (isLoopbackHostname(parsedHost.hostname)) {
+    try {
+      const protocol = new URL(req.url).protocol;
+      if (protocol !== "http:" && protocol !== "https:") return null;
+      return new URL(`${protocol}//${host}`).origin;
+    } catch {
+      return null;
+    }
+  }
+  if (!isApiAuthRequired(config)) return null;
+  if (config.runtimeRole === "hub" && config.hub?.managementPublicOrigin) {
+    try {
+      const configured = new URL(config.hub.managementPublicOrigin);
+      if (
+        (configured.protocol === "http:" || configured.protocol === "https:")
+        && !configured.username
+        && !configured.password
+        && configured.pathname === "/"
+        && !configured.search
+        && !configured.hash
+      ) return configured.origin;
+    } catch { /* malformed direct fixture: fall through to observed origin */ }
+  }
   try {
     const protocol = new URL(req.url).protocol;
     if (protocol !== "http:" && protocol !== "https:") return null;
@@ -200,6 +222,7 @@ export function corsHeaders(req?: Request, config?: RequestPolicyView): Record<s
 
 export function managementCorsHeaders(req?: Request, config?: OcxConfig): Record<string, string> {
   const headers = corsHeaders();
+  headers["Access-Control-Allow-Headers"] = `${STATIC_ALLOWED_REQUEST_HEADERS}, X-OpenCodex-GUI-Origin, X-OpenCodex-CSRF-Token`;
   const origin = req?.headers.get("Origin");
   if (origin && req && config && isAllowedManagementOrigin(req, config)) {
     headers["Access-Control-Allow-Origin"] = origin;
@@ -351,6 +374,10 @@ export function resolveDataPlaneAdmissionSecret(
   if (secretEquals(actual, configuredApiAuthToken(config))) return { kind: "environment", source };
   for (const k of config.apiKeys ?? []) {
     if (secretEquals(actual, k.key)) return { kind: "configured", keyId: k.id, source };
+    const pending = k.pendingRotation;
+    if (pending && Date.parse(pending.expiresAt) > Date.now() && secretEquals(actual, pending.key)) {
+      return { kind: "configured", keyId: k.id, source };
+    }
   }
   return null;
 }
@@ -667,6 +694,13 @@ export function providerManagementConfigError(name: unknown, provider: unknown):
     "noStructuredOutputModels",
   );
   if (structuredOutputOptOutError) return `provider ${name} ${structuredOutputOptOutError}`;
+  const retainModelsError = nonBlankStringArrayConfigError(raw.retainModels, "retainModels");
+  if (retainModelsError) return `provider ${name} ${retainModelsError}`;
+  const toolReasoningOptOutError = nonBlankStringArrayConfigError(
+    raw.omitReasoningEffortWithToolsModels,
+    "omitReasoningEffortWithToolsModels",
+  );
+  if (toolReasoningOptOutError) return `provider ${name} ${toolReasoningOptOutError}`;
   const openRouterError = openRouterRoutingConfigError(typed);
   if (openRouterError) return `provider ${name} ${openRouterError}`;
   const vercelError = vercelGatewayRoutingConfigError(typed);
@@ -760,6 +794,8 @@ export function safeConfigDTO(config: OcxConfig): unknown {
       "noTopPModels",
       "noPenaltyModels",
       "noStructuredOutputModels",
+      "retainModels",
+      "omitReasoningEffortWithToolsModels",
       "upstreamHttpVersion",
       "autoToolChoiceOnlyModels",
       "preserveReasoningContentModels",