@armadra/agent 0.6.1 → 0.6.2

package/CHANGELOG.md

@@ -5,6 +5,23 @@ English · [简体中文](CHANGELOG.zh-CN.md)
 > This file is in English starting with 0.6.0. Release notes for 0.1 through 0.5.1 are in Chinese in
 > [CHANGELOG.zh-CN.md](CHANGELOG.zh-CN.md). New entries go into both files.
 
+## 0.6.2 (2026-10-03)
+
+- **ChatGPT codex sign-in lists models, and the channel follows the sign-in method**: the codex model list
+  (`GET /models?client_version=…`) used to send ama's own version, which the backend filters against each model's minimum
+  Codex client version, so it returned no models; it now sends a Codex CLI version (default `0.160.0`, new user-level
+  `auth.chatgpt.codexClientVersion`, environment `AMA_CHATGPT_CODEX_CLIENT_VERSION`) and suggests raising it when codex still
+  returns none. The context window, input modalities and reasoning efforts from the codex response go into the discovery cache
+  and are used when models.dev has no data. Requests to `chatgpt` now pick the channel from the current sign-in at request time:
+  a model without an explicit `@channel` follows it, so a running session keeps working after switching between siwc and codex,
+  and a resumed session ignores the channel it recorded; only an explicit `@channel` that differs reports
+  `chatgpt_flavor_mismatch`, now with a clearer message. Login always rewrites the discovery cache (an empty list included)
+  after deleting the old one, and a cache whose flavor differs from the current sign-in counts as stale. `not_eligible` now
+  lists the likely causes (plan, workspace account, region or preview rollout — the most likely one for Pro accounts) and
+  suggests `--flavor codex`; a siwc login notes that eligibility is only confirmed on the first request. Also fixed: an
+  unlisted slug with an explicit `@channel` (`chatgpt/<slug>@siwc`) kept the default channel's endpoint. Docs:
+  docs/en/providers.md "ChatGPT login".
+
 ## 0.6.1 (2026-10-03)
 
 - **The model picker shows only configured models; ChatGPT models can be picked**: `/model` (and the startup picker and

package/CHANGELOG.zh-CN.md

@@ -4,6 +4,18 @@
 
 > 从 0.6.0 起 [CHANGELOG.md](CHANGELOG.md) 为英文，本文件保留中文记录（0.1–0.5.1 的完整历史在此）。新条目两份都要加。
 
+## 0.6.2（2026-10-03）
+
+- **ChatGPT codex 方式能列出模型，渠道跟随登录方式**：codex 模型列表（`GET /models?client_version=…`）原来发 ama 自己的版本号，
+  后端按每个模型的最低 Codex 客户端版本过滤，于是一个模型都不返回；现在发 Codex CLI 版本号（缺省 `0.160.0`，新增用户级
+  `auth.chatgpt.codexClientVersion` 与环境变量 `AMA_CHATGPT_CODEX_CLIENT_VERSION`），仍为 0 个时提示调高。codex 响应里的上下文
+  窗口、输入模态、推理强度写进发现缓存，models.dev 补不到时用它。`chatgpt` 的请求在请求时按当前登录方式选渠道：没写 `@渠道` 的
+  模型跟随登录，运行中的会话在 siwc 与 codex 之间换登录后照常继续，恢复会话时也不沿用记录的渠道；只有显式写了不符的 `@渠道`
+  才报 `chatgpt_flavor_mismatch`，文案更清楚。登录先删旧发现缓存再重写（0 个也写空表），缓存 flavor 与当前登录不符视为过期。
+  `not_eligible` 改为列出可能原因（套餐、工作空间账户、地区受限或预览期未开放——Pro 账户最可能是这一条）并提示
+  `--flavor codex`；siwc 登录成功后说明能否共享额度要到首次请求才能确认。另修复：表外 slug 显式写 `@渠道`
+  （`chatgpt/<slug>@siwc`）时仍用缺省渠道的地址。文档：docs/providers.md「ChatGPT 登录」。
+
 ## 0.6.1（2026-10-03）
 
 - **模型选择器只显示已配置的模型，ChatGPT 模型可选**：`/model`（以及启动选择器、`/config` 的模型项）只列有 key、OAuth 已登录或

package/dist/agent/session-settings.d.ts

@@ -11,7 +11,10 @@ import type { ToolDefinition } from "../tools/types.js";
 import type { StreamFn } from "./loop.js";
 import type { AgentSessionOptions, SessionCore } from "./session-core.js";
 import type { SystemPromptInput } from "./system-prompt.js";
-/** 按模型的协议分派到已注册的实现（会话流的最内层）。 */
+/**
+ * 按模型的协议分派到已注册的实现（会话流的最内层）。ChatGPT 订阅模型先按本次 token 的登录方式改渠道
+ * （没写 `@渠道` 时；auth/chatgpt/follow.ts），会话中途换登录方式不用重启。
+ */
 export declare function providerStream(providers: ProviderRegistryApi): StreamFn;
 export type StaticSystemInput = Omit<SystemPromptInput, "tools" | "cwd">;
 export interface SessionSettingsDeps {

package/dist/agent/session-settings.js

@@ -5,11 +5,16 @@
  * 纯搬迁：`setModel / setThinkingLevel / setPermissionMode / setActiveTools / addTool /
  * updateSystem / announceStart / getTools` 的行为与事件顺序不变；`AgentSessionImpl` 以同名成员转发。
  */
+import { followChatGptLogin } from "../auth/chatgpt/follow.js";
 import { AmaError } from "../errors.js";
 import { appendModelChange, findModelOrThrow, sessionStartEvent } from "./session-sync.js";
-/** 按模型的协议分派到已注册的实现（会话流的最内层）。 */
+/**
+ * 按模型的协议分派到已注册的实现（会话流的最内层）。ChatGPT 订阅模型先按本次 token 的登录方式改渠道
+ * （没写 `@渠道` 时；auth/chatgpt/follow.ts），会话中途换登录方式不用重启。
+ */
 export function providerStream(providers) {
-    return (model, context, streamOptions) => {
+    return (requested, context, streamOptions) => {
+        const model = followChatGptLogin(requested, providers.get(requested.provider), streamOptions.apiKey);
         const api = providers.getApi(model.api);
         if (api === undefined) {
             throw new AmaError("provider_not_found", `no implementation registered for api ${model.api}`);

package/dist/ai/apis/chatgpt-backend.d.ts

@@ -10,7 +10,9 @@
  * - 出错恢复（每种至多一次）：401 → 强制刷新重试；SIWC 400 `subscription_sharing_unsupported_capability` → 删去
  *   `error.param` 重试；codex 400 `Instructions are not valid` → 本会话切 developer-message 重试；
  * - 错误映射（文案带码前缀，宿主按码判断）：429 配额 → `quota_exceeded`（不重试）；失效 → `auth_expired`；
- *   SIWC 403 `subscription_sharing_user_not_eligible` → `not_eligible`；503 留给会话层现有重试；
+ *   SIWC 403 `subscription_sharing_user_not_eligible` → `not_eligible`（i18n 文案列出原因）；503 留给会话层现有重试；
+ * - 渠道跟随登录方式由会话层做（auth/chatgpt/follow.ts）；到这里仍不符说明用户显式写了 `@渠道`，报
+ *   `chatgpt_flavor_mismatch`（i18n）；
  * - 用量：`cost = 0`、`billing: "subscription"`。
  */
 import { type LiveToken } from "../../auth/oauth/live.js";
@@ -25,7 +27,10 @@ export declare function sessionKeyOf(model: Model, options: StreamOptions): stri
 export declare function resetChatGptState(): void;
 export declare function instructionsModeOf(model: Model, compat: OpenAIResponsesCompat, options: StreamOptions): "native" | "developer-message";
 export declare function transformChatGptBody(body: Json, model: Model, compat: OpenAIResponsesCompat, options: StreamOptions): Json;
-/** 发请求前：needsLogin 直接报 auth_expired；登录 flavor 与渠道不符报错。 */
+/**
+ * 发请求前：needsLogin 直接报 auth_expired；登录 flavor 与渠道不符报错（没写 `@渠道` 的模型会话层已改到登录的
+ * 渠道，走到这里的是显式指定了另一渠道）。
+ */
 export declare function chatgptPrecheck(model: Model, compat: OpenAIResponsesCompat, apiKey?: string): void;
 export declare function chatgptHeaders(compat: OpenAIResponsesCompat, options: StreamOptions, apiKey: string | undefined): Record<string, string>;
 /** 包一层 onResponse：解析响应头里的配额。 */

package/dist/ai/apis/chatgpt-backend.js

@@ -10,11 +10,14 @@
  * - 出错恢复（每种至多一次）：401 → 强制刷新重试；SIWC 400 `subscription_sharing_unsupported_capability` → 删去
  *   `error.param` 重试；codex 400 `Instructions are not valid` → 本会话切 developer-message 重试；
  * - 错误映射（文案带码前缀，宿主按码判断）：429 配额 → `quota_exceeded`（不重试）；失效 → `auth_expired`；
- *   SIWC 403 `subscription_sharing_user_not_eligible` → `not_eligible`；503 留给会话层现有重试；
+ *   SIWC 403 `subscription_sharing_user_not_eligible` → `not_eligible`（i18n 文案列出原因）；503 留给会话层现有重试；
+ * - 渠道跟随登录方式由会话层做（auth/chatgpt/follow.ts）；到这里仍不符说明用户显式写了 `@渠道`，报
+ *   `chatgpt_flavor_mismatch`（i18n）；
  * - 用量：`cost = 0`、`billing: "subscription"`。
  */
 import { liveToken } from "../../auth/oauth/live.js";
 import { authExpiredError } from "../../auth/oauth/refresh.js";
+import { msg } from "../../i18n/index.js";
 import { parseQuotaHeaders, parseRateLimitEvent, quotaFromLimitError, } from "./chatgpt-rate-limits.js";
 export const SIWC_FORBIDDEN_FIELDS = [
     "background",
@@ -81,7 +84,10 @@ export function transformChatGptBody(body, model, compat, options) {
     out["input"] = input;
     return out;
 }
-/** 发请求前：needsLogin 直接报 auth_expired；登录 flavor 与渠道不符报错。 */
+/**
+ * 发请求前：needsLogin 直接报 auth_expired；登录 flavor 与渠道不符报错（没写 `@渠道` 的模型会话层已改到登录的
+ * 渠道，走到这里的是显式指定了另一渠道）。
+ */
 export function chatgptPrecheck(model, compat, apiKey) {
     const live = liveToken(apiKey);
     if (live === undefined)
@@ -89,7 +95,9 @@ export function chatgptPrecheck(model, compat, apiKey) {
     if (live.needsLogin === true)
         throw authExpiredError(live.provider);
     if (live.flavor !== compat.chatgptBackend) {
-        throw new Error(`chatgpt_flavor_mismatch: logged in with ${live.flavor} but ${model.provider}/${model.id} uses the ${String(compat.chatgptBackend)} channel; run \`ama auth login ${live.provider} --flavor ${String(compat.chatgptBackend)}\` or switch channel`);
+        const pinned = String(compat.chatgptBackend);
+        const ref = `${model.provider}/${model.id}@${pinned}`;
+        throw new Error(`chatgpt_flavor_mismatch: ${msg().auth.request.flavorMismatch(live.flavor, ref, pinned)}`);
     }
 }
 export function chatgptHeaders(compat, options, apiKey) {
@@ -196,7 +204,7 @@ export function recoverChatGptError(error, model, compat, options, apiKey, tried
         code === "subscription_sharing_user_not_eligible")
         return {
             kind: "fail",
-            error: new Error("not_eligible: this ChatGPT account cannot share plan usage with ama (403 subscription_sharing_user_not_eligible)"),
+            error: new Error(`not_eligible: ${msg().auth.request.notEligible}`),
         };
     if (backend === "siwc" &&
         error.status === 400 &&

package/dist/ai/providers/discovered-cache.d.ts

@@ -4,9 +4,12 @@
  * 模型表为空、接受任意 slug 的供应商（`chatgpt` 的订阅后端）在选择器里原本一个模型都看不到。
  * `ama auth login chatgpt` 成功后与 `ama models discover chatgpt` 把账户可用的 slug 写进这里；组装注册表时
  * （`mergeDiscoveredModels`）并入**模型表仍为空**的供应商，元数据用 models.dev（快照 ⊕ 用户刷新）补全。
- * `ama auth logout chatgpt` 删掉它。只存 slug、显示名、flavor 与时间戳——没有 token、账户 id。
+ * `ama auth logout chatgpt` 删掉它。只存 slug、显示名、后端给的元数据（codex：上下文窗口、输入模态、推理强度，
+ * models.dev 补不到时用）、flavor 与时间戳——没有 token、账户 id。
+ *
+ * ChatGPT 的缓存带登录 flavor；组装时与当前登录的 flavor 不符视为过期、不并入（选择器提示重新发现）。
  */
-import type { Model, ProviderData } from "../types.js";
+import type { Model, ModelThinkingLevel, ProviderData } from "../types.js";
 import type { ModelsDevIndex } from "./models-dev.js";
 export declare const DISCOVERED_CACHE_VERSION = 1;
 export interface DiscoveredCacheFile {
@@ -16,10 +19,15 @@ export interface DiscoveredCacheFile {
     fetchedAt: string;
     /** ChatGPT 登录的 flavor（siwc / codex）；其它供应商不写。 */
     flavor?: string;
-    models: {
-        id: string;
-        name?: string;
-    }[];
+    models: DiscoveredCacheModel[];
+}
+/** 缓存里的一个模型：slug、显示名与后端给的元数据（都可缺）。 */
+export interface DiscoveredCacheModel {
+    id: string;
+    name?: string;
+    contextWindow?: number;
+    input?: ("text" | "image")[];
+    reasoningLevels?: string[];
 }
 /** 缓存文件位置。 */
 export declare function discoveredCachePath(dataDir: string, provider: string): string;
@@ -27,15 +35,16 @@ export declare function discoveredCachePath(dataDir: string, provider: string):
 export declare function readDiscoveredCache(dataDir: string, provider: string): DiscoveredCacheFile | undefined;
 /** 写缓存（先写临时文件再改名）；返回路径。 */
 export declare function writeDiscoveredCache(dataDir: string, provider: string, input: {
-    models: readonly {
-        id: string;
+    models: readonly (Omit<DiscoveredCacheModel, "name"> & {
         name?: string | undefined;
-    }[];
+    })[];
     flavor?: string | undefined;
 }, now?: number): string;
 /** 删缓存；删了返回 true。 */
 export declare function clearDiscoveredCache(dataDir: string, provider: string): boolean;
-/** 缓存里的模型 → 注册表模型（models.dev 补元数据，补不到用自定义缺省）。 */
+/** 后端给的推理强度 → 思考级别映射（`none` 对应 off；没列出的级别不支持）。 */
+export declare function thinkingMapOf(levels: readonly string[]): Partial<Record<ModelThinkingLevel, string | null>>;
+/** 缓存里的模型 → 注册表模型（models.dev 补元数据，补不到用后端给的，再补不到用自定义缺省）。 */
 export declare function discoveredModels(file: DiscoveredCacheFile, provider: ProviderData, modelsDev: () => ModelsDevIndex | undefined): Model[];
 /** 注册表里能追加模型的最小接口（`ProviderRegistry.addModels`）。 */
 export interface DiscoveredTarget {
@@ -45,4 +54,6 @@ export interface DiscoveredTarget {
 /**
  * 把缓存并入模型表为空的供应商（本地服务除外：它们每次启动现场探测）。返回并入了的供应商 id。
  */
-export declare function mergeDiscoveredModels(registry: DiscoveredTarget, dataDir: string, modelsDev: () => ModelsDevIndex | undefined): string[];
+export declare function mergeDiscoveredModels(registry: DiscoveredTarget, dataDir: string, modelsDev: () => ModelsDevIndex | undefined, 
+/** 当前登录的 flavor（只有 OAuth 供应商有）：缓存的 flavor 与之不符视为过期，不并入。 */
+loginFlavor?: (providerId: string) => string | undefined): string[];

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

@@ -4,7 +4,10 @@
  * 模型表为空、接受任意 slug 的供应商（`chatgpt` 的订阅后端）在选择器里原本一个模型都看不到。
  * `ama auth login chatgpt` 成功后与 `ama models discover chatgpt` 把账户可用的 slug 写进这里；组装注册表时
  * （`mergeDiscoveredModels`）并入**模型表仍为空**的供应商，元数据用 models.dev（快照 ⊕ 用户刷新）补全。
- * `ama auth logout chatgpt` 删掉它。只存 slug、显示名、flavor 与时间戳——没有 token、账户 id。
+ * `ama auth logout chatgpt` 删掉它。只存 slug、显示名、后端给的元数据（codex：上下文窗口、输入模态、推理强度，
+ * models.dev 补不到时用）、flavor 与时间戳——没有 token、账户 id。
+ *
+ * ChatGPT 的缓存带登录 flavor；组装时与当前登录的 flavor 不符视为过期、不并入（选择器提示重新发现）。
  */
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -15,11 +18,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 +56,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 +67,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 +83,36 @@ 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 没补上的字段用后端给的元数据。 */
+function withBackendMetadata(model, cached, matched) {
+    if (model.contextWindow === undefined && cached.contextWindow !== undefined)
+        model.contextWindow = cached.contextWindow;
+    if (matched)
+        return;
+    if (cached.input !== undefined)
+        model.input = [...cached.input];
+    const efforts = (cached.reasoningLevels ?? []).filter((x) => x !== "none");
+    if (efforts.length > 0) {
+        model.reasoning = true;
+        model.thinkingLevelMap = thinkingMapOf(cached.reasoningLevels ?? []);
+    }
+}
+/** 缓存里的模型 → 注册表模型（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 { entry, metadata } = enrichEntry(m.name ? { id: m.id, name: m.name } : { id: m.id }, modelsDev);
         const model = withCustomDefaults(entry, provider.id, provider.api);
+        withBackendMetadata(model, m, metadata.match !== undefined);
         // 只挂发现时登录的 flavor 对应的渠道（订阅后端的另一条渠道用不了，不在说明与 `@` 行里出现）；
         // 缓存没写 flavor 或渠道不存在时用供应商的缺省渠道
         const names = (provider.channels ?? []).map((c) => c.name);
@@ -87,7 +126,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 +136,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

@@ -2,9 +2,11 @@
  * 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 筛）；
+ * - 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 补不到时用）；
  *   `GET https://chatgpt.com/backend-api/wham/usage`（由 codex base 推出），私有格式，解析失败返回 undefined。
- * 只取 slug 与显示名，上下文窗口不猜。请求带 Bearer；codex 另带 `ChatGPT-Account-ID` 与 `originator`。
+ * SIWC 只取 slug 与显示名。请求带 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 +17,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 后端给。 */
+    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

@@ -2,13 +2,14 @@
  * 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 筛）；
+ * - 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 补不到时用）；
  *   `GET https://chatgpt.com/backend-api/wham/usage`（由 codex base 推出），私有格式，解析失败返回 undefined。
- * 只取 slug 与显示名，上下文窗口不猜。请求带 Bearer；codex 另带 `ChatGPT-Account-ID` 与 `originator`。
+ * SIWC 只取 slug 与显示名。请求带 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 +27,37 @@ function listed(item) {
     const visibility = item["visibility"];
     return visibility === undefined || visibility === "list";
 }
+/** codex 模型条目里的元数据；字段缺失或形状不对就不填。 */
+function codexMetadata(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 +77,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 } : {}),
+            ...(auth.flavor === "codex" ? codexMetadata(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;
+}