feat: dynamic model list fetching from Codex backend (#9)

* feat: dynamic model list fetching from Codex backend

Replace static-only model loading with a hybrid approach:
- Static YAML models as fallback baseline
- Background fetcher probes /codex/models and /models endpoints
- Backend models merge into catalog (backend wins, YAML fills gaps)
- Aliases always from YAML (user-customizable)
- New /debug/models endpoint for diagnostics
- All fetch errors non-fatal — gracefully falls back to static models

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: PR #9 review issues + complete Codex model catalog

- Remove dead _backendModelCount variable from model-store
- Fix hot-reload wiping backend models: add triggerImmediateRefresh()
in model-fetcher, chain it in reloadAllConfigs()
- Fix premature "hot-reloaded" log message ordering in config.ts
- Gate raw model sample logging to first fetch only in codex-api
- Remove dead re-exports from routes/models.ts
- Expand getModels() to probe sentinel/chat-requirements + flatten
nested category responses
- Rename ClaudeCodeSetup → AnthropicSetup with dynamic model dropdown
- Update translations (claudeCodeSetup → anthropicSetup)
- Complete Codex model catalog: 5.3/5.2/5.1 families with
base/high/mid/low/max/mini variants (23 static Codex models)
- Default model changed to gpt-5.2-codex, alias codex → gpt-5.2-codex

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: address PR #9 review issues

- Fix dead code in getModels(): scope flattened array per endpoint probe
- Replace async lazy imports in reloadAllConfigs() with direct sync imports
- Fix reasoning efforts merge using explicit flag instead of length > 1
- Add try/finally in scheduleNext() to prevent refresh loop from stopping
- Suppress noisy warn when unauthenticated by checking isAuthenticated()
- Return shallow copies from getModelCatalog()/getModelAliases()
- Rename ClaudeCodeSetup.tsx → AnthropicSetup.tsx to match export
- Use 'codex' alias instead of hardcoded 'gpt-5.2-codex' in use-status

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: icebear0828 <icebear0828@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

config/default.yaml

@@ -9,7 +9,7 @@ client:
   arch: arm64
   chromium_version: "137"
 model:
-  default: gpt-5.3-codex
+  default: gpt-5.2-codex
   default_reasoning_effort: medium
   suppress_desktop_directives: true
 auth:

config/models.yaml

@@ -1,83 +1,301 @@
-# Codex model catalog — sourced from Codex Desktop `model/list`.
-# Updated by scripts/apply-update.ts when new versions are detected.
+# Codex model catalog
+#
+# Sources:
+#   1. Static (below) — Codex-specific models (not returned by /backend-api/models)
+#   2. Dynamic          — general ChatGPT models fetched from /backend-api/models
+#
+# Dynamic fetch merges with static; backend entries win for shared IDs.
 
 models:
-  - id: "gpt-5.3-codex"
-    displayName: "gpt-5.3-codex"
-    description: "Latest frontier agentic coding model."
+  # ── GPT-5.3 Codex family ──────────────────────────────────────────
+  - id: gpt-5.3-codex
+    displayName: GPT-5.3 Codex
+    description: Latest Codex flagship model
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.3-codex-high
+    displayName: GPT-5.3 Codex High
+    description: GPT-5.3 Codex — high reasoning tier
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: high
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.3-codex-mid
+    displayName: GPT-5.3 Codex Mid
+    description: GPT-5.3 Codex — mid reasoning tier
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.3-codex-low
+    displayName: GPT-5.3 Codex Low
+    description: GPT-5.3 Codex — low reasoning tier (fastest)
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+    defaultReasoningEffort: low
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.3-codex-max
+    displayName: GPT-5.3 Codex Max
+    description: GPT-5.3 Codex — extended context / deepest reasoning
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.3-codex-mini
+    displayName: GPT-5.3 Codex Mini
+    description: GPT-5.3 Codex — lightweight, low-latency
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+    defaultReasoningEffort: low
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  # ── GPT-5.2 Codex family ──────────────────────────────────────────
+  - id: gpt-5.2-codex
+    displayName: GPT-5.2 Codex
+    description: GPT-5.2 Codex flagship
     isDefault: true
     supportedReasoningEfforts:
-      - { reasoningEffort: "low", description: "Fast responses with lighter reasoning" }
-      - { reasoningEffort: "medium", description: "Balances speed and reasoning depth for everyday tasks" }
-      - { reasoningEffort: "high", description: "Greater reasoning depth for complex problems" }
-      - { reasoningEffort: "xhigh", description: "Extra high reasoning depth for complex problems" }
-    defaultReasoningEffort: "medium"
-    inputModalities: ["text", "image"]
-    supportsPersonality: true
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
     upgrade: null
 
-  - id: "gpt-5.2-codex"
-    displayName: "gpt-5.2-codex"
-    description: "Frontier agentic coding model."
+  - id: gpt-5.2-codex-high
+    displayName: GPT-5.2 Codex High
+    description: GPT-5.2 Codex — high reasoning tier
     isDefault: false
     supportedReasoningEfforts:
-      - { reasoningEffort: "low", description: "Fast responses with lighter reasoning" }
-      - { reasoningEffort: "medium", description: "Balances speed and reasoning depth for everyday tasks" }
-      - { reasoningEffort: "high", description: "Greater reasoning depth for complex problems" }
-      - { reasoningEffort: "xhigh", description: "Extra high reasoning depth for complex problems" }
-    defaultReasoningEffort: "medium"
-    inputModalities: ["text", "image"]
-    supportsPersonality: true
-    upgrade: "gpt-5.3-codex"
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: high
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.2-codex-mid
+    displayName: GPT-5.2 Codex Mid
+    description: GPT-5.2 Codex — mid reasoning tier
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
 
-  - id: "gpt-5.1-codex-max"
-    displayName: "gpt-5.1-codex-max"
-    description: "Codex-optimized flagship for deep and fast reasoning."
+  - id: gpt-5.2-codex-low
+    displayName: GPT-5.2 Codex Low
+    description: GPT-5.2 Codex — low reasoning tier (fastest)
     isDefault: false
     supportedReasoningEfforts:
-      - { reasoningEffort: "low", description: "Fast responses with lighter reasoning" }
-      - { reasoningEffort: "medium", description: "Balances speed and reasoning depth for everyday tasks" }
-      - { reasoningEffort: "high", description: "Greater reasoning depth for complex problems" }
-      - { reasoningEffort: "xhigh", description: "Extra high reasoning depth for complex problems" }
-    defaultReasoningEffort: "medium"
-    inputModalities: ["text", "image"]
+      - { reasoningEffort: low,    description: "Fastest responses" }
+    defaultReasoningEffort: low
+    inputModalities: [text]
     supportsPersonality: false
-    upgrade: "gpt-5.3-codex"
+    upgrade: null
+
+  - id: gpt-5.2-codex-max
+    displayName: GPT-5.2 Codex Max
+    description: GPT-5.2 Codex — extended context / deepest reasoning
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
 
-  - id: "gpt-5.2"
-    displayName: "gpt-5.2"
-    description: "Latest frontier model with improvements across knowledge, reasoning and coding."
+  - id: gpt-5.2-codex-mini
+    displayName: GPT-5.2 Codex Mini
+    description: GPT-5.2 Codex — lightweight, low-latency
     isDefault: false
     supportedReasoningEfforts:
-      - { reasoningEffort: "low", description: "Balances speed with some reasoning" }
-      - { reasoningEffort: "medium", description: "Solid balance of reasoning depth and latency" }
-      - { reasoningEffort: "high", description: "Maximizes reasoning depth for complex problems" }
-      - { reasoningEffort: "xhigh", description: "Extra high reasoning for complex problems" }
-    defaultReasoningEffort: "medium"
-    inputModalities: ["text", "image"]
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+    defaultReasoningEffort: low
+    inputModalities: [text]
     supportsPersonality: false
-    upgrade: "gpt-5.3-codex"
+    upgrade: null
+
+  # ── GPT-5.1 Codex family ──────────────────────────────────────────
+  - id: gpt-5.1-codex
+    displayName: GPT-5.1 Codex
+    description: GPT-5.1 Codex
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
 
-  - id: "gpt-5.1-codex-mini"
-    displayName: "gpt-5.1-codex-mini"
-    description: "Optimized for codex. Cheaper, faster, but less capable."
+  - id: gpt-5.1-codex-high
+    displayName: GPT-5.1 Codex High
+    description: GPT-5.1 Codex — high reasoning tier
     isDefault: false
     supportedReasoningEfforts:
-      - { reasoningEffort: "medium", description: "Dynamically adjusts reasoning based on the task" }
-      - { reasoningEffort: "high", description: "Maximizes reasoning depth for complex problems" }
-    defaultReasoningEffort: "medium"
-    inputModalities: ["text", "image"]
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: high
+    inputModalities: [text]
     supportsPersonality: false
-    upgrade: "gpt-5.3-codex"
+    upgrade: null
+
+  - id: gpt-5.1-codex-mid
+    displayName: GPT-5.1 Codex Mid
+    description: GPT-5.1 Codex — mid reasoning tier
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.1-codex-low
+    displayName: GPT-5.1 Codex Low
+    description: GPT-5.1 Codex — low reasoning tier (fastest)
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+    defaultReasoningEffort: low
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.1-codex-max
+    displayName: GPT-5.1 Codex Max
+    description: GPT-5.1 Codex — extended context / deepest reasoning
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5.1-codex-mini
+    displayName: GPT-5.1 Codex Mini
+    description: GPT-5.1 Codex Mini — lightweight, low-latency
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+    defaultReasoningEffort: low
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  # ── GPT-5 Codex (legacy) ──────────────────────────────────────────
+  - id: gpt-5-codex
+    displayName: GPT-5 Codex
+    description: Original GPT-5 Codex
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: medium, description: "Default" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  - id: gpt-5-codex-mini
+    displayName: GPT-5 Codex Mini
+    description: Original lightweight Codex
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: medium, description: "Default" }
+    defaultReasoningEffort: medium
+    inputModalities: [text]
+    supportsPersonality: false
+    upgrade: null
+
+  # ── Base GPT models (also usable via Codex endpoint) ───────────────
+  - id: gpt-5.3
+    displayName: GPT-5.3
+    description: General-purpose GPT-5.3
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text, image]
+    supportsPersonality: true
+    upgrade: null
+
+  - id: gpt-5.2
+    displayName: GPT-5.2
+    description: General-purpose GPT-5.2
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text, image]
+    supportsPersonality: true
+    upgrade: null
+
+  - id: gpt-5.1
+    displayName: GPT-5.1
+    description: General-purpose GPT-5.1
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: low,    description: "Fastest responses" }
+      - { reasoningEffort: medium, description: "Balanced speed and quality" }
+      - { reasoningEffort: high,   description: "Deepest reasoning" }
+    defaultReasoningEffort: medium
+    inputModalities: [text, image]
+    supportsPersonality: true
+    upgrade: null
+
+  - id: gpt-5
+    displayName: GPT-5
+    description: General-purpose GPT-5
+    isDefault: false
+    supportedReasoningEfforts:
+      - { reasoningEffort: medium, description: "Default" }
+    defaultReasoningEffort: medium
+    inputModalities: [text, image]
+    supportsPersonality: true
+    upgrade: null
 
 aliases:
-  codex: "gpt-5.3-codex"
-  codex-max: "gpt-5.1-codex-max"
-  codex-mini: "gpt-5.1-codex-mini"
-  # Claude Code model aliases
-  claude-opus-4-6: "gpt-5.3-codex"
-  claude-sonnet-4-6: "gpt-5.2-codex"
-  claude-haiku-4-5-20251001: "gpt-5.1-codex-mini"
-  opus: "gpt-5.3-codex"
-  sonnet: "gpt-5.2-codex"
-  haiku: "gpt-5.1-codex-mini"
+  codex: "gpt-5.2-codex"

src/config.ts

@@ -2,6 +2,8 @@ import { readFileSync } from "fs";
 import { resolve } from "path";
 import yaml from "js-yaml";
 import { z } from "zod";
+import { loadStaticModels } from "./models/model-store.js";
+import { triggerImmediateRefresh } from "./models/model-fetcher.js";
 
 const ConfigSchema = z.object({
   api: z.object({
@@ -17,7 +19,7 @@ const ConfigSchema = z.object({
     chromium_version: z.string().default("136"),
   }),
   model: z.object({
-    default: z.string().default("gpt-5.3-codex"),
+    default: z.string().default("gpt-5.2-codex"),
     default_reasoning_effort: z.string().default("medium"),
     suppress_desktop_directives: z.boolean().default(true),
   }),
@@ -148,9 +150,12 @@ export function reloadFingerprint(configDir?: string): FingerprintConfig {
   return _fingerprint;
 }
 
-/** Reload both config and fingerprint from disk. */
+/** Reload both config and fingerprint from disk, plus static models. */
 export function reloadAllConfigs(configDir?: string): void {
   reloadConfig(configDir);
   reloadFingerprint(configDir);
-  console.log("[Config] Hot-reloaded config and fingerprint from disk");
+  loadStaticModels(configDir);
+  console.log("[Config] Hot-reloaded config, fingerprint, and models from disk");
+  // Re-merge backend models so hot-reload doesn't wipe them for ~1h
+  triggerImmediateRefresh();
 }

src/index.ts

@@ -18,6 +18,8 @@ import { CookieJar } from "./proxy/cookie-jar.js";
 import { startUpdateChecker, stopUpdateChecker } from "./update-checker.js";
 import { initProxy } from "./tls/curl-binary.js";
 import { initTransport } from "./tls/transport.js";
+import { loadStaticModels } from "./models/model-store.js";
+import { startModelRefresh, stopModelRefresh } from "./models/model-fetcher.js";
 
 async function main() {
   // Load configuration
@@ -33,6 +35,9 @@ async function main() {
     process.exit(1);
   }
 
+  // Load static model catalog (before transport/auth init)
+  loadStaticModels();
+
   // Detect proxy (config > env > auto-detect local ports)
   await initProxy();
 
@@ -100,6 +105,9 @@ async function main() {
   // Start background update checker
   startUpdateChecker();
 
+  // Start background model refresh (requires auth to be ready)
+  startModelRefresh(accountPool, cookieJar);
+
   const server = serve({
     fetch: app.fetch,
     hostname: host,
@@ -138,6 +146,7 @@ async function main() {
       cleanupDone = true;
       try {
         stopUpdateChecker();
+        stopModelRefresh();
         refreshScheduler.destroy();
         sessionManager.destroy();
         cookieJar.destroy();

src/models/model-fetcher.ts

@@ -0,0 +1,117 @@
+/**
+ * Model Fetcher — background model list refresh from Codex backend.
+ *
+ * - Probes known endpoints to discover the models list
+ * - Normalizes and merges into the model store
+ * - Non-fatal: all errors log warnings but never crash the server
+ */
+
+import { CodexApi } from "../proxy/codex-api.js";
+import { applyBackendModels, type BackendModelEntry } from "./model-store.js";
+import type { AccountPool } from "../auth/account-pool.js";
+import type { CookieJar } from "../proxy/cookie-jar.js";
+import { jitter } from "../utils/jitter.js";
+
+const REFRESH_INTERVAL_HOURS = 1;
+const INITIAL_DELAY_MS = 5_000; // 5s after startup
+
+let _refreshTimer: ReturnType<typeof setTimeout> | null = null;
+let _accountPool: AccountPool | null = null;
+let _cookieJar: CookieJar | null = null;
+
+/**
+ * Fetch models from the Codex backend using an available account.
+ */
+async function fetchModelsFromBackend(
+  accountPool: AccountPool,
+  cookieJar: CookieJar,
+): Promise<void> {
+  if (!accountPool.isAuthenticated()) return; // silently skip when no accounts
+
+  const acquired = accountPool.acquire();
+  if (!acquired) {
+    console.warn("[ModelFetcher] No available account — skipping model fetch");
+    return;
+  }
+
+  try {
+    const api = new CodexApi(
+      acquired.token,
+      acquired.accountId,
+      cookieJar,
+      acquired.entryId,
+    );
+
+    const models = await api.getModels();
+    if (models && models.length > 0) {
+      applyBackendModels(models);
+      console.log(`[ModelFetcher] Fetched ${models.length} models from backend`);
+    } else {
+      console.log("[ModelFetcher] Backend returned empty model list — keeping static models");
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(`[ModelFetcher] Backend fetch failed: ${msg}`);
+  } finally {
+    accountPool.release(acquired.entryId);
+  }
+}
+
+/**
+ * Start the background model refresh loop.
+ * - First fetch after a short delay (auth must be ready)
+ * - Subsequent fetches every ~1 hour with jitter
+ */
+export function startModelRefresh(
+  accountPool: AccountPool,
+  cookieJar: CookieJar,
+): void {
+  _accountPool = accountPool;
+  _cookieJar = cookieJar;
+
+  // Initial fetch after short delay
+  _refreshTimer = setTimeout(async () => {
+    await fetchModelsFromBackend(accountPool, cookieJar);
+    scheduleNext(accountPool, cookieJar);
+  }, INITIAL_DELAY_MS);
+
+  console.log("[ModelFetcher] Scheduled initial model fetch in 5s");
+}
+
+function scheduleNext(
+  accountPool: AccountPool,
+  cookieJar: CookieJar,
+): void {
+  const intervalMs = jitter(REFRESH_INTERVAL_HOURS * 3600 * 1000, 0.15);
+  _refreshTimer = setTimeout(async () => {
+    try {
+      await fetchModelsFromBackend(accountPool, cookieJar);
+    } finally {
+      scheduleNext(accountPool, cookieJar);
+    }
+  }, intervalMs);
+}
+
+/**
+ * Trigger an immediate model refresh (e.g. after hot-reload).
+ * No-op if startModelRefresh() hasn't been called yet.
+ */
+export function triggerImmediateRefresh(): void {
+  if (_accountPool && _cookieJar) {
+    fetchModelsFromBackend(_accountPool, _cookieJar).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`[ModelFetcher] Immediate refresh failed: ${msg}`);
+    });
+  }
+}
+
+/**
+ * Stop the background refresh timer.
+ */
+export function stopModelRefresh(): void {
+  if (_refreshTimer) {
+    clearTimeout(_refreshTimer);
+    _refreshTimer = null;
+    console.log("[ModelFetcher] Stopped model refresh");
+  }
+}

src/models/model-store.ts

@@ -0,0 +1,223 @@
+/**
+ * Model Store — mutable singleton for model catalog + aliases.
+ *
+ * Data flow:
+ *   1. loadStaticModels() — load from config/models.yaml (fallback baseline)
+ *   2. applyBackendModels() — merge backend-fetched models (backend wins for shared IDs)
+ *   3. getters — runtime reads from mutable state
+ *
+ * Aliases always come from YAML (user-customizable), never from backend.
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import yaml from "js-yaml";
+import { getConfig } from "../config.js";
+
+export interface CodexModelInfo {
+  id: string;
+  displayName: string;
+  description: string;
+  isDefault: boolean;
+  supportedReasoningEfforts: { reasoningEffort: string; description: string }[];
+  defaultReasoningEffort: string;
+  inputModalities: string[];
+  supportsPersonality: boolean;
+  upgrade: string | null;
+  /** Where this model entry came from */
+  source?: "static" | "backend";
+}
+
+interface ModelsConfig {
+  models: CodexModelInfo[];
+  aliases: Record<string, string>;
+}
+
+// ── Mutable state ──────────────────────────────────────────────────
+
+let _catalog: CodexModelInfo[] = [];
+let _aliases: Record<string, string> = {};
+let _lastFetchTime: string | null = null;
+
+// ── Static loading ─────────────────────────────────────────────────
+
+/**
+ * Load models from config/models.yaml (synchronous).
+ * Called at startup and on hot-reload.
+ */
+export function loadStaticModels(configDir?: string): void {
+  const dir = configDir ?? resolve(process.cwd(), "config");
+  const configPath = resolve(dir, "models.yaml");
+  const raw = yaml.load(readFileSync(configPath, "utf-8")) as ModelsConfig;
+
+  _catalog = (raw.models ?? []).map((m) => ({ ...m, source: "static" as const }));
+  _aliases = raw.aliases ?? {};
+  console.log(`[ModelStore] Loaded ${_catalog.length} static models, ${Object.keys(_aliases).length} aliases`);
+}
+
+// ── Backend merge ──────────────────────────────────────────────────
+
+/**
+ * Raw model entry from backend (fields are optional — format may vary).
+ */
+export interface BackendModelEntry {
+  slug?: string;
+  id?: string;
+  name?: string;
+  display_name?: string;
+  description?: string;
+  is_default?: boolean;
+  default_reasoning_effort?: string;
+  supported_reasoning_efforts?: Array<{
+    reasoning_effort?: string;
+    reasoningEffort?: string;
+    description?: string;
+  }>;
+  input_modalities?: string[];
+  supports_personality?: boolean;
+  upgrade?: string | null;
+}
+
+/** Intermediate type with explicit efforts flag for merge logic. */
+interface NormalizedModelWithMeta extends CodexModelInfo {
+  _hasExplicitEfforts: boolean;
+}
+
+/**
+ * Normalize a backend model entry to our CodexModelInfo format.
+ */
+function normalizeBackendModel(raw: BackendModelEntry): NormalizedModelWithMeta {
+  const id = raw.slug ?? raw.id ?? raw.name ?? "unknown";
+
+  const hasExplicitEfforts = Array.isArray(raw.supported_reasoning_efforts) && raw.supported_reasoning_efforts.length > 0;
+
+  // Normalize reasoning efforts — accept both snake_case and camelCase
+  const efforts = (raw.supported_reasoning_efforts ?? []).map((e) => ({
+    reasoningEffort: e.reasoningEffort ?? e.reasoning_effort ?? "medium",
+    description: e.description ?? "",
+  }));
+
+  return {
+    id,
+    displayName: raw.display_name ?? raw.name ?? id,
+    description: raw.description ?? "",
+    isDefault: raw.is_default ?? false,
+    supportedReasoningEfforts: efforts.length > 0
+      ? efforts
+      : [{ reasoningEffort: "medium", description: "Default" }],
+    defaultReasoningEffort: raw.default_reasoning_effort ?? "medium",
+    inputModalities: raw.input_modalities ?? ["text"],
+    supportsPersonality: raw.supports_personality ?? false,
+    upgrade: raw.upgrade ?? null,
+    source: "backend",
+    _hasExplicitEfforts: hasExplicitEfforts,
+  };
+}
+
+/**
+ * Merge backend models into the catalog.
+ *
+ * Strategy:
+ *   - Backend models overwrite static models with the same ID
+ *     (but YAML fields fill in missing backend fields)
+ *   - Static-only models are preserved (YAML may know about models the backend doesn't list)
+ *   - Aliases are never touched (always from YAML)
+ */
+export function applyBackendModels(backendModels: BackendModelEntry[]): void {
+  const staticMap = new Map(_catalog.map((m) => [m.id, m]));
+  const merged: CodexModelInfo[] = [];
+  const seenIds = new Set<string>();
+
+  for (const raw of backendModels) {
+    const normalized = normalizeBackendModel(raw);
+    seenIds.add(normalized.id);
+
+    const existing = staticMap.get(normalized.id);
+    // Strip internal meta field before storing
+    const { _hasExplicitEfforts, ...model } = normalized;
+    if (existing) {
+      // Backend wins, but YAML fills gaps
+      merged.push({
+        ...existing,
+        ...model,
+        // Preserve YAML fields if backend is empty
+        description: model.description || existing.description,
+        displayName: model.displayName || existing.displayName,
+        supportedReasoningEfforts: _hasExplicitEfforts
+          ? model.supportedReasoningEfforts
+          : existing.supportedReasoningEfforts,
+        source: "backend",
+      });
+    } else {
+      merged.push(model);
+    }
+  }
+
+  // Preserve static-only models (not in backend)
+  for (const m of _catalog) {
+    if (!seenIds.has(m.id)) {
+      merged.push({ ...m, source: "static" });
+    }
+  }
+
+  _catalog = merged;
+  _lastFetchTime = new Date().toISOString();
+  console.log(
+    `[ModelStore] Merged ${backendModels.length} backend + ${merged.length - backendModels.length} static-only = ${merged.length} total models`,
+  );
+}
+
+// ── Getters ────────────────────────────────────────────────────────
+
+/**
+ * Resolve a model name (may be an alias) to a canonical model ID.
+ */
+export function resolveModelId(input: string): string {
+  const trimmed = input.trim();
+  if (_aliases[trimmed]) return _aliases[trimmed];
+  if (_catalog.some((m) => m.id === trimmed)) return trimmed;
+  return getConfig().model.default;
+}
+
+/**
+ * Get model info by ID.
+ */
+export function getModelInfo(modelId: string): CodexModelInfo | undefined {
+  return _catalog.find((m) => m.id === modelId);
+}
+
+/**
+ * Get the full model catalog.
+ */
+export function getModelCatalog(): CodexModelInfo[] {
+  return [..._catalog];
+}
+
+/**
+ * Get the alias map.
+ */
+export function getModelAliases(): Record<string, string> {
+  return { ..._aliases };
+}
+
+/**
+ * Debug info for /debug/models endpoint.
+ */
+export function getModelStoreDebug(): {
+  totalModels: number;
+  backendModels: number;
+  staticOnlyModels: number;
+  aliasCount: number;
+  lastFetchTime: string | null;
+  models: Array<{ id: string; source: string }>;
+} {
+  const backendCount = _catalog.filter((m) => m.source === "backend").length;
+  return {
+    totalModels: _catalog.length,
+    backendModels: backendCount,
+    staticOnlyModels: _catalog.length - backendCount,
+    aliasCount: Object.keys(_aliases).length,
+    lastFetchTime: _lastFetchTime,
+    models: _catalog.map((m) => ({ id: m.id, source: m.source ?? "static" })),
+  };
+}

src/proxy/codex-api.ts

@@ -16,6 +16,9 @@ import {
   buildHeadersWithContentType,
 } from "../fingerprint/manager.js";
 import type { CookieJar } from "./cookie-jar.js";
+import type { BackendModelEntry } from "../models/model-store.js";
+
+let _firstModelFetchLogged = false;
 
 export interface CodexResponsesRequest {
   model: string;
@@ -125,6 +128,101 @@ export class CodexApi {
     }
   }
 
+  /**
+   * Fetch available models from the Codex backend.
+   * Probes known endpoints; returns null if none respond.
+   */
+  async getModels(): Promise<BackendModelEntry[] | null> {
+    const config = getConfig();
+    const transport = getTransport();
+    const baseUrl = config.api.base_url;
+
+    // Endpoints to probe (most specific first)
+    const endpoints = [
+      `${baseUrl}/codex/models`,
+      `${baseUrl}/models`,
+      `${baseUrl}/sentinel/chat-requirements`,
+    ];
+
+    const headers = this.applyHeaders(
+      buildHeaders(this.token, this.accountId),
+    );
+    headers["Accept"] = "application/json";
+    if (!transport.isImpersonate()) {
+      headers["Accept-Encoding"] = "gzip, deflate";
+    }
+
+    for (const url of endpoints) {
+      try {
+        const result = await transport.get(url, headers, 15);
+        const parsed = JSON.parse(result.body) as Record<string, unknown>;
+
+        // sentinel/chat-requirements returns { chat_models: { models: [...], ... } }
+        const sentinel = parsed.chat_models as Record<string, unknown> | undefined;
+        const models = sentinel?.models ?? parsed.models ?? parsed.data ?? parsed.categories;
+        if (Array.isArray(models) && models.length > 0) {
+          console.log(`[CodexApi] getModels() found ${models.length} entries from ${url}`);
+          if (!_firstModelFetchLogged) {
+            console.log(`[CodexApi] Raw response keys: ${Object.keys(parsed).join(", ")}`);
+            console.log(`[CodexApi] Raw model sample: ${JSON.stringify(models[0]).slice(0, 500)}`);
+            if (models.length > 1) {
+              console.log(`[CodexApi] Raw model sample[1]: ${JSON.stringify(models[1]).slice(0, 500)}`);
+            }
+            _firstModelFetchLogged = true;
+          }
+          // Flatten nested categories into a single list
+          const flattened: BackendModelEntry[] = [];
+          for (const item of models) {
+            if (item && typeof item === "object") {
+              const entry = item as Record<string, unknown>;
+              if (Array.isArray(entry.models)) {
+                for (const sub of entry.models as BackendModelEntry[]) {
+                  flattened.push(sub);
+                }
+              } else {
+                flattened.push(item as BackendModelEntry);
+              }
+            }
+          }
+          if (flattened.length > 0) {
+            console.log(`[CodexApi] getModels() total after flatten: ${flattened.length} models`);
+            return flattened;
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`[CodexApi] Probe ${url} failed: ${msg}`);
+        continue;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Probe a backend endpoint and return raw JSON (for debug).
+   */
+  async probeEndpoint(path: string): Promise<Record<string, unknown> | null> {
+    const config = getConfig();
+    const transport = getTransport();
+    const url = `${config.api.base_url}${path}`;
+
+    const headers = this.applyHeaders(
+      buildHeaders(this.token, this.accountId),
+    );
+    headers["Accept"] = "application/json";
+    if (!transport.isImpersonate()) {
+      headers["Accept-Encoding"] = "gzip, deflate";
+    }
+
+    try {
+      const result = await transport.get(url, headers, 15);
+      return JSON.parse(result.body) as Record<string, unknown>;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Create a response (streaming).
    * Returns the raw Response so the caller can process the SSE stream.

src/routes/gemini.ts

@@ -21,7 +21,7 @@ import {
   collectCodexToGeminiResponse,
 } from "../translation/codex-to-gemini.js";
 import { getConfig } from "../config.js";
-import { getModelCatalog } from "./models.js";
+import { getModelCatalog } from "../models/model-store.js";
 import {
   handleProxyRequest,
   type FormatAdapter,

src/routes/models.ts

@@ -1,66 +1,16 @@
-import { Hono } from "hono";
-import { readFileSync } from "fs";
-import { resolve } from "path";
-import yaml from "js-yaml";
-import { getConfig } from "../config.js";
-import type { OpenAIModel, OpenAIModelList } from "../types/openai.js";
-
 /**
- * Full model catalog from Codex CLI `model/list`.
- * Each model has reasoning effort levels, description, and capabilities.
+ * Model routes — pure route handlers reading from model-store singleton.
  */
-export interface CodexModelInfo {
-  id: string;
-  displayName: string;
-  description: string;
-  isDefault: boolean;
-  supportedReasoningEfforts: { reasoningEffort: string; description: string }[];
-  defaultReasoningEffort: string;
-  inputModalities: string[];
-  supportsPersonality: boolean;
-  upgrade: string | null;
-}
-
-interface ModelsConfig {
-  models: CodexModelInfo[];
-  aliases: Record<string, string>;
-}
-
-function loadModelConfig(): ModelsConfig {
-  const configPath = resolve(process.cwd(), "config/models.yaml");
-  const raw = yaml.load(readFileSync(configPath, "utf-8")) as ModelsConfig;
-  return raw;
-}
-
-const modelConfig = loadModelConfig();
-const MODEL_CATALOG: CodexModelInfo[] = modelConfig.models;
-const MODEL_ALIASES: Record<string, string> = modelConfig.aliases;
-
-/**
- * Resolve a model name (may be an alias) to a canonical model ID.
- */
-export function resolveModelId(input: string): string {
-  const trimmed = input.trim();
-  if (MODEL_ALIASES[trimmed]) return MODEL_ALIASES[trimmed];
-  // Check if it's already a known model ID
-  if (MODEL_CATALOG.some((m) => m.id === trimmed)) return trimmed;
-  // Fall back to config default
-  return getConfig().model.default;
-}
 
-/**
- * Get model info by ID.
- */
-export function getModelInfo(modelId: string): CodexModelInfo | undefined {
-  return MODEL_CATALOG.find((m) => m.id === modelId);
-}
-
-/**
- * Get the full model catalog.
- */
-export function getModelCatalog(): CodexModelInfo[] {
-  return MODEL_CATALOG;
-}
+import { Hono } from "hono";
+import type { OpenAIModel, OpenAIModelList } from "../types/openai.js";
+import {
+  getModelCatalog,
+  getModelAliases,
+  getModelInfo,
+  getModelStoreDebug,
+  type CodexModelInfo,
+} from "../models/model-store.js";
 
 // --- Routes ---
 
@@ -80,9 +30,12 @@ export function createModelRoutes(): Hono {
   const app = new Hono();
 
   app.get("/v1/models", (c) => {
+    const catalog = getModelCatalog();
+    const aliases = getModelAliases();
+
     // Include catalog models + aliases as separate entries
-    const models: OpenAIModel[] = MODEL_CATALOG.map(toOpenAIModel);
-    for (const [alias] of Object.entries(MODEL_ALIASES)) {
+    const models: OpenAIModel[] = catalog.map(toOpenAIModel);
+    for (const alias of Object.keys(aliases)) {
       models.push({
         id: alias,
         object: "model",
@@ -96,13 +49,15 @@ export function createModelRoutes(): Hono {
 
   app.get("/v1/models/:modelId", (c) => {
     const modelId = c.req.param("modelId");
+    const catalog = getModelCatalog();
+    const aliases = getModelAliases();
 
     // Try direct match
-    const info = MODEL_CATALOG.find((m) => m.id === modelId);
+    const info = catalog.find((m) => m.id === modelId);
     if (info) return c.json(toOpenAIModel(info));
 
     // Try alias
-    const resolved = MODEL_ALIASES[modelId];
+    const resolved = aliases[modelId];
     if (resolved) {
       return c.json({
         id: modelId,
@@ -126,8 +81,9 @@ export function createModelRoutes(): Hono {
   // Extended endpoint: model details with reasoning efforts
   app.get("/v1/models/:modelId/info", (c) => {
     const modelId = c.req.param("modelId");
-    const resolved = MODEL_ALIASES[modelId] ?? modelId;
-    const info = MODEL_CATALOG.find((m) => m.id === resolved);
+    const aliases = getModelAliases();
+    const resolved = aliases[modelId] ?? modelId;
+    const info = getModelInfo(resolved);
     if (!info) {
       c.status(404);
       return c.json({ error: `Model '${modelId}' not found` });
@@ -135,5 +91,10 @@ export function createModelRoutes(): Hono {
     return c.json(info);
   });
 
+  // Debug endpoint: model store internals
+  app.get("/debug/models", (c) => {
+    return c.json(getModelStoreDebug());
+  });
+
   return app;
 }

src/translation/anthropic-to-codex.ts

@@ -7,7 +7,7 @@ import type {
   CodexResponsesRequest,
   CodexInputItem,
 } from "../proxy/codex-api.js";
-import { resolveModelId, getModelInfo } from "../routes/models.js";
+import { resolveModelId, getModelInfo } from "../models/model-store.js";
 import { getConfig } from "../config.js";
 import { buildInstructions, budgetToEffort } from "./shared-utils.js";
 import { anthropicToolsToCodex, anthropicToolChoiceToCodex } from "./tool-format.js";

src/translation/gemini-to-codex.ts

@@ -11,7 +11,7 @@ import type {
   CodexResponsesRequest,
   CodexInputItem,
 } from "../proxy/codex-api.js";
-import { resolveModelId, getModelInfo } from "../routes/models.js";
+import { resolveModelId, getModelInfo } from "../models/model-store.js";
 import { getConfig } from "../config.js";
 import { buildInstructions, budgetToEffort } from "./shared-utils.js";
 import { geminiToolsToCodex, geminiToolConfigToCodex } from "./tool-format.js";

src/translation/openai-to-codex.ts

@@ -7,7 +7,7 @@ import type {
   CodexResponsesRequest,
   CodexInputItem,
 } from "../proxy/codex-api.js";
-import { resolveModelId, getModelInfo } from "../routes/models.js";
+import { resolveModelId, getModelInfo } from "../models/model-store.js";
 import { getConfig } from "../config.js";
 import { buildInstructions } from "./shared-utils.js";
 import {

web/src/App.tsx

@@ -4,7 +4,7 @@ import { Header } from "./components/Header";
 import { AccountList } from "./components/AccountList";
 import { AddAccount } from "./components/AddAccount";
 import { ApiConfig } from "./components/ApiConfig";
-import { ClaudeCodeSetup } from "./components/ClaudeCodeSetup";
+import { AnthropicSetup } from "./components/AnthropicSetup";
 import { CodeExamples } from "./components/CodeExamples";
 import { Footer } from "./components/Footer";
 import { useAccounts } from "./hooks/use-accounts";
@@ -37,8 +37,10 @@ function Dashboard() {
             selectedModel={status.selectedModel}
             onModelChange={status.setSelectedModel}
           />
-          <ClaudeCodeSetup
+          <AnthropicSetup
             apiKey={status.apiKey}
+            models={status.models}
+            selectedModel={status.selectedModel}
           />
           <CodeExamples
             baseUrl={status.baseUrl}

web/src/components/{ClaudeCodeSetup.tsx → AnthropicSetup.tsx}

@@ -1,29 +1,23 @@
-import { useState, useCallback, useMemo } from "preact/hooks";
+import { useState, useMemo, useCallback } from "preact/hooks";
 import { useT } from "../i18n/context";
 import { CopyButton } from "./CopyButton";
 
-type ClaudeModel = "opus" | "sonnet" | "haiku";
-
-const CLAUDE_MODELS: { id: ClaudeModel; label: string; desc: string }[] = [
-  { id: "opus", label: "Opus", desc: "gpt-5.3-codex" },
-  { id: "sonnet", label: "Sonnet", desc: "gpt-5.2-codex" },
-  { id: "haiku", label: "Haiku", desc: "gpt-5.1-codex-mini" },
-];
-
-interface ClaudeCodeSetupProps {
+interface AnthropicSetupProps {
   apiKey: string;
+  models: string[];
+  selectedModel: string;
 }
 
-export function ClaudeCodeSetup({ apiKey }: ClaudeCodeSetupProps) {
+export function AnthropicSetup({ apiKey, models, selectedModel }: AnthropicSetupProps) {
   const t = useT();
-  const [model, setModel] = useState<ClaudeModel>("opus");
+  const [model, setModel] = useState(selectedModel);
 
   const origin = typeof window !== "undefined" ? window.location.origin : "http://localhost:8080";
 
   const envLines = useMemo(() => ({
     ANTHROPIC_BASE_URL: origin,
     ANTHROPIC_API_KEY: apiKey,
-    ANTHROPIC_MODEL: `claude-${model}-4-${model === "haiku" ? "5-20251001" : "6"}`,
+    ANTHROPIC_MODEL: model,
   }), [origin, apiKey, model]);
 
   const allEnvText = useMemo(
@@ -36,9 +30,6 @@ export function ClaudeCodeSetup({ apiKey }: ClaudeCodeSetupProps) {
   const getApiKey = useCallback(() => envLines.ANTHROPIC_API_KEY, [envLines]);
   const getModel = useCallback(() => envLines.ANTHROPIC_MODEL, [envLines]);
 
-  const activeBtn = "px-3 py-1.5 text-xs font-semibold rounded bg-white dark:bg-[#21262d] text-slate-800 dark:text-text-main shadow-sm border border-transparent dark:border-border-dark transition-all";
-  const inactiveBtn = "px-3 py-1.5 text-xs font-medium rounded text-slate-500 dark:text-text-dim hover:text-slate-700 dark:hover:text-text-main hover:bg-white/50 dark:hover:bg-[#21262d] border border-transparent transition-all";
-
   return (
     <section class="bg-white dark:bg-card-dark border border-gray-200 dark:border-border-dark rounded-xl p-5 shadow-sm transition-colors">
       <div class="flex items-center justify-between mb-6 border-b border-slate-100 dark:border-border-dark pb-4">
@@ -46,20 +37,17 @@ export function ClaudeCodeSetup({ apiKey }: ClaudeCodeSetupProps) {
           <svg class="size-5 text-primary" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
             <path stroke-linecap="round" stroke-linejoin="round" d="M6.75 7.5l3 2.25-3 2.25m4.5 0h3m-9 8.25h13.5A2.25 2.25 0 0021 18V6a2.25 2.25 0 00-2.25-2.25H5.25A2.25 2.25 0 003 6v12a2.25 2.25 0 002.25 2.25z" />
           </svg>
-          <h2 class="text-[0.95rem] font-bold">{t("claudeCodeSetup")}</h2>
+          <h2 class="text-[0.95rem] font-bold">{t("anthropicSetup")}</h2>
         </div>
-        <div class="flex gap-2 p-1 bg-slate-100 dark:bg-bg-dark dark:border dark:border-border-dark rounded-lg">
-          {CLAUDE_MODELS.map((m) => (
-            <button
-              key={m.id}
-              onClick={() => setModel(m.id)}
-              class={model === m.id ? activeBtn : inactiveBtn}
-            >
-              {m.label}
-              <span class="ml-1 text-[0.65rem] opacity-60">({m.desc})</span>
-            </button>
+        <select
+          class="px-3 py-1.5 text-xs font-mono rounded-lg bg-slate-100 dark:bg-bg-dark border border-gray-200 dark:border-border-dark text-slate-700 dark:text-text-main outline-none"
+          value={model}
+          onChange={(e) => setModel((e.target as HTMLSelectElement).value)}
+        >
+          {models.map((m) => (
+            <option key={m} value={m}>{m}</option>
           ))}
-        </div>
+        </select>
       </div>
 
       {/* Env vars */}
@@ -86,7 +74,7 @@ export function ClaudeCodeSetup({ apiKey }: ClaudeCodeSetupProps) {
       {/* Copy all button */}
       <div class="mt-5 flex items-center gap-3">
         <CopyButton getText={getAllEnv} variant="label" />
-        <span class="text-xs text-slate-400 dark:text-text-dim">{t("claudeCodeCopyAllHint")}</span>
+        <span class="text-xs text-slate-400 dark:text-text-dim">{t("anthropicCopyAllHint")}</span>
       </div>
     </section>
   );

web/src/hooks/use-status.ts

@@ -13,7 +13,7 @@ export function useStatus(accountCount: number) {
       const ids: string[] = data.data.map((m: { id: string }) => m.id);
       if (ids.length > 0) {
         setModels(ids);
-        const preferred = ids.find((n) => n.includes("5.3-codex"));
+        const preferred = ids.find((n) => n === "codex");
         if (preferred) setSelectedModel(preferred);
       }
     } catch {

web/src/i18n/translations.ts

@@ -32,8 +32,8 @@ export const translations = {
       "Use this key to authenticate requests to the proxy. Do not share it.",
     copyUrl: "Copy URL",
     copyApiKey: "Copy API Key",
-    claudeCodeSetup: "Claude Code Quick Setup",
-    claudeCodeCopyAllHint: "Copy all env vars — paste into terminal or .env file",
+    anthropicSetup: "Anthropic SDK Setup",
+    anthropicCopyAllHint: "Copy all env vars — paste into terminal or .env file",
     integrationExamples: "Integration Examples",
     copy: "Copy",
     addStep1:
@@ -89,8 +89,8 @@ export const translations = {
       "\u4f7f\u7528\u6b64\u5bc6\u94a5\u5411\u4ee3\u7406\u53d1\u9001\u8ba4\u8bc1\u8bf7\u6c42\uff0c\u8bf7\u52ff\u6cc4\u9732\u3002",
     copyUrl: "\u590d\u5236 URL",
     copyApiKey: "\u590d\u5236 API \u5bc6\u94a5",
-    claudeCodeSetup: "Claude Code \u5feb\u901f\u914d\u7f6e",
-    claudeCodeCopyAllHint: "\u590d\u5236\u6240\u6709\u73af\u5883\u53d8\u91cf \u2014 \u7c98\u8d34\u5230\u7ec8\u7aef\u6216 .env \u6587\u4ef6",
+    anthropicSetup: "Anthropic SDK \u914d\u7f6e",
+    anthropicCopyAllHint: "\u590d\u5236\u6240\u6709\u73af\u5883\u53d8\u91cf \u2014 \u7c98\u8d34\u5230\u7ec8\u7aef\u6216 .env \u6587\u4ef6",
     integrationExamples: "\u96c6\u6210\u793a\u4f8b",
     copy: "\u590d\u5236",
     addStep1: