@armadra/agent 0.6.1 → 0.6.3

package/dist/ai/providers/discovered-cache.js

@@ -3,8 +3,15 @@
  *
  * 模型表为空、接受任意 slug 的供应商（`chatgpt` 的订阅后端）在选择器里原本一个模型都看不到。
  * `ama auth login chatgpt` 成功后与 `ama models discover chatgpt` 把账户可用的 slug 写进这里；组装注册表时
- * （`mergeDiscoveredModels`）并入**模型表仍为空**的供应商，元数据用 models.dev（快照 ⊕ 用户刷新）补全。
- * `ama auth logout chatgpt` 删掉它。只存 slug、显示名、flavor 与时间戳——没有 token、账户 id。
+ * （`mergeDiscoveredModels`）并入**模型表仍为空**的供应商。`ama auth logout chatgpt` 删掉它。只存 slug、显示名、
+ * 后端给的元数据（上下文窗口、输入模态、推理强度）、flavor 与时间戳——没有 token、账户 id。
+ *
+ * 元数据优先级：后端明确给的 > models.dev（快照 ⊕ 用户刷新）> 自定义缺省。上下文窗口尤其如此：订阅后端的生效
+ * 窗口（如 codex 的 272k）可能远小于 models.dev 记的 API 版窗口（1.1M），按后者算压缩阈值会让请求超窗被拒。
+ * 旧版本写的缓存（siwc 不含上下文窗口）照旧用 models.dev；`chatgpt` 两边都没有时用保守缺省
+ * `SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW`，不让自动压缩关闭。
+ *
+ * ChatGPT 的缓存带登录 flavor；组装时与当前登录的 flavor 不符视为过期、不并入（选择器提示重新发现）。
  */
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -15,11 +22,24 @@ export const DISCOVERED_CACHE_VERSION = 1;
 export function discoveredCachePath(dataDir, provider) {
     return join(dataDir, "models", "discovered", `${provider}.json`);
 }
-function isEntry(value) {
+/** 未知值 → 缓存模型；id 不对返回 undefined，元数据字段形状不对的丢掉。 */
+function toEntry(value) {
     if (typeof value !== "object" || value === null)
-        return false;
-    const { id, name } = value;
-    return typeof id === "string" && id !== "" && (name === undefined || typeof name === "string");
+        return undefined;
+    const raw = value;
+    const { id, name, contextWindow, input, reasoningLevels } = raw;
+    if (typeof id !== "string" || id === "")
+        return undefined;
+    const out = { id };
+    if (typeof name === "string" && name !== "")
+        out.name = name;
+    if (typeof contextWindow === "number" && Number.isInteger(contextWindow) && contextWindow > 0)
+        out.contextWindow = contextWindow;
+    if (Array.isArray(input) && input.includes("text"))
+        out.input = ["text", "image"].filter((x) => input.includes(x));
+    if (Array.isArray(reasoningLevels) && reasoningLevels.every((x) => typeof x === "string"))
+        out.reasoningLevels = reasoningLevels;
+    return out;
 }
 /** 读缓存；不存在、损坏或形状不对返回 undefined（不报错，选择器给提示行）。 */
 export function readDiscoveredCache(dataDir, provider) {
@@ -40,9 +60,7 @@ export function readDiscoveredCache(dataDir, provider) {
         provider,
         fetchedAt: typeof file.fetchedAt === "string" ? file.fetchedAt : "",
         ...(typeof file.flavor === "string" ? { flavor: file.flavor } : {}),
-        models: file.models
-            .filter(isEntry)
-            .map((m) => (m.name ? { id: m.id, name: m.name } : { id: m.id })),
+        models: file.models.map(toEntry).filter((m) => m !== undefined),
     };
 }
 /** 写缓存（先写临时文件再改名）；返回路径。 */
@@ -53,7 +71,7 @@ export function writeDiscoveredCache(dataDir, provider, input, now = Date.now())
         provider,
         fetchedAt: new Date(now).toISOString(),
         ...(input.flavor !== undefined ? { flavor: input.flavor } : {}),
-        models: input.models.map((m) => (m.name ? { id: m.id, name: m.name } : { id: m.id })),
+        models: input.models.map(toEntry).filter((m) => m !== undefined),
     };
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const tmp = `${path}.${process.pid}.tmp`;
@@ -69,11 +87,48 @@ export function clearDiscoveredCache(dataDir, provider) {
     rmSync(path, { force: true });
     return true;
 }
-/** 缓存里的模型 → 注册表模型（models.dev 补元数据，补不到用自定义缺省）。 */
+const EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
+/** 后端给的推理强度 → 思考级别映射（`none` 对应 off；没列出的级别不支持）。 */
+export function thinkingMapOf(levels) {
+    const map = {
+        off: levels.includes("none") ? "none" : null,
+    };
+    for (const level of EFFORT_LEVELS)
+        map[level] = levels.includes(level) ? level : null;
+    return map;
+}
+/** 订阅后端：models.dev 与后端都没给上下文窗口时的保守缺省。 */
+export const SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW = 128_000;
+const SUBSCRIPTION_PROVIDERS = new Set(["chatgpt"]);
+/** 后端明确给的元数据覆盖 models.dev 补的；没给的字段保留 models.dev 的（maxTokens 只来自 models.dev）。 */
+function withBackendMetadata(model, cached) {
+    if (cached.contextWindow !== undefined) {
+        model.contextWindow = cached.contextWindow;
+        // models.dev 的输入上限是 API 版的，超过后端窗口就没有意义
+        if (model.inputLimit !== undefined && model.inputLimit >= cached.contextWindow)
+            delete model.inputLimit;
+    }
+    if (cached.input !== undefined)
+        model.input = [...cached.input];
+    if (cached.reasoningLevels === undefined)
+        return;
+    if (cached.reasoningLevels.some((x) => x !== "none")) {
+        model.reasoning = true;
+        model.thinkingLevelMap = thinkingMapOf(cached.reasoningLevels);
+    }
+    else {
+        model.reasoning = false;
+        delete model.thinkingLevelMap;
+    }
+}
+/** 缓存里的模型 → 注册表模型（后端给的元数据优先，其次 models.dev，再次自定义缺省）。 */
 export function discoveredModels(file, provider, modelsDev) {
     return file.models.map((m) => {
         const { entry } = enrichEntry(m.name ? { id: m.id, name: m.name } : { id: m.id }, modelsDev);
         const model = withCustomDefaults(entry, provider.id, provider.api);
+        withBackendMetadata(model, m);
+        if (model.contextWindow === undefined && SUBSCRIPTION_PROVIDERS.has(provider.id))
+            model.contextWindow = SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW;
         // 只挂发现时登录的 flavor 对应的渠道（订阅后端的另一条渠道用不了，不在说明与 `@` 行里出现）；
         // 缓存没写 flavor 或渠道不存在时用供应商的缺省渠道
         const names = (provider.channels ?? []).map((c) => c.name);
@@ -87,7 +142,9 @@ export function discoveredModels(file, provider, modelsDev) {
 /**
  * 把缓存并入模型表为空的供应商（本地服务除外：它们每次启动现场探测）。返回并入了的供应商 id。
  */
-export function mergeDiscoveredModels(registry, dataDir, modelsDev) {
+export function mergeDiscoveredModels(registry, dataDir, modelsDev, 
+/** 当前登录的 flavor（只有 OAuth 供应商有）：缓存的 flavor 与之不符视为过期，不并入。 */
+loginFlavor = () => undefined) {
     const merged = [];
     for (const provider of registry.list()) {
         if (provider.models.length > 0 || !provider.requiresApiKey)
@@ -95,6 +152,9 @@ export function mergeDiscoveredModels(registry, dataDir, modelsDev) {
         const file = readDiscoveredCache(dataDir, provider.id);
         if (file === undefined || file.models.length === 0)
             continue;
+        const flavor = loginFlavor(provider.id);
+        if (flavor !== undefined && file.flavor !== undefined && file.flavor !== flavor)
+            continue;
         registry.addModels(provider.id, discoveredModels(file, provider, modelsDev), "discovered");
         merged.push(provider.id);
     }

package/dist/ai/providers/registry.js

@@ -380,9 +380,8 @@ export class ProviderRegistry {
                 candidates: available.filter(Boolean).map((c) => `${provider.id}/${model.id}@${c}`),
             };
         }
-        if (channel === model.channel)
-            return { ok: true, model, provider };
-        return { ok: true, model: this.materialize(provider, model, channel), provider };
+        const picked = channel === model.channel ? model : this.materialize(provider, model, channel);
+        return { ok: true, model: { ...picked, channelPinned: true }, provider };
     }
     /**
      * `provider/model`、`provider/model@渠道` 或裸模型 id。`@` 先按渠道解析（id 里本来就带 `@` 且已登记的
@@ -415,9 +414,11 @@ export class ProviderRegistry {
                 const open = this.relayed.has(provider.id) || this.openTables.has(provider.id);
                 const relayed = provider.models.length === 0 || open;
                 if (synthesize && relayed && id.length > 0) {
-                    const synthesized = this.synthesize(provider, id);
-                    if (channel !== undefined && provider.channels?.some((c) => c.name === channel))
-                        synthesized.channels = [...new Set([...(synthesized.channels ?? []), channel])];
+                    // 按所要的渠道直接物化（先按缺省渠道物化再换渠道会留下缺省渠道的地址与 compat）
+                    const known = provider.channels?.some((c) => c.name === channel) ? channel : undefined;
+                    const synthesized = this.synthesize(provider, id, known);
+                    if (known)
+                        synthesized.channels = [...new Set([...(synthesized.channels ?? []), known])];
                     return { ok: true, model: synthesized, provider };
                 }
                 return { ok: false, reason: "not_found", candidates: this.similar(id, provider.id) };

package/dist/ai/types.d.ts

@@ -321,6 +321,11 @@ export interface Model {
     requiresApiKey?: boolean;
     /** 所选渠道名（registry 物化时填入；隐式 `default` 渠道不填）。 */
     channel?: string;
+    /**
+     * 渠道是引用里显式写的 `@渠道`（`findModel("p/m@c")` 填 true）。ChatGPT 订阅供应商据此区分：没写的渠道在
+     * 请求时跟随当前登录方式，写了的不跟随（不符时报 `chatgpt_flavor_mismatch`）。
+     */
+    channelPinned?: boolean;
     /** 该模型挂载的全部渠道，首个为首选（多渠道供应商才有）。 */
     channels?: string[];
     /** 模型家族（如 `claude-sonnet`）。 */

package/dist/auth/chatgpt/backend-client.d.ts

@@ -1,10 +1,13 @@
 /**
  * ChatGPT 后端的只读查询（[W6-O]）：模型列表（`ama models discover chatgpt`）与 codex 的 `wham/usage`。
  *
- * - SIWC：`GET {base}/models`，只留 `visibility === "list"`（没有该字段的也留）；
- * - codex：`GET {base}/models?client_version=<ama 版本>`，`models[].slug`（同样按 visibility 筛）；
- *   `GET https://chatgpt.com/backend-api/wham/usage`（由 codex base 推出），私有格式，解析失败返回 undefined。
- * 只取 slug 与显示名，上下文窗口不猜。请求带 Bearer；codex 另带 `ChatGPT-Account-ID` 与 `originator`。
+ * - SIWC：`GET {base}/models`，只留 `visibility === "list"`（没有该字段的也留）；条目若带下述元数据字段同样取；
+ * - codex：`GET {base}/models?client_version=<Codex CLI 版本>`（`codexClientVersion()`；后端按每个模型的
+ *   `minimal_client_version` 过滤，发 ama 自己的版本号会一个都拿不到），`models[].slug`（同样按 visibility 筛），
+ *   另取 `context_window`、`input_modalities`、`supported_reasoning_levels` 作元数据（后端给了就优先于 models.dev，
+ *   见 discovered-cache.ts；`max_context_window` 是可调上限而非生效值、`auto_compact_token_limit` 没有对应的模型字段，
+ *   都不取）；`GET https://chatgpt.com/backend-api/wham/usage`（由 codex base 推出），私有格式，解析失败返回 undefined。
+ * 请求带 Bearer；codex 另带 `ChatGPT-Account-ID` 与 `originator`。
  */
 import { type QuotaSnapshot } from "../../ai/apis/chatgpt-rate-limits.js";
 import type { ChatGptFlavor } from "../../config/types-w6.js";
@@ -15,10 +18,17 @@ export interface BackendAuth {
     accessToken: string;
     accountId?: string | undefined;
     originator?: string | undefined;
+    /** codex 模型列表的 `client_version`，缺省 `DEFAULT_CODEX_CLIENT_VERSION`。 */
+    clientVersion?: string | undefined;
 }
 export interface DiscoveredModel {
     id: string;
     name?: string;
+    /** 以下是后端给的元数据（codex 后端给；SIWC 条目带了也取）。 */
+    contextWindow?: number;
+    input?: ("text" | "image")[];
+    /** 支持的推理强度（`none` / `minimal` / `low` / `medium` / `high` / `xhigh` …）。 */
+    reasoningLevels?: string[];
 }
 export declare function listChatGptModels(fetchFn: FetchLike, baseUrl: string, auth: BackendAuth): Promise<DiscoveredModel[]>;
 export declare function usageUrl(codexBaseUrl: string): string;

package/dist/auth/chatgpt/backend-client.js

@@ -1,14 +1,16 @@
 /**
  * ChatGPT 后端的只读查询（[W6-O]）：模型列表（`ama models discover chatgpt`）与 codex 的 `wham/usage`。
  *
- * - SIWC：`GET {base}/models`，只留 `visibility === "list"`（没有该字段的也留）；
- * - codex：`GET {base}/models?client_version=<ama 版本>`，`models[].slug`（同样按 visibility 筛）；
- *   `GET https://chatgpt.com/backend-api/wham/usage`（由 codex base 推出），私有格式，解析失败返回 undefined。
- * 只取 slug 与显示名，上下文窗口不猜。请求带 Bearer；codex 另带 `ChatGPT-Account-ID` 与 `originator`。
+ * - SIWC：`GET {base}/models`，只留 `visibility === "list"`（没有该字段的也留）；条目若带下述元数据字段同样取；
+ * - codex：`GET {base}/models?client_version=<Codex CLI 版本>`（`codexClientVersion()`；后端按每个模型的
+ *   `minimal_client_version` 过滤，发 ama 自己的版本号会一个都拿不到），`models[].slug`（同样按 visibility 筛），
+ *   另取 `context_window`、`input_modalities`、`supported_reasoning_levels` 作元数据（后端给了就优先于 models.dev，
+ *   见 discovered-cache.ts；`max_context_window` 是可调上限而非生效值、`auto_compact_token_limit` 没有对应的模型字段，
+ *   都不取）；`GET https://chatgpt.com/backend-api/wham/usage`（由 codex base 推出），私有格式，解析失败返回 undefined。
+ * 请求带 Bearer；codex 另带 `ChatGPT-Account-ID` 与 `originator`。
  */
 import { parseUsagePayload } from "../../ai/apis/chatgpt-rate-limits.js";
-import { AMA_VERSION } from "../../version.js";
-import { DEFAULT_ORIGINATOR } from "./presets.js";
+import { DEFAULT_CODEX_CLIENT_VERSION, DEFAULT_ORIGINATOR } from "./presets.js";
 export const BACKEND_TIMEOUT_MS = 15_000;
 function headers(auth) {
     const out = {
@@ -26,10 +28,37 @@ function listed(item) {
     const visibility = item["visibility"];
     return visibility === undefined || visibility === "list";
 }
+/** 模型条目里的元数据；字段缺失或形状不对就不填。 */
+function backendMetadata(item) {
+    const out = {};
+    const window = item["context_window"];
+    if (typeof window === "number" && Number.isInteger(window) && window > 0)
+        out.contextWindow = window;
+    const modalities = item["input_modalities"];
+    if (Array.isArray(modalities)) {
+        const input = ["text", "image"].filter((x) => modalities.includes(x));
+        if (input.includes("text"))
+            out.input = input;
+    }
+    const levels = item["supported_reasoning_levels"];
+    if (Array.isArray(levels)) {
+        const efforts = levels
+            .map((level) => typeof level === "string"
+            ? level
+            : typeof level === "object" && level !== null
+                ? level["effort"]
+                : undefined)
+            .filter((x) => typeof x === "string" && x !== "");
+        if (efforts.length > 0)
+            out.reasoningLevels = [...new Set(efforts)];
+    }
+    return out;
+}
 export async function listChatGptModels(fetchFn, baseUrl, auth) {
     const base = baseUrl.replace(/\/+$/, "");
+    const version = auth.clientVersion ?? DEFAULT_CODEX_CLIENT_VERSION;
     const url = auth.flavor === "codex"
-        ? `${base}/models?client_version=${encodeURIComponent(AMA_VERSION)}`
+        ? `${base}/models?client_version=${encodeURIComponent(version)}`
         : `${base}/models`;
     const response = await fetchFn(url, {
         headers: headers(auth),
@@ -49,7 +78,11 @@ export async function listChatGptModels(fetchFn, baseUrl, auth) {
             continue;
         seen.add(id);
         const name = item["display_name"];
-        out.push(typeof name === "string" && name !== "" ? { id, name } : { id });
+        out.push({
+            id,
+            ...(typeof name === "string" && name !== "" ? { name } : {}),
+            ...backendMetadata(item),
+        });
     }
     return out;
 }

package/dist/auth/chatgpt/cli.d.ts

@@ -4,7 +4,8 @@
  * - login：flavor 取 `--flavor` > 用户级 `auth.chatgpt.flavor` > siwc；`--paste` / `--device`（只 codex）/ 缺省
  *   浏览器；codex 首次在 TTY 下一次性确认「非官方、仅个人使用」（非 TTY 需 `--yes`），`acknowledgedAt` 入条目；
  *   成功后在刷新锁下写 auth.json（0600）。
- *   成功后查一次模型列表写发现缓存（`<dataDir>/models/discovered/chatgpt.json`，失败静默）。
+ *   成功后先删旧的发现缓存，再查一次模型列表写缓存（`<dataDir>/models/discovered/chatgpt.json`；0 个也写空表并带
+ *   flavor，免得残留另一种登录方式的缓存；查询失败静默）。codex 返回 0 个时提示 codexClientVersion 可能过旧。
  * - logout：SIWC 先撤销 refresh token（失败照样删本地，提示到 ChatGPT 设置里断开）；codex 只删本地；
  *   同时删发现缓存。
  * - status：flavor、计划、掩码邮箱、access token 剩余、needsLogin；codex 另查 `wham/usage` 显示配额。

package/dist/auth/chatgpt/cli.js

@@ -4,7 +4,8 @@
  * - login：flavor 取 `--flavor` > 用户级 `auth.chatgpt.flavor` > siwc；`--paste` / `--device`（只 codex）/ 缺省
  *   浏览器；codex 首次在 TTY 下一次性确认「非官方、仅个人使用」（非 TTY 需 `--yes`），`acknowledgedAt` 入条目；
  *   成功后在刷新锁下写 auth.json（0600）。
- *   成功后查一次模型列表写发现缓存（`<dataDir>/models/discovered/chatgpt.json`，失败静默）。
+ *   成功后先删旧的发现缓存，再查一次模型列表写缓存（`<dataDir>/models/discovered/chatgpt.json`；0 个也写空表并带
+ *   flavor，免得残留另一种登录方式的缓存；查询失败静默）。codex 返回 0 个时提示 codexClientVersion 可能过旧。
  * - logout：SIWC 先撤销 refresh token（失败照样删本地，提示到 ChatGPT 设置里断开）；codex 只删本地；
  *   同时删发现缓存。
  * - status：flavor、计划、掩码邮箱、access token 剩余、needsLogin；codex 另查 `wham/usage` 显示配额。
@@ -25,7 +26,7 @@ import { clearDiscoveredCache, writeDiscoveredCache } from "../../ai/providers/d
 import { fetchCodexUsage, listChatGptModels } from "./backend-client.js";
 import { maskEmail } from "./claims.js";
 import { loginChatGpt, revokeChatGpt } from "./login.js";
-import { CHATGPT_PROVIDER_ID, chatgptBaseUrl } from "./presets.js";
+import { CHATGPT_PROVIDER_ID, chatgptBaseUrl, codexClientVersion } from "./presets.js";
 import { quotaParts } from "./quota-text.js";
 function userAuthConfig(io) {
     try {
@@ -186,9 +187,14 @@ export async function runLogin(args, io, deps = {}) {
     if (entry.planType === "free")
         io.stdout(`${m.freePlanHint(entry.planType)}\n`);
     if (flavor === "siwc")
-        io.stdout(`${m.siwcLimitHint}\n`);
+        io.stdout(`${m.siwcLimitHint}\n${m.siwcEligibilityHint}\n`);
     const count = await cacheModels(io, entry, config, deps);
-    io.stdout(`${count === undefined ? m.modelHint : m.modelsCached(count)}\n`);
+    const done = count === 0 && flavor === "codex"
+        ? m.codexNoModels(codexClientVersion(config, io.env))
+        : count === undefined || count === 0
+            ? m.modelHint
+            : m.modelsCached(count);
+    io.stdout(`${done}\n`);
     return ExitCode.Ok;
 }
 /**
@@ -196,16 +202,17 @@ export async function runLogin(args, io, deps = {}) {
  * 任何失败静默（返回 undefined，调用方改提示 `ama models discover chatgpt`）。
  */
 async function cacheModels(io, entry, config, deps) {
+    const dataDir = resolveDataDir({ env: io.env });
     try {
+        // 先删旧缓存：换了登录方式时另一 flavor 的缓存不能留下
+        clearDiscoveredCache(dataDir, CHATGPT_PROVIDER_ID);
         const models = await listChatGptModels(deps.fetch ?? fetch, chatgptBaseUrl(entry.flavor, io.env), {
             flavor: entry.flavor,
             accessToken: entry.accessToken,
             accountId: entry.accountId,
             originator: config?.originator,
+            clientVersion: codexClientVersion(config, io.env),
         });
-        if (models.length === 0)
-            return undefined;
-        const dataDir = resolveDataDir({ env: io.env });
         writeDiscoveredCache(dataDir, CHATGPT_PROVIDER_ID, { models, flavor: entry.flavor });
         return models.length;
     }

package/dist/auth/chatgpt/follow.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ChatGPT 订阅：请求渠道跟随当前登录方式。
+ *
+ * `siwc` 与 `codex` 两条渠道协议相同（openai-responses），只差端点、请求头与请求体白名单。会话里的模型是启动
+ * （或选模型）时按当时的登录物化的；用户中途 `ama auth logout` 再换另一种方式登录后，同一会话的下一次请求
+ * 拿到的 token 属于新的 flavor。这里在**请求时**按 token 的 flavor（活 token 登记）把模型改到对应渠道：
+ *
+ * - 模型引用没有显式 `@渠道`（`channelPinned` 不为 true）→ 改到登录 flavor 的渠道（端点、渠道头、compat）；
+ * - 显式写了另一渠道 → 不动，协议层报 `chatgpt_flavor_mismatch`（chatgpt-backend.ts）；
+ * - 不是 ChatGPT 后端、token 不是 OAuth、flavor 已一致 → 原样返回。
+ *
+ * 会话里记录的模型（`model_change`）不算显式：恢复时由 startup-steps 去掉渠道再解析。
+ */
+import type { Model, ProviderData } from "../../ai/types.js";
+/** 按 `apiKey` 对应登录的 flavor 改写模型的渠道；无需改动时返回原对象。 */
+export declare function followChatGptLogin(model: Model, provider: ProviderData | undefined, apiKey: string | undefined): Model;

package/dist/auth/chatgpt/follow.js

@@ -0,0 +1,51 @@
+/**
+ * ChatGPT 订阅：请求渠道跟随当前登录方式。
+ *
+ * `siwc` 与 `codex` 两条渠道协议相同（openai-responses），只差端点、请求头与请求体白名单。会话里的模型是启动
+ * （或选模型）时按当时的登录物化的；用户中途 `ama auth logout` 再换另一种方式登录后，同一会话的下一次请求
+ * 拿到的 token 属于新的 flavor。这里在**请求时**按 token 的 flavor（活 token 登记）把模型改到对应渠道：
+ *
+ * - 模型引用没有显式 `@渠道`（`channelPinned` 不为 true）→ 改到登录 flavor 的渠道（端点、渠道头、compat）；
+ * - 显式写了另一渠道 → 不动，协议层报 `chatgpt_flavor_mismatch`（chatgpt-backend.ts）；
+ * - 不是 ChatGPT 后端、token 不是 OAuth、flavor 已一致 → 原样返回。
+ *
+ * 会话里记录的模型（`model_change`）不算显式：恢复时由 startup-steps 去掉渠道再解析。
+ */
+import { liveToken } from "../oauth/live.js";
+function backendOf(compat) {
+    if (typeof compat !== "object" || compat === null)
+        return undefined;
+    const value = compat.chatgptBackend;
+    return value === "siwc" || value === "codex" ? value : undefined;
+}
+/** 按 `apiKey` 对应登录的 flavor 改写模型的渠道；无需改动时返回原对象。 */
+export function followChatGptLogin(model, provider, apiKey) {
+    const current = backendOf(model.compat);
+    if (current === undefined || model.channelPinned === true)
+        return model;
+    const flavor = liveToken(apiKey)?.flavor;
+    if (flavor === undefined || flavor === current)
+        return model;
+    const channels = provider?.channels ?? [];
+    const target = channels.find((c) => backendOf(c.compat) === flavor) ?? channels.find((c) => c.name === flavor);
+    if (target === undefined)
+        return model;
+    const previous = channels.find((c) => c.name === model.channel);
+    // 去掉旧渠道带来的头（codex 的 originator 等），换上新渠道的
+    const headers = { ...model.headers };
+    for (const name of Object.keys(previous?.headers ?? {}))
+        delete headers[name];
+    Object.assign(headers, target.headers);
+    const next = {
+        ...model,
+        api: target.api,
+        baseUrl: target.baseUrl,
+        channel: target.name,
+        compat: { ...model.compat, ...target.compat, chatgptBackend: flavor },
+    };
+    if (Object.keys(headers).length > 0)
+        next.headers = headers;
+    else
+        delete next.headers;
+    return next;
+}

package/dist/auth/chatgpt/presets.d.ts

@@ -9,6 +9,10 @@
  *
  * 覆盖：`AMA_CHATGPT_CLIENT_ID` / `AMA_CHATGPT_ISSUER`（测试用）/ `AMA_CHATGPT_BASE_URL` > 配置
  * `auth.chatgpt.*` > 条目里签发的 client id > 缺省。
+ *
+ * codex 后端的模型列表按 `client_version` 过滤（每个模型带 `minimal_client_version`，版本过低一个都不给）：
+ * 发的是 Codex CLI 的版本号而不是 ama 的，`AMA_CHATGPT_CODEX_CLIENT_VERSION` > `auth.chatgpt.codexClientVersion`
+ * > `DEFAULT_CODEX_CLIENT_VERSION`。推理请求不带版本（Codex 自己也只在 User-Agent 里带）。
  */
 import type { ChatGptAuthConfig, ChatGptFlavor, OAuthAuthEntry } from "../../config/types-w6.js";
 export declare const CHATGPT_PROVIDER_ID = "chatgpt";
@@ -19,6 +23,8 @@ export declare const SIWC_RESOURCE = "https://api.openai.com/v1";
 export declare const SIWC_REQUIRED_SCOPE = "chatgpt.tokens.use.direct";
 export declare const AGENT_NAME_HINT = "ama";
 export declare const DEFAULT_ORIGINATOR = "codex_cli_rs";
+/** codex 后端 `GET /models?client_version=` 用的 Codex CLI 版本号（模型列表按它过滤）。 */
+export declare const DEFAULT_CODEX_CLIENT_VERSION = "0.160.0";
 export declare const CHATGPT_BASE_URLS: Readonly<Record<ChatGptFlavor, string>>;
 export interface AuthorizeInput {
     redirectUri: string;
@@ -61,6 +67,8 @@ export interface PresetOverrides {
     port?: number | undefined;
 }
 export declare function chatgptBaseUrl(flavor: ChatGptFlavor, env?: Readonly<Record<string, string | undefined>>): string;
+/** codex 模型列表的 `client_version`：环境变量 > 用户级配置 > 缺省。 */
+export declare function codexClientVersion(config?: ChatGptAuthConfig, env?: Readonly<Record<string, string | undefined>>): string;
 export declare function resolveChatGptPreset(flavor: ChatGptFlavor, overrides?: PresetOverrides): ChatGptPreset;
 /** 授权 URL（参数顺序固定，便于测试）。 */
 export declare function authorizeUrl(preset: ChatGptPreset, input: AuthorizeInput): string;

package/dist/auth/chatgpt/presets.js

@@ -9,6 +9,10 @@
  *
  * 覆盖：`AMA_CHATGPT_CLIENT_ID` / `AMA_CHATGPT_ISSUER`（测试用）/ `AMA_CHATGPT_BASE_URL` > 配置
  * `auth.chatgpt.*` > 条目里签发的 client id > 缺省。
+ *
+ * codex 后端的模型列表按 `client_version` 过滤（每个模型带 `minimal_client_version`，版本过低一个都不给）：
+ * 发的是 Codex CLI 的版本号而不是 ama 的，`AMA_CHATGPT_CODEX_CLIENT_VERSION` > `auth.chatgpt.codexClientVersion`
+ * > `DEFAULT_CODEX_CLIENT_VERSION`。推理请求不带版本（Codex 自己也只在 User-Agent 里带）。
  */
 export const CHATGPT_PROVIDER_ID = "chatgpt";
 export const DEFAULT_ISSUER = "https://auth.openai.com";
@@ -18,6 +22,8 @@ export const SIWC_RESOURCE = "https://api.openai.com/v1";
 export const SIWC_REQUIRED_SCOPE = "chatgpt.tokens.use.direct";
 export const AGENT_NAME_HINT = "ama";
 export const DEFAULT_ORIGINATOR = "codex_cli_rs";
+/** codex 后端 `GET /models?client_version=` 用的 Codex CLI 版本号（模型列表按它过滤）。 */
+export const DEFAULT_CODEX_CLIENT_VERSION = "0.160.0";
 export const CHATGPT_BASE_URLS = {
     siwc: "https://api.openai.com/v1",
     codex: "https://chatgpt.com/backend-api/codex",
@@ -29,6 +35,12 @@ function nonEmpty(value) {
 export function chatgptBaseUrl(flavor, env = process.env) {
     return nonEmpty(env["AMA_CHATGPT_BASE_URL"]) ?? CHATGPT_BASE_URLS[flavor];
 }
+/** codex 模型列表的 `client_version`：环境变量 > 用户级配置 > 缺省。 */
+export function codexClientVersion(config, env = process.env) {
+    return (nonEmpty(env["AMA_CHATGPT_CODEX_CLIENT_VERSION"]) ??
+        nonEmpty(config?.codexClientVersion) ??
+        DEFAULT_CODEX_CLIENT_VERSION);
+}
 export function resolveChatGptPreset(flavor, overrides = {}) {
     const env = overrides.env ?? process.env;
     const config = overrides.config;

package/dist/auth/testing/fake-oauth.d.ts

@@ -4,7 +4,8 @@
  * OAuth：authorize（记参数、302 回 redirect_uri；SIWC 注册时带签发的 client_id 与 scope）、token（校验 PKCE；
  * 授权码 / 刷新；刷新轮换，旧 refresh token 再用 → `refresh_token_reused`）、deviceauth、discovery + JWKS
  * （现场生成 RSA 密钥对）、revoke。后端：`/v1/responses`、`/codex/responses`、`/v1/models`、`/codex/models`、
- * `/wham/usage`，按脚本回放。
+ * `/wham/usage`，按脚本回放；给了 `codexModels` 时 `/codex/models` 改按 `client_version` 过滤（不带 → 400，
+ * 低于条目的 `minimal_client_version` 不给），与真实 codex 后端一致。
  */
 export interface RecordedRequest {
     method: string;
@@ -37,6 +38,8 @@ export interface FakeOAuthOptions {
     /** 设备码轮询先返回几次 403。 */
     devicePending?: number;
     marker?: string;
+    /** codex 模型目录（`/codex/models` 按 `client_version` 过滤后返回 `{ models }`）。 */
+    codexModels?: Record<string, unknown>[];
 }
 export declare class FakeOAuthServer {
     readonly options: FakeOAuthOptions;

package/dist/auth/testing/fake-oauth.js

@@ -4,10 +4,22 @@
  * OAuth：authorize（记参数、302 回 redirect_uri；SIWC 注册时带签发的 client_id 与 scope）、token（校验 PKCE；
  * 授权码 / 刷新；刷新轮换，旧 refresh token 再用 → `refresh_token_reused`）、deviceauth、discovery + JWKS
  * （现场生成 RSA 密钥对）、revoke。后端：`/v1/responses`、`/codex/responses`、`/v1/models`、`/codex/models`、
- * `/wham/usage`，按脚本回放。
+ * `/wham/usage`，按脚本回放；给了 `codexModels` 时 `/codex/models` 改按 `client_version` 过滤（不带 → 400，
+ * 低于条目的 `minimal_client_version` 不给），与真实 codex 后端一致。
  */
 import { createHash, generateKeyPairSync, randomBytes, sign } from "node:crypto";
 import { createServer } from "node:http";
+/** `a.b.c` 比较；非数字段按 0。 */
+function compareVersion(a, b) {
+    const pa = a.split(".").map((x) => Number.parseInt(x, 10) || 0);
+    const pb = b.split(".").map((x) => Number.parseInt(x, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
 function b64url(value) {
     return Buffer.from(JSON.stringify(value)).toString("base64url");
 }
@@ -212,6 +224,17 @@ export class FakeOAuthServer {
                     code_challenge: "x",
                 });
             }
+            case "/codex/models": {
+                const catalog = this.options.codexModels;
+                if (catalog === undefined)
+                    return this.backend(res);
+                const version = url.searchParams.get("client_version");
+                if (version === null)
+                    return json(400, { error: { message: "client_version required" } });
+                return json(200, {
+                    models: catalog.filter((m) => compareVersion(version, String(m["minimal_client_version"] ?? "0")) >= 0),
+                });
+            }
             case "/revoke":
                 this.revoked.push(params()["token"] ?? "");
                 res.writeHead(200).end();