@bitkyc08/opencodex 2.7.23 → 2.7.24

package/src/providers/registry.ts

@@ -1,4 +1,4 @@
-import type { OcxProviderConfig } from "../types";
+import type { CodexAccountMode, OcxProviderConfig } from "../types";
 import { KIRO_MODELS, KIRO_MODEL_CONTEXT_WINDOWS, KIRO_MODEL_REASONING_EFFORTS } from "./kiro-models";
 import { ANTIGRAVITY_MODELS, ANTIGRAVITY_MODEL_CONTEXT_WINDOWS } from "./antigravity-models";
 import {
@@ -18,10 +18,16 @@ export interface ProviderRegistryEntry {
   adapter: string;
   baseUrl: string;
   authKind: ProviderAuthKind;
+  codexAccountMode?: CodexAccountMode;
   /** OAuth preset may explicitly honor a persisted API-key billing mode. */
   allowKeyAuthOverride?: boolean;
   allowPrivateNetworkByDefault?: boolean;
   keyOptional?: boolean;
+  /**
+   * Free-tier pricing (no paid subscription required). Distinct from `keyOptional`:
+   * free tiers may still require an API key (e.g. NVIDIA NIM free credits).
+   */
+  freeTier?: boolean;
   allowBaseUrlOverride?: boolean;
   /** Static headers merged into every upstream request for this provider. */
   staticHeaders?: Record<string, string>;
@@ -38,6 +44,7 @@ export interface ProviderRegistryEntry {
   modelInputModalities?: Record<string, string[]>;
   reasoningEfforts?: string[];
   modelReasoningEfforts?: Record<string, string[]>;
+  modelDefaultReasoningEfforts?: Record<string, string>;
   reasoningEffortMap?: Record<string, string>;
   modelReasoningEffortMap?: Record<string, Record<string, string>>;
   noVisionModels?: string[];
@@ -53,6 +60,8 @@ export interface ProviderRegistryEntry {
   thinkingBudgetModels?: string[];
   escapeBuiltinToolNames?: boolean;
   oauthId?: string;
+  virtualModels?: Record<string, { wireModelId: string; reasoningMode: "pro" }>;
+  modelMaxInputTokens?: Record<string, number>;
   jawcodeBundle?: string;
   extraMetadataAliases?: string[];
   metadataModelIdNormalize?: MetadataModelIdNormalize;
@@ -63,9 +72,10 @@ export interface ProviderRegistryEntry {
 
 export type ProviderConfigSeed = Pick<
   OcxProviderConfig,
-  "adapter" | "baseUrl" | "authMode" | "keyOptional" | "modelSuffixBracketStrip" | "defaultModel" | "models"
+  "adapter" | "baseUrl" | "authMode" | "keyOptional" | "freeTier" | "modelSuffixBracketStrip" | "defaultModel" | "models"
   | "liveModels" | "contextWindow" | "modelContextWindows" | "modelInputModalities"
-  | "reasoningEfforts" | "modelReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap"
+  | "modelMaxInputTokens"
+  | "reasoningEfforts" | "modelReasoningEfforts" | "modelDefaultReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap"
   | "noVisionModels" | "noReasoningModels" | "noTemperatureModels" | "noTopPModels" | "noPenaltyModels"
   | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "thinkingToggleModels" | "thinkingBudgetModels" | "escapeBuiltinToolNames"
   | "googleMode" | "project" | "location" | "headers"
@@ -92,13 +102,29 @@ const MINIMAX_MODELS = [
 const MINIMAX_MODEL_CONTEXT_WINDOWS: Record<string, number> = Object.fromEntries(
   MINIMAX_MODELS.map(id => [id, id === "MiniMax-M3" ? 1_000_000 : 204_800]),
 );
-const OPENAI_GPT56_MODELS = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"];
-const OPENAI_GPT56_CONTEXT_WINDOW = 372_000;
+const OPENAI_GPT56_MODELS = ["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"];
+const OPENAI_GPT56_PRO_MODELS = ["gpt-5.6-sol-pro", "gpt-5.6-terra-pro", "gpt-5.6-luna-pro"];
+const OPENAI_API_GPT56_CONTEXT_WINDOW = 1_050_000;
+const OPENAI_CODEX_GPT56_CONTEXT_WINDOW = 372_000;
 const OPENAI_GPT56_CONTEXT_WINDOWS = {
-  "gpt-5.6-sol": OPENAI_GPT56_CONTEXT_WINDOW,
-  "gpt-5.6-terra": OPENAI_GPT56_CONTEXT_WINDOW,
-  "gpt-5.6-luna": OPENAI_GPT56_CONTEXT_WINDOW,
+  "gpt-5.6-sol": OPENAI_CODEX_GPT56_CONTEXT_WINDOW,
+  "gpt-5.6-terra": OPENAI_CODEX_GPT56_CONTEXT_WINDOW,
+  "gpt-5.6-luna": OPENAI_CODEX_GPT56_CONTEXT_WINDOW,
 };
+const OPENAI_API_GPT56_CONTEXT_WINDOWS: Record<string, number> = {
+  ...Object.fromEntries([...OPENAI_GPT56_MODELS, ...OPENAI_GPT56_PRO_MODELS].map(id => [id, OPENAI_API_GPT56_CONTEXT_WINDOW])),
+  "gpt-5.5": OPENAI_API_GPT56_CONTEXT_WINDOW,
+};
+const OPENAI_API_GPT56_MAX_INPUT_TOKENS: Record<string, number> = {
+  ...Object.fromEntries([...OPENAI_GPT56_MODELS, ...OPENAI_GPT56_PRO_MODELS].map(id => [id, 922_000])),
+  "gpt-5.5": 922_000,
+};
+const OPENAI_API_GPT56_VIRTUAL_MODELS: Record<string, { wireModelId: string; reasoningMode: "pro" }> = {
+  "gpt-5.6-sol-pro": { wireModelId: "gpt-5.6-sol", reasoningMode: "pro" },
+  "gpt-5.6-terra-pro": { wireModelId: "gpt-5.6-terra", reasoningMode: "pro" },
+  "gpt-5.6-luna-pro": { wireModelId: "gpt-5.6-luna", reasoningMode: "pro" },
+};
+const OPENAI_API_GPT56_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 const OPENROUTER_GPT56_MODELS = OPENAI_GPT56_MODELS.map(id => `openai/${id}`);
 // OpenRouter's live /endpoints routes report 1,050,000; keep this separate from the
 // unverified OpenAI API-key seed. Evidence: devlog/_plan/260710_provider_hardening/003_research_aggregators.md.
@@ -161,8 +187,23 @@ const KIMI_CODING_MODELS = [...KIMI_CODING_K3_MODELS, ...KIMI_LEGACY_API_MODELS,
 const KIMI_THINKING_MODELS = KIMI_CODING_MODELS;
 const KIMI_CODING_NO_REASONING_MODELS = KIMI_CODING_MODELS.filter(id => !KIMI_CODING_K3_MODELS.includes(id));
 const KIMI_API_NO_REASONING_MODELS = KIMI_API_MODELS.filter(id => id !== "kimi-k3");
+const KIMI_CODING_K3_REASONING_EFFORTS = ["low", "high", "max"];
+const KIMI_CODING_K3_REASONING_EFFORT_MAP: Record<string, string> = {
+  none: "none",
+  low: "low",
+  medium: "high",
+  high: "high",
+  xhigh: "max",
+  max: "max",
+};
 const KIMI_CODING_REASONING_EFFORTS = Object.fromEntries(
-  KIMI_CODING_MODELS.map(id => [id, KIMI_CODING_K3_MODELS.includes(id) ? ["max"] : []]),
+  KIMI_CODING_MODELS.map(id => [id, KIMI_CODING_K3_MODELS.includes(id) ? KIMI_CODING_K3_REASONING_EFFORTS : []]),
+);
+const KIMI_CODING_DEFAULT_REASONING_EFFORTS = Object.fromEntries(
+  KIMI_CODING_K3_MODELS.map(id => [id, "max"]),
+);
+const KIMI_CODING_REASONING_EFFORT_MAPS = Object.fromEntries(
+  KIMI_CODING_K3_MODELS.map(id => [id, KIMI_CODING_K3_REASONING_EFFORT_MAP]),
 );
 const KIMI_API_REASONING_EFFORTS = Object.fromEntries(
   KIMI_API_MODELS.map(id => [id, id === "kimi-k3" ? ["max"] : []]),
@@ -221,12 +262,13 @@ const UMANS_MODEL_INPUT_MODALITIES: Record<string, string[]> = Object.fromEntrie
 export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   {
     id: "openai",
-    label: "OpenAI (ChatGPT login)",
+    label: "OpenAI (Codex login)",
     adapter: "openai-responses",
     baseUrl: "https://chatgpt.com/backend-api/codex",
     authKind: "forward",
+    codexAccountMode: "pool",
     featured: true,
-    note: "Uses your codex login — no API key",
+    note: "Codex login account pool (default) or Direct main-account mode via codexAccountMode",
   },
   {
     id: "cursor",
@@ -270,20 +312,21 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     // 260709 refresh: lineup + metadata from official docs.x.ai (grok-4.5 announced 07-08);
     // grok-composer-2.5-fast kept as account-verified (absent from public docs). Evidence:
     // devlog/model_update/260709_model_refresh/001_xai_lineup.md.
-    models: ["grok-4.5", "grok-4.3", "grok-4.20-multi-agent-0309", "grok-4.20-0309-reasoning", "grok-4.20-0309-non-reasoning", "grok-build-0.1", "grok-composer-2.5-fast"],
+    // grok-4.20-multi-agent-0309 is intentionally absent: the OAuth chat-completions
+    // transport returns 400 ("Multi Agent requests are not allowed on chat completions").
+    models: ["grok-4.5", "grok-4.3", "grok-4.20-0309-reasoning", "grok-4.20-0309-non-reasoning", "grok-build-0.1", "grok-composer-2.5-fast"],
     defaultModel: "grok-4.5",
     noReasoningModels: ["grok-4.20-0309-non-reasoning", "grok-build-0.1", "grok-composer-2.5-fast"],
     // Replay assistant reasoning_content for grok reasoning models: xAI documents dropped
     // reasoning_content as the top cause of prompt-cache misses on multi-turn conversations
     // (docs.x.ai prompt-caching/multi-turn, verified 2026-07-13 — devlog/_plan/260713_grok_caching).
     // Models that never emit reasoning simply have no thinking parts to replay (no-op).
-    preserveReasoningContentModels: ["grok-4.5", "grok-4.3", "grok-4.20-multi-agent-0309", "grok-4.20-0309-reasoning"],
+    preserveReasoningContentModels: ["grok-4.5", "grok-4.3", "grok-4.20-0309-reasoning"],
     // grok-4.5 reasoning is always-on with low/medium/high control (no off tier upstream).
     modelReasoningEfforts: { "grok-4.5": ["low", "medium", "high"] },
     modelContextWindows: {
       "grok-4.5": 500_000,
       "grok-4.3": 1_000_000,
-      "grok-4.20-multi-agent-0309": 1_000_000,
       "grok-4.20-0309-reasoning": 1_000_000,
       "grok-4.20-0309-non-reasoning": 1_000_000,
       "grok-build-0.1": 256_000,
@@ -335,9 +378,11 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     defaultModel: "kimi-k2.7-code",
     modelContextWindows: KIMI_CODING_MODEL_CONTEXT_WINDOWS,
     modelInputModalities: KIMI_CODING_MODEL_INPUT_MODALITIES,
-    // K3 accepts reasoning_effort=max; older Kimi models use Kimi's private thinking control.
+    // K3 accepts low/high/max; Codex aliases are normalized by the model-scoped wire map.
     noReasoningModels: KIMI_CODING_NO_REASONING_MODELS,
     modelReasoningEfforts: KIMI_CODING_REASONING_EFFORTS,
+    modelDefaultReasoningEfforts: KIMI_CODING_DEFAULT_REASONING_EFFORTS,
+    modelReasoningEffortMap: KIMI_CODING_REASONING_EFFORT_MAPS,
     noTemperatureModels: KIMI_LOCKED_PARAMETER_MODELS,
     noTopPModels: KIMI_LOCKED_PARAMETER_MODELS,
     noPenaltyModels: KIMI_LOCKED_PARAMETER_MODELS,
@@ -354,11 +399,35 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     note: "Import-first: reuses your installed kiro-cli login (no browser). Experimental third-party harness — see Kiro ToS.",
     models: KIRO_MODELS,
     defaultModel: "kiro-auto",
+    // Kiro speaks CodeWhisperer wire, not OpenAI-style GET /models. Keep the static
+    // catalog authoritative so a spurious 2xx from runtime.../models cannot drop seeded ids
+    // (e.g. newly listed GPT-5.6 tiers) via live-discovery reconciliation.
+    liveModels: false,
     // Per-model context metadata is maintained next to the Kiro model list.
     modelContextWindows: KIRO_MODEL_CONTEXT_WINDOWS,
     modelReasoningEfforts: KIRO_MODEL_REASONING_EFFORTS,
   },
-  { id: "openai-apikey", label: "OpenAI (API key)", adapter: "openai-responses", baseUrl: "https://api.openai.com/v1", authKind: "key", featured: true, dashboardUrl: "https://platform.openai.com/api-keys", defaultModel: "gpt-5.5", models: ["gpt-5.5", ...OPENAI_GPT56_MODELS], liveModels: true, modelContextWindows: OPENAI_GPT56_CONTEXT_WINDOWS },
+  {
+    id: "openai-apikey",
+    label: "OpenAI API",
+    adapter: "openai-responses",
+    baseUrl: "https://api.openai.com/v1",
+    authKind: "key",
+    featured: true,
+    dashboardUrl: "https://platform.openai.com/api-keys",
+    defaultModel: "gpt-5.5",
+    models: ["gpt-5.5", ...OPENAI_GPT56_MODELS, ...OPENAI_GPT56_PRO_MODELS],
+    liveModels: true,
+    modelContextWindows: OPENAI_API_GPT56_CONTEXT_WINDOWS,
+    modelMaxInputTokens: OPENAI_API_GPT56_MAX_INPUT_TOKENS,
+    modelInputModalities: Object.fromEntries(
+      ["gpt-5.5", ...OPENAI_GPT56_MODELS, ...OPENAI_GPT56_PRO_MODELS].map(id => [id, ["text", "image"]]),
+    ),
+    modelReasoningEfforts: Object.fromEntries(
+      [...OPENAI_GPT56_MODELS, ...OPENAI_GPT56_PRO_MODELS].map(id => [id, OPENAI_API_GPT56_REASONING_EFFORTS]),
+    ),
+    virtualModels: OPENAI_API_GPT56_VIRTUAL_MODELS,
+  },
   {
     id: "umans",
     label: "Umans AI Coding Plan",
@@ -387,17 +456,22 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     id: "opencode-go", label: "opencode go", adapter: "openai-chat", baseUrl: "https://opencode.ai/zen/go/v1",
     authKind: "key", featured: true, dashboardUrl: "https://opencode.ai/auth", defaultModel: "kimi-k2.7-code",
     jawcodeBundle: "opencode-go", note: "GLM, DeepSeek, Kimi, Qwen, MiMo…",
+    modelContextWindows: { "kimi-k3": KIMI_K3_STANDARD_CONTEXT_WINDOW },
+    modelInputModalities: { "kimi-k3": ["text", "image"] },
     modelReasoningEfforts: {
       "glm-5.2": ZAI_GLM_52_REASONING_EFFORTS,
+      "kimi-k3": KIMI_CODING_K3_REASONING_EFFORTS,
       "kimi-k2.7-code": [],
       "kimi-k2.7-code-highspeed": [],
       ...Object.fromEntries(OPENCODE_GO_THINKING_TOGGLE_MODELS.map(id => [id, THINKING_TOGGLE_EFFORTS])),
       ...Object.fromEntries(OPENCODE_GO_THINKING_BUDGET_MODELS.map(id => [id, THINKING_BUDGET_EFFORTS])),
       ...Object.fromEntries(DEEPSEEK_THINKING_MODELS.map(id => [id, DEEPSEEK_THINKING_EFFORTS])),
     },
+    modelDefaultReasoningEfforts: { "kimi-k3": "max" },
     // glm-5.2 uses identity labels now that `max` is a native Codex level (no alias map);
     // the thinking-toggle map is a REAL wire alias (effort -> enabled/disabled) and stays.
     modelReasoningEffortMap: {
+      "kimi-k3": KIMI_CODING_K3_REASONING_EFFORT_MAP,
       ...Object.fromEntries(OPENCODE_GO_THINKING_TOGGLE_MODELS.map(id => [id, THINKING_TOGGLE_MAP])),
       ...Object.fromEntries(DEEPSEEK_THINKING_MODELS.map(id => [id, DEEPSEEK_THINKING_REASONING_MAP])),
     },
@@ -414,12 +488,12 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
       "minimax-m2.5", "minimax-m2.7",
       "qwen3.7-max",
     ],
-    noTemperatureModels: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
-    noTopPModels: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
-    noPenaltyModels: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
+    noTemperatureModels: ["kimi-k3", "kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
+    noTopPModels: ["kimi-k3", "kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
+    noPenaltyModels: ["kimi-k3", "kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
     autoToolChoiceOnlyModels: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
     // Issue #78: DeepSeek V4 thinking mode requires reasoning_content replay on tool-call turns.
-    preserveReasoningContentModels: ["glm-5.2", "kimi-k2.7-code", "kimi-k2.7-code-highspeed", ...DEEPSEEK_THINKING_MODELS],
+    preserveReasoningContentModels: ["glm-5.2", "kimi-k3", "kimi-k2.7-code", "kimi-k2.7-code-highspeed", ...DEEPSEEK_THINKING_MODELS],
   },
   {
     id: "neuralwatt",
@@ -544,10 +618,13 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   //   its working reasoning_effort. Future kimi ids must be appended individually.
   {
     id: "nvidia", label: "NVIDIA NIM", baseUrl: "https://integrate.api.nvidia.com/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://build.nvidia.com",
+    // Free pricing, but an API key is still required (free key from build.nvidia.com).
+    freeTier: true,
     parallelToolCalls: false,
     noReasoningModels: NVIDIA_NIM_KIMI_MODELS,
     modelReasoningEfforts: Object.fromEntries(NVIDIA_NIM_KIMI_MODELS.map(id => [id, []])),
     preserveReasoningContentModels: NVIDIA_NIM_KIMI_THINKING_MODELS,
+    note: "Free tier on NVIDIA NIM — API key still required (get a free key at build.nvidia.com).",
   },
   { id: "venice", label: "Venice", baseUrl: "https://api.venice.ai/api/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://venice.ai/settings/api" },
   // 260710 GLM-5.2 context and path-specific ids: Tier-2 evidence in
@@ -628,6 +705,8 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     modelInputModalities: KIMI_CODING_MODEL_INPUT_MODALITIES,
     noReasoningModels: KIMI_CODING_NO_REASONING_MODELS,
     modelReasoningEfforts: KIMI_CODING_REASONING_EFFORTS,
+    modelDefaultReasoningEfforts: KIMI_CODING_DEFAULT_REASONING_EFFORTS,
+    modelReasoningEffortMap: KIMI_CODING_REASONING_EFFORT_MAPS,
     noTemperatureModels: KIMI_LOCKED_PARAMETER_MODELS,
     noTopPModels: KIMI_LOCKED_PARAMETER_MODELS,
     noPenaltyModels: KIMI_LOCKED_PARAMETER_MODELS,
@@ -682,6 +761,19 @@ export function getProviderRegistryEntry(id: string): ProviderRegistryEntry | un
   return PROVIDER_REGISTRY.find(entry => entry.id === id);
 }
 
+/**
+ * Effective Codex account mode for a provider. For canonical `openai`, a valid persisted
+ * `codexAccountMode` on the provider config wins and a missing/invalid value defaults to
+ * `"pool"`. Other providers keep registry-only metadata (there is no mode for `openai-apikey`).
+ */
+export function providerCodexAccountMode(id: string, provider?: OcxProviderConfig): CodexAccountMode | undefined {
+  const registryMode = getProviderRegistryEntry(id)?.codexAccountMode;
+  if (id !== "openai") return registryMode;
+  const persisted = provider?.codexAccountMode;
+  if (persisted === "pool" || persisted === "direct") return persisted;
+  return registryMode ?? "pool";
+}
+
 /**
  * Effective Google wire mode for a provider: config value, else registry backfill (a saved
  * key-login config may omit `googleMode` — mirrors the router's backfill), else "ai-studio"

package/src/reasoning-effort.ts

@@ -58,23 +58,24 @@ export function sanitizeCodexReasoningEfforts(efforts: readonly string[] | undef
 export function configuredReasoningEfforts(provider: OcxProviderConfig, modelId: string): string[] | undefined {
   if (modelInList(provider.noReasoningModels, modelId)) return [];
   const modelEfforts = modelRecordValue(provider.modelReasoningEfforts, modelId);
-  if (modelEfforts !== undefined) return healMaxTier(provider, modelId, sanitizeCodexReasoningEfforts(modelEfforts) ?? []);
-  if (provider.reasoningEfforts !== undefined) return healMaxTier(provider, modelId, sanitizeCodexReasoningEfforts(provider.reasoningEfforts) ?? []);
+  if (modelEfforts !== undefined) return healMappedTiers(provider, modelId, sanitizeCodexReasoningEfforts(modelEfforts) ?? []);
+  if (provider.reasoningEfforts !== undefined) return healMappedTiers(provider, modelId, sanitizeCodexReasoningEfforts(provider.reasoningEfforts) ?? []);
   return undefined;
 }
 
 /**
- * Stale-ladder self-heal: saved configs seeded before `max` became a native Codex level can
- * advertise a ladder that stops at `xhigh` while the wire map already routes xhigh -> max
- * (e.g. opencode-go glm-5.2, deepseek thinking models). When the map proves the provider
- * accepts wire `max`, append `max` so the picker actually shows the top tier. Thinking-toggle
- * maps (xhigh -> "enabled") never match, so binary-toggle models stay two-step.
+ * Stale-ladder self-heal: a registry wire map is authoritative evidence of the upstream tiers
+ * it can emit. Merge Codex-native map values into an older persisted ladder so newly documented
+ * tiers appear without rewriting the user's config. Non-Codex values such as enabled/disabled
+ * and Kimi's none sentinel are ignored here; they remain request-only wire aliases.
  */
-function healMaxTier(provider: OcxProviderConfig, modelId: string, efforts: string[]): string[] {
-  if (efforts.includes("max") || !efforts.includes("xhigh")) return efforts;
+function healMappedTiers(provider: OcxProviderConfig, modelId: string, efforts: string[]): string[] {
+  if (efforts.length === 0) return efforts;
   const wireMap = reasoningEffortMapFor(provider, modelId);
-  if (wireMap?.xhigh !== "max" && wireMap?.max !== "max") return efforts;
-  return sanitizeCodexReasoningEfforts([...efforts, "max"]) ?? efforts;
+  if (!wireMap) return efforts;
+  const mappedTiers = Object.values(wireMap).filter(isCodexReasoningEffort);
+  if (mappedTiers.length === 0) return efforts;
+  return sanitizeCodexReasoningEfforts([...efforts, ...mappedTiers]) ?? efforts;
 }
 
 function requestToCodexEffort(requested: string): string | undefined {

package/src/router.ts

@@ -1,12 +1,16 @@
-import type { OcxConfig, OcxProviderConfig } from "./types";
+import type { CodexAccountMode, OcxConfig, OcxProviderConfig } from "./types";
+import { COMBO_NAMESPACE, tryPickComboModel, type ComboPick } from "./combos";
 import { hasOwnProvider, resolveEnvValue } from "./config";
 import { assertProviderDestinationAllowed } from "./lib/destination-policy";
-import { PROVIDER_REGISTRY } from "./providers/registry";
+import { PROVIDER_REGISTRY, providerCodexAccountMode } from "./providers/registry";
+import { LEGACY_CHATGPT_PROVIDER_ID, LEGACY_OPENAI_MULTI_PROVIDER_ID, OPENAI_API_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID } from "./providers/openai-tiers";
 
-interface RouteResult {
+export interface RouteResult {
   providerName: string;
   provider: OcxProviderConfig;
   modelId: string;
+  codexAccountMode?: CodexAccountMode;
+  combo?: ComboPick;
 }
 
 const MODEL_PROVIDER_PATTERNS: Array<{ providerNames: string[]; prefixes: string[] }> = [
@@ -16,12 +20,6 @@ const MODEL_PROVIDER_PATTERNS: Array<{ providerNames: string[]; prefixes: string
     "claude-", "claude-sonnet-", "claude-opus-", "claude-haiku-",
     ],
   },
-  {
-    providerNames: ["openai", "chatgpt", "openai-apikey"],
-    prefixes: [
-    "gpt-", "o1-", "o3-", "o4-",
-    ],
-  },
   {
     providerNames: ["groq"],
     prefixes: [
@@ -67,6 +65,18 @@ function mergeRecordFill<T>(
   return { ...(seed ?? {}), ...(user ?? {}) };
 }
 
+function mergePositiveNumberCaps(
+  seed: Record<string, number> | undefined,
+  user: Record<string, number> | undefined,
+): Record<string, number> | undefined {
+  if (!seed && !user) return undefined;
+  const out = { ...(seed ?? {}) };
+  for (const [key, value] of Object.entries(user ?? {})) {
+    out[key] = typeof out[key] === "number" ? Math.min(out[key]!, value) : value;
+  }
+  return out;
+}
+
 function mergeStringArrayRecord(
   seed: Record<string, string[]> | undefined,
   user: Record<string, string[]> | undefined,
@@ -95,8 +105,14 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
   const reasoningEffortMap = mergeRecord(registryEntry.reasoningEffortMap, provider.reasoningEffortMap);
   const modelReasoningEffortMap = mergeNestedRecord(registryEntry.modelReasoningEffortMap, provider.modelReasoningEffortMap);
   const modelReasoningEfforts = mergeStringArrayRecord(registryEntry.modelReasoningEfforts, provider.modelReasoningEfforts);
-  const modelContextWindows = mergeRecordFill(registryEntry.modelContextWindows, provider.modelContextWindows);
+  const modelDefaultReasoningEfforts = mergeRecordFill(registryEntry.modelDefaultReasoningEfforts, provider.modelDefaultReasoningEfforts);
+  const modelContextWindows = providerName === OPENAI_API_PROVIDER_ID
+    ? mergePositiveNumberCaps(registryEntry.modelContextWindows, provider.modelContextWindows)
+    : mergeRecordFill(registryEntry.modelContextWindows, provider.modelContextWindows);
   const modelInputModalities = mergeRecordFill(registryEntry.modelInputModalities, provider.modelInputModalities);
+  const modelMaxInputTokens = providerName === OPENAI_API_PROVIDER_ID
+    ? mergePositiveNumberCaps(registryEntry.modelMaxInputTokens, provider.modelMaxInputTokens)
+    : mergeRecordFill(registryEntry.modelMaxInputTokens, provider.modelMaxInputTokens);
   const noVisionModels = mergeStringArray(registryEntry.noVisionModels, provider.noVisionModels);
   const noReasoningModels = mergeStringArray(registryEntry.noReasoningModels, provider.noReasoningModels);
   const noTemperatureModels = mergeStringArray(registryEntry.noTemperatureModels, provider.noTemperatureModels);
@@ -140,7 +156,9 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
     ...(provider.parallelToolCalls === undefined && registryEntry.parallelToolCalls !== undefined ? { parallelToolCalls: registryEntry.parallelToolCalls } : {}),
     ...(modelContextWindows ? { modelContextWindows } : {}),
     ...(modelInputModalities ? { modelInputModalities } : {}),
+    ...(modelMaxInputTokens ? { modelMaxInputTokens } : {}),
     ...(modelReasoningEfforts ? { modelReasoningEfforts } : {}),
+    ...(modelDefaultReasoningEfforts ? { modelDefaultReasoningEfforts } : {}),
     ...(reasoningEffortMap ? { reasoningEffortMap } : {}),
     ...(modelReasoningEffortMap ? { modelReasoningEffortMap } : {}),
     ...(noVisionModels ? { noVisionModels } : {}),
@@ -156,10 +174,44 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
 }
 
 function activeProviderEntries(config: OcxConfig): [string, OcxProviderConfig][] {
-  return Object.entries(config.providers).filter(([, provider]) => provider.disabled !== true);
+  return Object.entries(config.providers)
+    .filter(([name, provider]) => name !== LEGACY_CHATGPT_PROVIDER_ID && provider.disabled !== true);
+}
+
+export class NoEnabledOpenAiProviderError extends Error {
+  constructor(modelId: string) {
+    super(`No enabled canonical OpenAI provider for model: ${modelId}`);
+    this.name = "NoEnabledOpenAiProviderError";
+  }
+}
+
+function isBareOpenAiFamilyModel(modelId: string): boolean {
+  return !modelId.includes("/") && /^(?:gpt-|o1-|o3-|o4-)/.test(modelId);
+}
+
+function routeResult(providerName: string, provider: OcxProviderConfig, modelId: string): RouteResult {
+  const codexAccountMode = providerCodexAccountMode(providerName, provider);
+  return {
+    providerName,
+    provider: routedProviderConfig(providerName, provider),
+    modelId,
+    ...(codexAccountMode ? { codexAccountMode } : {}),
+  };
 }
 
 export function routeModel(config: OcxConfig, modelId: string): RouteResult {
+  const preservePhysicalComboProvider =
+    hasOwnProvider(config.providers, COMBO_NAMESPACE)
+    && Object.keys(config.combos ?? {}).length === 0;
+  if (!preservePhysicalComboProvider) {
+    const combo = tryPickComboModel(config, modelId);
+    if (combo) {
+      const concrete = `${combo.target.provider}/${combo.target.model}`;
+      const routed = routeModel(config, concrete);
+      return { ...routed, combo };
+    }
+  }
+
   // 0. Explicit "<provider>/<model>" namespace (e.g. "opencode-go/deepseek-v4-pro").
   //    Only triggers when the prefix matches a CONFIGURED provider, so genuine
   //    slash-containing model ids (e.g. "anthropic/claude-...") fall through when
@@ -167,24 +219,25 @@ export function routeModel(config: OcxConfig, modelId: string): RouteResult {
   const slash = modelId.indexOf("/");
   if (slash > 0) {
     const provName = modelId.slice(0, slash);
+    if (provName === LEGACY_CHATGPT_PROVIDER_ID || provName === LEGACY_OPENAI_MULTI_PROVIDER_ID) {
+      throw new Error(`No provider configured for model: ${modelId}`);
+    }
     if (hasOwnProvider(config.providers, provName)) {
       const prov = config.providers[provName];
       if (prov.disabled === true) throw new Error(`Provider is disabled: ${provName}`);
-      return {
-        providerName: provName,
-        provider: routedProviderConfig(provName, prov),
-        modelId: modelId.slice(slash + 1),
-      };
+      return routeResult(provName, prov, modelId.slice(slash + 1));
     }
   }
 
+  if (isBareOpenAiFamilyModel(modelId)) {
+    const provider = config.providers[OPENAI_CODEX_PROVIDER_ID];
+    if (provider && provider.disabled !== true) return routeResult(OPENAI_CODEX_PROVIDER_ID, provider, modelId);
+    throw new NoEnabledOpenAiProviderError(modelId);
+  }
+
   for (const [provName, prov] of activeProviderEntries(config)) {
     if (prov.defaultModel === modelId) {
-      return {
-        providerName: provName,
-        provider: routedProviderConfig(provName, prov),
-        modelId,
-      };
+      return routeResult(provName, prov, modelId);
     }
   }
 
@@ -193,22 +246,17 @@ export function routeModel(config: OcxConfig, modelId: string): RouteResult {
 
   for (const [provName, prov] of activeProviderEntries(config)) {
     if (prov.models && Array.isArray(prov.models) && (prov.models as string[]).includes(modelId)) {
-      return {
-        providerName: provName,
-        provider: routedProviderConfig(provName, prov),
-        modelId,
-      };
+      return routeResult(provName, prov, modelId);
     }
   }
 
+  if (config.defaultProvider === LEGACY_CHATGPT_PROVIDER_ID) {
+    throw new Error(`No provider configured for model: ${modelId}`);
+  }
   if (hasOwnProvider(config.providers, config.defaultProvider)) {
     const defaultProv = config.providers[config.defaultProvider];
     if (defaultProv.disabled === true) throw new Error(`Default provider is disabled: ${config.defaultProvider}`);
-    return {
-      providerName: config.defaultProvider,
-      provider: routedProviderConfig(config.defaultProvider, defaultProv),
-      modelId,
-    };
+    return routeResult(config.defaultProvider, defaultProv, modelId);
   }
 
   throw new Error(`No provider configured for model: ${modelId}`);
@@ -222,11 +270,7 @@ function routeByKnownModelPattern(config: OcxConfig, modelId: string): RouteResu
       );
       if (matchingProvider) {
         const [provName, prov] = matchingProvider;
-        return {
-          providerName: provName,
-          provider: routedProviderConfig(provName, prov),
-          modelId,
-        };
+        return routeResult(provName, prov, modelId);
       }
     }
   }

package/src/server/auth-cors.ts

@@ -2,11 +2,13 @@ import { timingSafeEqual } from "node:crypto";
 import { formatErrorResponse } from "../bridge";
 import {
   codexAutoStartEnabled,
+  positiveIntegerRecordConfigError,
   providerBaseUrlConfigError,
   providerHeadersConfigError,
 } from "../config";
 import { providerDestinationConfigError } from "../lib/destination-policy";
-import { getProviderRegistryEntry } from "../providers/registry";
+import { getProviderRegistryEntry, providerCodexAccountMode } from "../providers/registry";
+import { providerConfigSeed } from "../providers/derive";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 
 let _corsOrigin = "http://localhost:10100";
@@ -139,6 +141,18 @@ export function isProxyAdmissionSecret(token: string, config: OcxConfig): boolea
   return false;
 }
 
+export class ForwardAdmissionCredentialError extends Error {
+  constructor() {
+    super("OpenCodex admission credentials cannot be forwarded upstream");
+    this.name = "ForwardAdmissionCredentialError";
+  }
+}
+
+export function validateForwardAdmissionCredential(headers: Headers, config: OcxConfig): void {
+  const bearer = headers.get("authorization")?.replace(/^Bearer\s+/i, "").trim();
+  if (bearer && isProxyAdmissionSecret(bearer, config)) throw new ForwardAdmissionCredentialError();
+}
+
 export function hasValidApiAuth(req: Request, config: OcxConfig): boolean {
   if (!isApiAuthRequired(config)) return true;
   const actual = req.headers.get("x-opencodex-api-key")?.trim()
@@ -155,18 +169,77 @@ export function requireApiAuth(req: Request, config: OcxConfig, kind: "managemen
   return formatErrorResponse(401, "authentication_error", "opencodex API key required");
 }
 
-export function providerManagementConfigError(name: string, provider: OcxProviderConfig): string | null {
-  const baseUrlError = providerBaseUrlConfigError(provider.baseUrl);
+/**
+ * Admission for OpenAI Responses transports whose Authorization header belongs to
+ * Codex Direct. Remote binds must use the dedicated proxy header so the two bearer
+ * domains can never be confused.
+ */
+export function requireResponsesApiAuth(req: Request, config: OcxConfig): Response | null {
+  if (!isApiAuthRequired(config)) return null;
+  const actual = req.headers.get("x-opencodex-api-key")?.trim();
+  if (actual && isProxyAdmissionSecret(actual, config)) return null;
+  return formatErrorResponse(401, "authentication_error", "opencodex API key required");
+}
+
+const FORBIDDEN_PROVIDER_RUNTIME_FIELDS = [
+  "virtualModels", "codexAuthContext", "selectedForwardHeaders",
+  "sidecarOutcomeRecorder", "_codexAccountOverride", "_codexAccountRequired",
+] as const;
+
+function sameCanonicalProviderSeed(actual: Record<string, unknown>, expected: OcxProviderConfig): boolean {
+  const actualKeys = Object.keys(actual).sort();
+  const expectedKeys = Object.keys(expected).sort();
+  if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, i) => key !== expectedKeys[i])) return false;
+  return actualKeys.every(key => JSON.stringify(actual[key]) === JSON.stringify((expected as unknown as Record<string, unknown>)[key]));
+}
+
+export function providerManagementConfigError(name: unknown, provider: unknown): string | null {
+  if (typeof name !== "string" || !provider || typeof provider !== "object" || Array.isArray(provider)) {
+    return "provider must be a plain object";
+  }
+  const raw = provider as Record<string, unknown>;
+  for (const field of FORBIDDEN_PROVIDER_RUNTIME_FIELDS) {
+    if (Object.hasOwn(raw, field)) return `provider ${name} must not include runtime field "${field}"`;
+  }
+  if (name === "chatgpt") return "provider chatgpt is reserved for internal credential compatibility";
+  if (name === "openai-multi") return "provider openai-multi is reserved for legacy config migration";
+  if (name === "openai") {
+    const entry = getProviderRegistryEntry(name);
+    const seed = entry ? providerConfigSeed(entry) : undefined;
+    if (!Object.hasOwn(raw, "codexAccountMode") || (raw.codexAccountMode !== "pool" && raw.codexAccountMode !== "direct")) {
+      return "provider openai codexAccountMode must be pool or direct";
+    }
+    if (seed) seed.codexAccountMode = raw.codexAccountMode;
+    const canonical = seed && sameCanonicalProviderSeed(raw, seed);
+    if (!canonical) {
+      return `provider ${name} must equal the canonical built-in provider seed`;
+    }
+  } else if (Object.hasOwn(raw, "codexAccountMode")) {
+    return `provider ${name} must not include codexAccountMode`;
+  }
+  const typed = provider as unknown as OcxProviderConfig;
+  const baseUrlError = providerBaseUrlConfigError(typed.baseUrl);
   if (baseUrlError) return `provider ${name} ${baseUrlError}`;
-  const destinationError = providerDestinationConfigError(name, provider);
+  const destinationError = providerDestinationConfigError(name, typed);
   if (destinationError) return `provider ${name} ${destinationError}`;
-  const headersError = providerHeadersConfigError(provider.headers);
+  const headersError = providerHeadersConfigError(typed.headers);
   if (headersError) return `provider ${name} ${headersError}`;
-  if (provider.authMode === "forward") {
+  const maxInputError = positiveIntegerRecordConfigError(raw.modelMaxInputTokens, "modelMaxInputTokens");
+  if (maxInputError) return `provider ${name} ${maxInputError}`;
+  if (typed.authMode === "local") {
+    // "local" bypasses key-requirement enforcement (api-keys/key-failover treat non-oauth/
+    // forward as key auth; openai-chat skips credential checks for local). Only providers
+    // whose registry entry is genuinely local (Ollama/vLLM/LM Studio) may claim it.
+    const entry = getProviderRegistryEntry(name);
+    if (entry && entry.authKind !== "local") {
+      return `provider ${name} cannot use authMode "local" — its registry entry requires ${entry.authKind} auth`;
+    }
+  }
+  if (typed.authMode === "forward") {
     const normalizedName = name.trim().toLowerCase();
-    const base = provider.baseUrl.replace(/\/+$/, "");
-    const isBuiltInChatGptForward = (normalizedName === "openai" || normalizedName === "chatgpt")
-      && provider.adapter === "openai-responses"
+    const base = typed.baseUrl.replace(/\/+$/, "");
+    const isBuiltInChatGptForward = normalizedName === "openai"
+      && typed.adapter === "openai-responses"
       && base === "https://chatgpt.com/backend-api/codex";
     if (isBuiltInChatGptForward) return null;
     return `provider ${name} uses reserved authMode "forward"; configure ChatGPT passthrough via the built-in provider`;
@@ -212,6 +285,7 @@ export function safeConfigDTO(config: OcxConfig): unknown {
       "allowPrivateNetwork",
       "authMode",
       "keyOptional",
+      "freeTier",
       "liveModels",
       "models",
       "contextWindow",
@@ -231,6 +305,8 @@ export function safeConfigDTO(config: OcxConfig): unknown {
     }
     const registryNote = getProviderRegistryEntry(name)?.note;
     if (typeof registryNote === "string" && registryNote.trim()) dto.note = registryNote;
+    const codexAccountMode = providerCodexAccountMode(name, provider);
+    if (codexAccountMode) dto.codexAccountMode = codexAccountMode;
     providers[name] = dto;
   }
   return {