@bitkyc08/opencodex 2.39.0 → 2.40.0

package/src/lib/service-secrets.ts

@@ -1,11 +1,171 @@
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, fsyncSync, lstatSync, openSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { readFileSync } from "node:fs";
 import { getConfigDir } from "../config";
+import { atomicWriteFile } from "../config/atomic-write";
+
+const MAX_SERVICE_API_TOKEN_BYTES = 4096;
+
+export interface PersistedServiceApiToken {
+  path: string;
+  fingerprint: string;
+}
+
+export type ServiceApiTokenState =
+  | { kind: "absent" }
+  | { kind: "present"; token: string; fingerprint: string }
+  | { kind: "unsafe"; reason: string };
 
 export function serviceApiTokenFilePath(): string {
   return join(getConfigDir(), "service-api-token");
 }
 
+export function serviceApiTokenBackupPath(): string {
+  return `${serviceApiTokenFilePath()}.prev`;
+}
+
+export function serviceApiTokenFingerprint(token: string): string {
+  return createHash("sha256").update(token).digest("hex");
+}
+
+export function readServiceApiTokenState(): ServiceApiTokenState {
+  const path = serviceApiTokenFilePath();
+  if (!existsSync(path)) return { kind: "absent" };
+  let stat;
+  try {
+    stat = lstatSync(path);
+  } catch {
+    return { kind: "unsafe", reason: "service token path could not be inspected" };
+  }
+  if (stat.isSymbolicLink() || !stat.isFile() || stat.size > MAX_SERVICE_API_TOKEN_BYTES) {
+    return { kind: "unsafe", reason: "service token path is not a bounded regular file" };
+  }
+  try {
+    const token = readFileSync(path, "utf8").trim();
+    if (!token) return { kind: "unsafe", reason: "service token file is empty" };
+    return { kind: "present", token, fingerprint: serviceApiTokenFingerprint(token) };
+  } catch {
+    return { kind: "unsafe", reason: "service token file could not be read" };
+  }
+}
+
+export function writeServiceApiTokenFile(token: string): PersistedServiceApiToken {
+  const value = token.trim();
+  if (!value || /[\r\n\0]/.test(value) || Buffer.byteLength(value) > MAX_SERVICE_API_TOKEN_BYTES) {
+    throw new Error("refusing to persist an invalid service API token");
+  }
+  const path = serviceApiTokenFilePath();
+  const existing = readServiceApiTokenState();
+  if (existing.kind !== "absent") {
+    throw new Error(existing.kind === "unsafe"
+      ? existing.reason
+      : "refusing to replace a pre-existing service API token");
+  }
+  atomicWriteFile(path, `${value}\n`);
+  return { path, fingerprint: serviceApiTokenFingerprint(value) };
+}
+
+function fsyncRegularFile(path: string): void {
+  // "r+", not "r": Windows rejects fsync on a read-only handle with EPERM, so a read-only
+  // open turned every token backup/replace/restore into a hard failure there.
+  const fd = openSync(path, "r+");
+  try { fsyncSync(fd); } finally { closeSync(fd); }
+}
+
+function validatedTokenValue(token: string): string {
+  const value = token.trim();
+  if (!value || /[\r\n\0]/.test(value) || Buffer.byteLength(value) > MAX_SERVICE_API_TOKEN_BYTES) {
+    throw new Error("refusing to persist an invalid service API token");
+  }
+  return value;
+}
+
+export function replaceServiceApiTokenFile(token: string): PersistedServiceApiToken {
+  const value = validatedTokenValue(token);
+  const current = readServiceApiTokenState();
+  if (current.kind !== "present") {
+    throw new Error(current.kind === "unsafe" ? current.reason : "service token file is missing");
+  }
+  const path = serviceApiTokenFilePath();
+  atomicWriteFile(path, `${value}\n`);
+  fsyncRegularFile(path);
+  return { path, fingerprint: serviceApiTokenFingerprint(value) };
+}
+
+export function readTokenBackupState(): ServiceApiTokenState {
+  const path = serviceApiTokenBackupPath();
+  if (!existsSync(path)) return { kind: "absent" };
+  let stat;
+  try { stat = lstatSync(path); }
+  catch { return { kind: "unsafe", reason: "service token backup could not be inspected" }; }
+  if (stat.isSymbolicLink() || !stat.isFile() || stat.size > MAX_SERVICE_API_TOKEN_BYTES
+    || (process.platform !== "win32" && (stat.mode & 0o077) !== 0)) {
+    return { kind: "unsafe", reason: "service token backup is not an owner-only bounded regular file" };
+  }
+  try {
+    const token = readFileSync(path, "utf8").trim();
+    if (!token || /[\r\n\0]/.test(token)) return { kind: "unsafe", reason: "service token backup is invalid" };
+    return { kind: "present", token, fingerprint: serviceApiTokenFingerprint(token) };
+  } catch {
+    return { kind: "unsafe", reason: "service token backup could not be read" };
+  }
+}
+
+export function writeTokenBackup(expectedFingerprint: string): PersistedServiceApiToken {
+  const current = readServiceApiTokenState();
+  if (current.kind !== "present" || current.fingerprint !== expectedFingerprint) {
+    throw new Error(current.kind === "unsafe" ? current.reason : "service token ownership changed before backup");
+  }
+  const existing = readTokenBackupState();
+  if (existing.kind !== "absent") {
+    throw new Error(existing.kind === "unsafe" ? existing.reason : "service token backup already exists");
+  }
+  const path = serviceApiTokenBackupPath();
+  atomicWriteFile(path, `${current.token}\n`);
+  fsyncRegularFile(path);
+  return { path, fingerprint: current.fingerprint };
+}
+
+export function restoreTokenBackup(expectedPath: string): PersistedServiceApiToken {
+  if (expectedPath !== serviceApiTokenBackupPath()) throw new Error("service token backup path mismatch");
+  const backup = readTokenBackupState();
+  if (backup.kind !== "present") {
+    throw new Error(backup.kind === "unsafe" ? backup.reason : "service token backup is missing");
+  }
+  const path = serviceApiTokenFilePath();
+  atomicWriteFile(path, `${backup.token}\n`);
+  fsyncRegularFile(path);
+  return { path, fingerprint: backup.fingerprint };
+}
+
+export function removeOrphanTokenBackup(): "removed" | "absent" {
+  const backup = readTokenBackupState();
+  if (backup.kind === "absent") return "absent";
+  if (backup.kind === "unsafe") throw new Error(backup.reason);
+  try {
+    unlinkSync(serviceApiTokenBackupPath());
+    return "removed";
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return "absent";
+    throw new Error("service token backup could not be removed", { cause: error });
+  }
+}
+
+export function removeServiceApiTokenFileIfOwned(
+  expectedFingerprint: string,
+): "removed" | "absent" | "changed" {
+  const state = readServiceApiTokenState();
+  if (state.kind === "absent") return "absent";
+  if (state.kind !== "present" || state.fingerprint !== expectedFingerprint) return "changed";
+  try {
+    unlinkSync(serviceApiTokenFilePath());
+    return "removed";
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return "absent";
+    throw new Error("owned service API token could not be removed", { cause: error });
+  }
+}
+
 /**
  * App-side service token loading (WinSW native mode has no batch wrapper to read the
  * token file into the environment). Pure: returns the token or null — the CALLER

package/src/lib/windows-system-proxy.ts

@@ -0,0 +1,115 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { decodeWindowsTextBytes } from "./windows-text";
+
+/**
+ * Startup-time discovery of the Windows WinINET static proxy (#1525, slice 1).
+ *
+ * Reads `HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings` once and returns a
+ * normalized `http://host:port` URL when a static proxy is enabled. PAC/WPAD, per-request
+ * resolution, ProxyOverride, live refresh, and direct fallback are deliberately out of scope:
+ * this is the piece an operator can audit from one log line, and everything else needs the
+ * transport boundary the reviewer asked for first.
+ */
+
+const INTERNET_SETTINGS_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
+
+export type WindowsSystemProxyResult =
+  | { kind: "proxy"; url: string }
+  | { kind: "disabled" }
+  | { kind: "socks-only" }
+  | { kind: "unsupported" }
+  | { kind: "unreadable" };
+
+/** Raw registry values; `null` when the value is absent or the read failed. */
+export interface WindowsProxyRegistryValues {
+  proxyEnable: string | null;
+  proxyServer: string | null;
+}
+
+export type WindowsProxyRegistryReader = () => WindowsProxyRegistryValues | null;
+
+function registryExe(): string {
+  const candidate = join(process.env.SystemRoot ?? "C:\\Windows", "System32", "reg.exe");
+  return existsSync(candidate) ? candidate : "reg.exe";
+}
+
+function queryValue(name: string): string | null {
+  try {
+    const stdout = execFileSync(registryExe(), ["query", INTERNET_SETTINGS_KEY, "/v", name], {
+      encoding: "buffer",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2000,
+      maxBuffer: 64 * 1024,
+      windowsHide: true,
+    });
+    const text = decodeWindowsTextBytes(stdout);
+    // "    ProxyServer    REG_SZ    host:port"
+    const line = text.split(/\r?\n/).find(row => row.trim().startsWith(name));
+    if (!line) return null;
+    const match = line.match(/REG_(?:SZ|DWORD|EXPAND_SZ)\s+(.*)$/);
+    return match ? match[1]!.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+export function readWindowsProxyRegistry(): WindowsProxyRegistryValues | null {
+  const proxyEnable = queryValue("ProxyEnable");
+  if (proxyEnable === null) return null;
+  return { proxyEnable, proxyServer: queryValue("ProxyServer") };
+}
+
+/**
+ * `ProxyServer` is either a bare `host:port` (applies to every scheme) or a semicolon list of
+ * `scheme=host:port` entries. Prefer the https entry, then http; a SOCKS-only value cannot be
+ * mirrored into HTTP_PROXY/HTTPS_PROXY.
+ */
+export function parseWindowsProxyServer(value: string): { kind: "proxy"; url: string } | { kind: "socks-only" } | { kind: "disabled" } {
+  const trimmed = value.trim();
+  if (!trimmed) return { kind: "disabled" };
+  if (!trimmed.includes("=")) return normalize(trimmed);
+  const entries = new Map<string, string>();
+  for (const part of trimmed.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq <= 0) continue;
+    entries.set(part.slice(0, eq).trim().toLowerCase(), part.slice(eq + 1).trim());
+  }
+  const candidate = entries.get("https") || entries.get("http");
+  if (candidate) return normalize(candidate);
+  if (entries.has("socks")) return { kind: "socks-only" };
+  return { kind: "disabled" };
+}
+
+function normalize(hostPort: string): { kind: "proxy"; url: string } | { kind: "disabled" } {
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(hostPort) ? hostPort : `http://${hostPort}`;
+  try {
+    const url = new URL(withScheme);
+    if (!url.hostname || (url.protocol !== "http:" && url.protocol !== "https:")) return { kind: "disabled" };
+    // Keep userinfo: a credentialed proxy is valid in HTTP_PROXY. Only the log strips it.
+    const auth = url.username ? `${url.username}${url.password ? `:${url.password}` : ""}@` : "";
+    return { kind: "proxy", url: `${url.protocol}//${auth}${url.host}` };
+  } catch {
+    return { kind: "disabled" };
+  }
+}
+
+export function readWindowsSystemProxy(
+  reader: WindowsProxyRegistryReader = readWindowsProxyRegistry,
+  platform: NodeJS.Platform = process.platform,
+): WindowsSystemProxyResult {
+  if (platform !== "win32") return { kind: "unsupported" };
+  const values = reader();
+  if (!values) return { kind: "unreadable" };
+  // REG_DWORD prints as 0x1 / 0x0.
+  const enabled = /^(0x)?0*1$/i.test((values.proxyEnable ?? "").trim());
+  if (!enabled) return { kind: "disabled" };
+  if (!values.proxyServer) return { kind: "disabled" };
+  return parseWindowsProxyServer(values.proxyServer);
+}
+
+/** Log-safe form: origin only, so a credentialed value can never reach the console. */
+export function describeProxyForLog(url: string): string {
+  try { return new URL(url).origin; } catch { return "<unparseable>"; }
+}

package/src/oauth/index.ts

@@ -1,7 +1,8 @@
 import type { KiroOAuthMetadata, OAuthController, OAuthCredentials } from "./types";
 import { parseCallbackInput } from "./callback-server";
 import type { OcxConfig, OcxProviderConfig, RefreshPolicy } from "../types";
-import { ConfigMutationLockError, loadConfig, resolveEnvValue, saveConfig } from "../config";
+import { ConfigMutationLockError, loadConfig, saveConfig } from "../config";
+import { resolveProviderApiKey } from "../providers/key-store";
 import { maskEmail } from "../lib/privacy";
 import { KiroTokenRefreshError, environmentKiroRoutingMetadata, loginKiro, refreshKiroToken, settleKiroLoginTransaction } from "./kiro";
 import {
@@ -1043,7 +1044,7 @@ export async function resolveModelsAuthToken(name: string, prov: OcxProviderConf
       return undefined;
     }
   }
-  return resolveEnvValue(prov.apiKey);
+  return resolveProviderApiKey(prov.apiKey);
 }
 
 function modelDiscoveryTransportSeed(providerName: string, prov: OcxProviderConfig): OcxProviderConfig {

package/src/oauth/pool-settings-capability.ts

@@ -0,0 +1,55 @@
+import { isGenericFailoverProvider } from "./generic-account-failover";
+import type { OcxProviderConfig } from "../types";
+
+/**
+ * Which pool-settings contract a provider speaks (#695, slice 1).
+ *
+ * `codex` and `anthropic` keep their own routes and storage untouched. `generic` is every
+ * other OAuth provider the generic failover module admits; its settings persist on
+ * `providers.<name>.oauthAccountFailover`. Settings stored for a generic provider are a
+ * declared contract the selector can consume in a later slice; today they change nothing.
+ */
+export type PoolSettingsKind = "codex" | "anthropic" | "generic";
+
+export const GENERIC_POOL_STRATEGIES = ["quota", "round-robin", "fill-first"] as const;
+export type GenericPoolStrategy = typeof GENERIC_POOL_STRATEGIES[number];
+
+export function poolSettingsCapability(name: string, provider: OcxProviderConfig | undefined): PoolSettingsKind | null {
+  if (name === "openai") return "codex";
+  if (name === "anthropic") return "anthropic";
+  if (!provider) return null;
+  return isGenericFailoverProvider(name, provider) ? "generic" : null;
+}
+
+export function parseGenericPoolStrategy(value: unknown): GenericPoolStrategy | null {
+  return typeof value === "string" && (GENERIC_POOL_STRATEGIES as readonly string[]).includes(value)
+    ? value as GenericPoolStrategy
+    : null;
+}
+
+export function parseGenericAutoSwitchThreshold(value: unknown): number | null {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 100 ? value : null;
+}
+
+export interface GenericPoolSettingsDto {
+  provider: string;
+  kind: "generic";
+  enabled: boolean | null;
+  strategy: GenericPoolStrategy | null;
+  autoSwitchThreshold: number | null;
+  /** Slice-1 marker: persisted, not yet consumed by the selector. */
+  inert: true;
+}
+
+export function genericPoolSettingsDto(name: string, provider: OcxProviderConfig): GenericPoolSettingsDto {
+  const failover = provider.oauthAccountFailover ?? {};
+  return {
+    provider: name,
+    kind: "generic",
+    enabled: typeof failover.enabled === "boolean" ? failover.enabled : null,
+    strategy: parseGenericPoolStrategy(failover.strategy),
+    autoSwitchThreshold: parseGenericAutoSwitchThreshold(failover.autoSwitchThreshold),
+    inert: true,
+  };
+}
+

package/src/providers/api-keys.ts

@@ -24,7 +24,9 @@ function isEnvReference(value: string): boolean {
 }
 
 export function maskApiKey(value: string): string {
-  if (isEnvReference(value)) return value;
+  // Env and keychain references carry no secret material; show them verbatim so an operator
+  // can tell where the key lives.
+  if (isEnvReference(value) || value.startsWith("keychain:")) return value;
   if (value.length <= 8) return "****";
   return `${value.slice(0, 4)}****${value.slice(-4)}`;
 }

package/src/providers/codex-capacity.ts

@@ -8,6 +8,28 @@ export const CODEX_CONFIGURED_CAPACITY_WEIGHTS = {
   pro: 20,
 } as const;
 
+/**
+ * Weight for a plan the map above has not calibrated.
+ *
+ * `CodexAccount.plan` is an unrestricted upstream string and cannot be enumerated: the
+ * bundled model snapshot alone carries 21 distinct plan names (`edu_plus`, `finserv`,
+ * `k12`, `quorum`, `self_serve_business_usage_based`, …) against the five listed above.
+ * Treating an unlisted plan as unknown dropped the account from the estimate entirely and
+ * reported "incomplete coverage" — which is how a Business seat upgraded to Premium
+ * disappeared from its own capacity report (#3155), and it was already happening to the
+ * other sixteen snapshot plans without anyone noticing.
+ *
+ * `src/codex/quota.ts` reached the same conclusion about the same field: an allowlist is a
+ * list of the plans someone remembered. Counting an unfamiliar plan at the baseline seat
+ * weight — the value `plus`, `team`, and `business` already carry — under-states a large
+ * seat, which is a visibly conservative estimate. Excluding it silently overstates coverage
+ * the operator does not have, which is worse.
+ *
+ * Uncalibrated plans are still counted in `unknownPlanAccounts` so the estimate's
+ * uncertainty stays on screen.
+ */
+export const CODEX_DEFAULT_CAPACITY_WEIGHT = 1;
+
 /** Match the provider-report last-good freshness bound. */
 export const CODEX_CAPACITY_MAX_QUOTA_AGE_MS = 30 * 60_000;
 
@@ -85,11 +107,17 @@ type MutableWindow = {
   oldestUpdatedAt: number;
 };
 
-function configuredWeight(plan: unknown): number | undefined {
+/** True when this plan has a calibrated weight rather than falling back to the default. */
+function isCalibratedPlan(plan: unknown): boolean {
+  const normalized = codexPlanKey(plan);
+  return !!normalized && Object.hasOwn(CODEX_CONFIGURED_CAPACITY_WEIGHTS, normalized);
+}
+
+function configuredWeight(plan: unknown): number {
   const normalized = codexPlanKey(plan);
   return normalized && Object.hasOwn(CODEX_CONFIGURED_CAPACITY_WEIGHTS, normalized)
     ? CODEX_CONFIGURED_CAPACITY_WEIGHTS[normalized as keyof typeof CODEX_CONFIGURED_CAPACITY_WEIGHTS]
-    : undefined;
+    : CODEX_DEFAULT_CAPACITY_WEIGHT;
 }
 
 function normalizedPercent(value: unknown): number | undefined {
@@ -188,7 +216,9 @@ export function aggregateCodexPoolCapacity(
 
   for (const account of accounts) {
     const weight = configuredWeight(account.plan);
-    if (weight === undefined) unknownPlanAccounts += 1;
+    // Still reported, so the operator can see the estimate is conservative for this seat —
+    // but no longer a reason to drop the account from the aggregate (#3155).
+    if (!isCalibratedPlan(account.plan)) unknownPlanAccounts += 1;
     if (account.paused) pausedAccounts += 1;
     if (account.needsReauth) reauthAccounts += 1;
     const quota = account.quota;
@@ -204,7 +234,7 @@ export function aggregateCodexPoolCapacity(
     const custom = quota?.customWindows ?? [];
     const hasQuota = hasKnownQuotaWindow(quota);
     if (!hasQuota) missingQuotaAccounts += 1;
-    if (account.paused || account.needsReauth || weight === undefined || !quota || !hasQuota || !quotaFresh) continue;
+    if (account.paused || account.needsReauth || !quota || !hasQuota || !quotaFresh) continue;
 
     let contributed = false;
     const contributionKeys = new Set<string>();

package/src/providers/derive.ts

@@ -44,6 +44,7 @@ export interface DerivedKeyLoginProvider {
   preserveReasoningContentModels?: string[];
   requiresReasoningPlaceholderModels?: string[];
   reasoningSplitModels?: string[];
+  reasoningDetailsModels?: string[];
   thinkingToggleModels?: string[];
   thinkingBudgetModels?: string[];
   escapeBuiltinToolNames?: boolean;
@@ -230,6 +231,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(liveModels !== undefined ? { liveModels } : {}),
     ...(entry.contextWindow !== undefined ? { contextWindow: entry.contextWindow } : {}),
     ...(entry.modelContextWindows ? { modelContextWindows: { ...entry.modelContextWindows } } : {}),
+    ...(entry.modelDisplayNames ? { modelDisplayNames: { ...entry.modelDisplayNames } } : {}),
     ...(entry.modelInputModalities ? { modelInputModalities: cloneRecordOfArrays(entry.modelInputModalities) } : {}),
     ...(entry.modelMaxInputTokens ? { modelMaxInputTokens: { ...entry.modelMaxInputTokens } } : {}),
     ...(entry.defaultMaxOutputTokens !== undefined ? { defaultMaxOutputTokens: entry.defaultMaxOutputTokens } : {}),
@@ -261,6 +263,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.preserveReasoningContentModels ? { preserveReasoningContentModels: [...entry.preserveReasoningContentModels] } : {}),
     ...(entry.requiresReasoningPlaceholderModels ? { requiresReasoningPlaceholderModels: [...entry.requiresReasoningPlaceholderModels] } : {}),
     ...(entry.reasoningSplitModels ? { reasoningSplitModels: [...entry.reasoningSplitModels] } : {}),
+    ...(entry.reasoningDetailsModels ? { reasoningDetailsModels: [...entry.reasoningDetailsModels] } : {}),
     ...(entry.thinkingToggleModels ? { thinkingToggleModels: [...entry.thinkingToggleModels] } : {}),
     ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
     ...(entry.escapeBuiltinToolNames !== undefined ? { escapeBuiltinToolNames: entry.escapeBuiltinToolNames } : {}),
@@ -308,6 +311,7 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
       ...(entry.preserveReasoningContentModels ? { preserveReasoningContentModels: [...entry.preserveReasoningContentModels] } : {}),
       ...(entry.requiresReasoningPlaceholderModels ? { requiresReasoningPlaceholderModels: [...entry.requiresReasoningPlaceholderModels] } : {}),
       ...(entry.reasoningSplitModels ? { reasoningSplitModels: [...entry.reasoningSplitModels] } : {}),
+      ...(entry.reasoningDetailsModels ? { reasoningDetailsModels: [...entry.reasoningDetailsModels] } : {}),
       ...(entry.thinkingToggleModels ? { thinkingToggleModels: [...entry.thinkingToggleModels] } : {}),
       ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
       ...(entry.escapeBuiltinToolNames !== undefined ? { escapeBuiltinToolNames: entry.escapeBuiltinToolNames } : {}),
@@ -475,6 +479,11 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (prov.liveModels === undefined && seed.liveModels !== undefined) prov.liveModels = seed.liveModels;
   if (prov.contextWindow === undefined && seed.contextWindow !== undefined) prov.contextWindow = seed.contextWindow;
   if (!prov.modelContextWindows && seed.modelContextWindows) prov.modelContextWindows = { ...seed.modelContextWindows };
+  // Per-model fill, not all-or-nothing: an operator who renamed ONE model must still receive
+  // labels for the rest, and an existing install must pick up newly seeded rows on enrich.
+  if (seed.modelDisplayNames) {
+    prov.modelDisplayNames = { ...seed.modelDisplayNames, ...(prov.modelDisplayNames ?? {}) };
+  }
   if (seed.modelInputModalities) prov.modelInputModalities = fillRecordOfArrays(seed.modelInputModalities, prov.modelInputModalities);
   if (prov.defaultMaxOutputTokens === undefined && seed.defaultMaxOutputTokens !== undefined) prov.defaultMaxOutputTokens = seed.defaultMaxOutputTokens;
   if (!prov.modelMaxOutputTokens && seed.modelMaxOutputTokens) prov.modelMaxOutputTokens = { ...seed.modelMaxOutputTokens };
@@ -542,6 +551,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (!prov.preserveReasoningContentModels && seed.preserveReasoningContentModels) prov.preserveReasoningContentModels = [...seed.preserveReasoningContentModels];
   if (!prov.requiresReasoningPlaceholderModels && seed.requiresReasoningPlaceholderModels) prov.requiresReasoningPlaceholderModels = [...seed.requiresReasoningPlaceholderModels];
   if (!prov.reasoningSplitModels && seed.reasoningSplitModels) prov.reasoningSplitModels = [...seed.reasoningSplitModels];
+  if (!prov.reasoningDetailsModels && seed.reasoningDetailsModels) prov.reasoningDetailsModels = [...seed.reasoningDetailsModels];
   if (!prov.thinkingToggleModels && seed.thinkingToggleModels) prov.thinkingToggleModels = [...seed.thinkingToggleModels];
   if (!prov.thinkingBudgetModels && seed.thinkingBudgetModels) prov.thinkingBudgetModels = [...seed.thinkingBudgetModels];
   if (prov.escapeBuiltinToolNames === undefined && seed.escapeBuiltinToolNames !== undefined) prov.escapeBuiltinToolNames = seed.escapeBuiltinToolNames;

package/src/providers/fastwire.ts

@@ -14,6 +14,9 @@ const FAST_WIRE_ADAPTERS: Readonly<Record<FastWire["kind"], ReadonlySet<string>>
   "service-tier": SERVICE_TIER_ADAPTERS,
   // A1 deliberately has no adapter implementation for Anthropic speed.
   "anthropic-speed": new Set(),
+  // Cursor expresses Fast as a variant dimension of the picked model, resolved in the
+  // request builder, so the adapter set is exactly the cursor adapter.
+  "cursor-variant": new Set(["cursor"]),
 };
 
 const DEFAULT_SERVICE_TIER_FAST_WIRE: FastWire = Object.freeze({
@@ -209,8 +212,13 @@ export function resolveFastPolicy(
   // On classified routes this permission applies only to a caller's foreign tier: proxy-owned
   // canonical Fast has already passed capability validation. On unclassified routes every caller
   // tier still needs the final wire's forwarding permission.
+  // A wire that declares `foreignCallerTiers: "drop"` cannot carry an arbitrary tier string at
+  // all — cursor-variant resolves a MODEL VARIANT, so there is nothing to forward a foreign
+  // value into. Without this, an unclassified route on such a wire projects "unknown" support
+  // and Codex would show a Fast toggle on a base that has no fast variant.
   const forwardCallerTier = capability !== false
     && callerWireAvailable
+    && fastWire?.foreignCallerTiers !== "drop"
     && forwardCallerServiceTier !== false
     && (adapter !== "openai-chat" || authority.capability.chatServiceTier === true);
 
@@ -467,8 +475,8 @@ export function fastWireDeclarationError(source: {
   }
   if (value === null) return null;
   if (!isPlainRecord(value)) return "fastWire must be an object, null, or absent";
-  if (value.kind !== "service-tier" && value.kind !== "anthropic-speed") {
-    return "fastWire.kind must be service-tier or anthropic-speed";
+  if (value.kind !== "service-tier" && value.kind !== "anthropic-speed" && value.kind !== "cursor-variant") {
+    return "fastWire.kind must be service-tier, anthropic-speed, or cursor-variant";
   }
   if (value.foreignCallerTiers !== "verbatim" && value.foreignCallerTiers !== "drop") {
     return "fastWire.foreignCallerTiers must be verbatim or drop";