@armadra/agent 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -5,6 +5,49 @@ 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
+  `/config` model items) lists only providers with a key, a valid OAuth sign-in or a local server, one row per model on
+  multi-channel providers (other channels in the description; type `@` in the filter for `model@channel` rows); the current
+  model is pinned when it is not listed. `Tab` switches to "all" (unconfigured providers marked "no key configured", with an
+  `ama auth set` hint), `Space` adds / removes the highlighted model to / from the new user-level `models.enabled` list
+  (`provider/model[@channel]`, `provider/*`), which, once set, is all the picker shows; `ama models enable | disable` and
+  `ama models list --enabled` edit and show it. `ama auth login chatgpt` now fetches the models available to the account
+  (read-only, no usage) into `<dataDir>/models/discovered/chatgpt.json`, `ama models discover chatgpt` rewrites it and
+  logout deletes it; the registry merges the cache into providers with an empty model table, so ChatGPT models appear in
+  `/model` and `ama models list`. Note: with only a ChatGPT sign-in and no `defaultModel`, the first cached ChatGPT model can
+  now be chosen as the default model. Docs: docs/en/tui.md, docs/en/providers.md "ChatGPT login".
+
+- **`ama auth login chatgpt` explains a refused sign-in**: when the OAuth callback carries `error=access_denied` (or another
+  error) the message now lists the likely causes (the authorization page was cancelled or plan usage was not checked; the
+  account / plan is not eligible — sharing is Plus / Pro only, Team / Enterprise workspaces may not offer it, the browser may be
+  signed in to another account; the region is not supported) and, for siwc, suggests the fallback
+  `ama auth login chatgpt --flavor codex`. Nothing is retried or switched automatically.
+
+- **`ama config set` reports the written value when a higher layer overrides it**: with e.g. `AMA_LANG=zh`,
+  `ama config set ui.language en` used to print the effective value `zh` labelled "(user)". The first line is now the value just
+  written and its layer (`ui.language = en (written to user)`), and the second line names the override and the effective value
+  (`Still overridden by AMA_LANG (zh); the effective value is zh`). `ama config get` still shows the effective value and its
+  real source.
+
 ## 0.6.0 (2026-10-03)
 
 Wave 6: the agent bar and sub-agent view, traces, memory, ChatGPT login, the `/config` settings panel, and a bilingual

package/CHANGELOG.zh-CN.md

@@ -4,6 +4,38 @@
 
 > 从 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 已登录或
+  本地服务的供应商；多渠道供应商每个模型一行（其它渠道写在说明里，筛选文本输入 `@` 列出 `模型@渠道` 行）；当前模型不在列表里时
+  置顶。`Tab` 切到「全部」（没配置的供应商标「未配置 key」，选中时提示 `ama auth set`），`Space` 把高亮的模型加入 / 移出新的
+  用户级清单 `models.enabled`（`provider/model[@channel]`、`provider/*`），设置后选择器只列清单内的模型；`ama models enable |
+disable` 与 `ama models list --enabled` 在命令行编辑和查看。`ama auth login chatgpt` 成功后拉取账户可用的模型（只读、不消耗
+  额度）缓存到 `<dataDir>/models/discovered/chatgpt.json`，`ama models discover chatgpt` 重写、logout 删除；注册表把缓存并入模型
+  表为空的供应商，ChatGPT 模型因此出现在 `/model` 与 `ama models list` 里。注意：只登录了 ChatGPT、没设 `defaultModel` 时，
+  缺省模型现在可能选中缓存里的第一个 ChatGPT 模型。文档：docs/tui.md、docs/providers.md「ChatGPT 登录」。
+
+- **`ama auth login chatgpt` 授权被拒时说明原因**：OAuth 回调带 `error=access_denied`（或其它 error）时，提示改为列出可能原因
+  （在授权页取消或没勾选使用 ChatGPT 套餐额度；账户 / 套餐不符合——额度共享只对 Plus / Pro 开放，Team / Enterprise 工作空间可能
+  未开放，浏览器可能登录了别的账户；所在地区受限），siwc 下另提示可改用备用 `ama auth login chatgpt --flavor codex`。不自动重试、
+  不自动换 flavor。
+
+- **`ama config set` 被更高优先级来源覆盖时，回执显示刚写入的值**：如 `AMA_LANG=zh` 下 `ama config set ui.language en`，原来
+  第一行显示覆盖后的生效值 `zh` 却标「（用户级）」。现在第一行是刚写入的值与写入层（`ui.language = en（已写入用户级）`），第二行
+  提示覆盖来源与生效值（`当前仍被 AMA_LANG（zh）覆盖，生效值为 zh`）。`ama config get` 仍显示生效值与真实来源。
+
 ## 0.6.0（2026-10-03）
 
 第六波：Agent 栏与子 Agent 视图、轨迹、记忆（Memory）、ChatGPT 登录、`/config` 设置面板、中英双语界面。设计依据与决定表见

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

@@ -0,0 +1,59 @@
+/**
+ * 发现得到的模型列表缓存：`<dataDir>/models/discovered/<provider>.json`。
+ *
+ * 模型表为空、接受任意 slug 的供应商（`chatgpt` 的订阅后端）在选择器里原本一个模型都看不到。
+ * `ama auth login chatgpt` 成功后与 `ama models discover chatgpt` 把账户可用的 slug 写进这里；组装注册表时
+ * （`mergeDiscoveredModels`）并入**模型表仍为空**的供应商，元数据用 models.dev（快照 ⊕ 用户刷新）补全。
+ * `ama auth logout chatgpt` 删掉它。只存 slug、显示名、后端给的元数据（codex：上下文窗口、输入模态、推理强度，
+ * models.dev 补不到时用）、flavor 与时间戳——没有 token、账户 id。
+ *
+ * ChatGPT 的缓存带登录 flavor；组装时与当前登录的 flavor 不符视为过期、不并入（选择器提示重新发现）。
+ */
+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 {
+    version: number;
+    provider: string;
+    /** ISO 时间。 */
+    fetchedAt: string;
+    /** ChatGPT 登录的 flavor（siwc / codex）；其它供应商不写。 */
+    flavor?: 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;
+/** 读缓存；不存在、损坏或形状不对返回 undefined（不报错，选择器给提示行）。 */
+export declare function readDiscoveredCache(dataDir: string, provider: string): DiscoveredCacheFile | undefined;
+/** 写缓存（先写临时文件再改名）；返回路径。 */
+export declare function writeDiscoveredCache(dataDir: string, provider: string, input: {
+    models: readonly (Omit<DiscoveredCacheModel, "name"> & {
+        name?: string | undefined;
+    })[];
+    flavor?: string | undefined;
+}, now?: number): string;
+/** 删缓存；删了返回 true。 */
+export declare function clearDiscoveredCache(dataDir: string, provider: string): boolean;
+/** 后端给的推理强度 → 思考级别映射（`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 {
+    list(): readonly ProviderData[];
+    addModels(providerId: string, models: readonly Model[], source?: "discovered"): void;
+}
+/**
+ * 把缓存并入模型表为空的供应商（本地服务除外：它们每次启动现场探测）。返回并入了的供应商 id。
+ */
+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

@@ -0,0 +1,146 @@
+/**
+ * 发现得到的模型列表缓存：`<dataDir>/models/discovered/<provider>.json`。
+ *
+ * 模型表为空、接受任意 slug 的供应商（`chatgpt` 的订阅后端）在选择器里原本一个模型都看不到。
+ * `ama auth login chatgpt` 成功后与 `ama models discover chatgpt` 把账户可用的 slug 写进这里；组装注册表时
+ * （`mergeDiscoveredModels`）并入**模型表仍为空**的供应商，元数据用 models.dev（快照 ⊕ 用户刷新）补全。
+ * `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";
+import { withCustomDefaults } from "./catalog.js";
+import { enrichEntry } from "./enrich.js";
+export const DISCOVERED_CACHE_VERSION = 1;
+/** 缓存文件位置。 */
+export function discoveredCachePath(dataDir, provider) {
+    return join(dataDir, "models", "discovered", `${provider}.json`);
+}
+/** 未知值 → 缓存模型；id 不对返回 undefined，元数据字段形状不对的丢掉。 */
+function toEntry(value) {
+    if (typeof value !== "object" || value === null)
+        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) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(discoveredCachePath(dataDir, provider), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return undefined;
+    const file = parsed;
+    if (file.provider !== provider || !Array.isArray(file.models))
+        return undefined;
+    return {
+        version: typeof file.version === "number" ? file.version : DISCOVERED_CACHE_VERSION,
+        provider,
+        fetchedAt: typeof file.fetchedAt === "string" ? file.fetchedAt : "",
+        ...(typeof file.flavor === "string" ? { flavor: file.flavor } : {}),
+        models: file.models.map(toEntry).filter((m) => m !== undefined),
+    };
+}
+/** 写缓存（先写临时文件再改名）；返回路径。 */
+export function writeDiscoveredCache(dataDir, provider, input, now = Date.now()) {
+    const path = discoveredCachePath(dataDir, provider);
+    const file = {
+        version: DISCOVERED_CACHE_VERSION,
+        provider,
+        fetchedAt: new Date(now).toISOString(),
+        ...(input.flavor !== undefined ? { flavor: input.flavor } : {}),
+        models: input.models.map(toEntry).filter((m) => m !== undefined),
+    };
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(file, null, 2)}\n`);
+    renameSync(tmp, path);
+    return path;
+}
+/** 删缓存；删了返回 true。 */
+export function clearDiscoveredCache(dataDir, provider) {
+    const path = discoveredCachePath(dataDir, provider);
+    if (!existsSync(path))
+        return false;
+    rmSync(path, { force: true });
+    return true;
+}
+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, 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);
+        if (names.length > 0) {
+            const own = file.flavor !== undefined && names.includes(file.flavor) ? file.flavor : undefined;
+            model.channels = [own ?? provider.defaultChannel ?? names[0]];
+        }
+        return model;
+    });
+}
+/**
+ * 把缓存并入模型表为空的供应商（本地服务除外：它们每次启动现场探测）。返回并入了的供应商 id。
+ */
+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)
+            continue;
+        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);
+    }
+    return merged;
+}

package/dist/ai/providers/model-visibility.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 模型选择器的可见性规则（`/model`、启动选择器、`/config` 的模型项、`ama models list --enabled` 共用）。
+ *
+ * - 供应商的可用状态：本地（`requiresApiKey: false`）、有 key、OAuth 已登录、OAuth 需重新登录、没配置；
+ *   前三种算「已配置」，缺省只显示它们的模型。
+ * - `models.enabled`（用户级）：`provider/model[@channel]` 或 `provider/*`；设置后只显示清单内的模型。
+ *   清单为空等同不设（写回时删掉这个键）。
+ */
+import type { ProviderData, ProviderRegistryApi } from "../types.js";
+export type ProviderAccess = "local" | "key" | "oauth" | "needsLogin" | "none";
+/** 解析 key 判断供应商的可用状态（OAuth 条目会按需刷新，与发请求前相同）。 */
+export declare function providerAccess(registry: ProviderRegistryApi, provider: ProviderData): Promise<ProviderAccess>;
+export declare function accessReady(access: ProviderAccess): boolean;
+/** `provider/model@channel` → 三段（模型 id 里可以有 `/`）。 */
+export declare function splitEnabledRef(ref: string): {
+    provider: string;
+    model: string;
+    channel?: string;
+} | undefined;
+/**
+ * 清单是否包含该行：`exact` 是逐字列出（`provider/model`，渠道行要 `provider/model@channel`），
+ * `wildcard` 只经 `provider/*` 匹配上。
+ */
+export declare function enabledMatch(list: readonly string[], ref: string): {
+    kind: "exact" | "wildcard";
+    pattern: string;
+} | undefined;
+/** 追加（去重、保持顺序）。 */
+export declare function addEnabled(list: readonly string[] | undefined, refs: readonly string[]): string[];
+/** 移出；移空返回 undefined（删掉键，恢复「显示全部已配置」）。 */
+export declare function removeEnabled(list: readonly string[] | undefined, refs: readonly string[]): string[] | undefined;
+/** 配置里的清单：非数组或空数组视为未设置。 */
+export declare function enabledList(value: unknown): readonly string[] | undefined;

package/dist/ai/providers/model-visibility.js

@@ -0,0 +1,70 @@
+/**
+ * 模型选择器的可见性规则（`/model`、启动选择器、`/config` 的模型项、`ama models list --enabled` 共用）。
+ *
+ * - 供应商的可用状态：本地（`requiresApiKey: false`）、有 key、OAuth 已登录、OAuth 需重新登录、没配置；
+ *   前三种算「已配置」，缺省只显示它们的模型。
+ * - `models.enabled`（用户级）：`provider/model[@channel]` 或 `provider/*`；设置后只显示清单内的模型。
+ *   清单为空等同不设（写回时删掉这个键）。
+ */
+import { liveToken } from "../../auth/oauth/live.js";
+/** 解析 key 判断供应商的可用状态（OAuth 条目会按需刷新，与发请求前相同）。 */
+export async function providerAccess(registry, provider) {
+    if (!provider.requiresApiKey)
+        return "local";
+    const key = await registry
+        .resolveApiKey(provider.id)
+        .catch(() => ({ apiKey: undefined, source: "none" }));
+    if (key.apiKey === undefined)
+        return "none";
+    if (key.source !== "oauth")
+        return "key";
+    return liveToken(key.apiKey)?.needsLogin === true ? "needsLogin" : "oauth";
+}
+export function accessReady(access) {
+    return access === "local" || access === "key" || access === "oauth";
+}
+/** `provider/model@channel` → 三段（模型 id 里可以有 `/`）。 */
+export function splitEnabledRef(ref) {
+    const slash = ref.indexOf("/");
+    if (slash <= 0 || slash === ref.length - 1)
+        return undefined;
+    const provider = ref.slice(0, slash);
+    const rest = ref.slice(slash + 1);
+    const at = rest.lastIndexOf("@");
+    if (at > 0)
+        return { provider, model: rest.slice(0, at), channel: rest.slice(at + 1) };
+    return { provider, model: rest };
+}
+/**
+ * 清单是否包含该行：`exact` 是逐字列出（`provider/model`，渠道行要 `provider/model@channel`），
+ * `wildcard` 只经 `provider/*` 匹配上。
+ */
+export function enabledMatch(list, ref) {
+    if (list.includes(ref))
+        return { kind: "exact", pattern: ref };
+    const parts = splitEnabledRef(ref);
+    if (parts === undefined)
+        return undefined;
+    const wildcard = `${parts.provider}/*`;
+    return list.includes(wildcard) ? { kind: "wildcard", pattern: wildcard } : undefined;
+}
+/** 追加（去重、保持顺序）。 */
+export function addEnabled(list, refs) {
+    const out = [...(list ?? [])];
+    for (const ref of refs)
+        if (!out.includes(ref))
+            out.push(ref);
+    return out;
+}
+/** 移出；移空返回 undefined（删掉键，恢复「显示全部已配置」）。 */
+export function removeEnabled(list, refs) {
+    const out = (list ?? []).filter((ref) => !refs.includes(ref));
+    return out.length > 0 ? out : undefined;
+}
+/** 配置里的清单：非数组或空数组视为未设置。 */
+export function enabledList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const list = value.filter((x) => typeof x === "string");
+    return list.length > 0 ? list : undefined;
+}

package/dist/ai/providers/registry.d.ts

@@ -63,6 +63,8 @@ export declare class ProviderRegistry implements ProviderRegistryApi {
     private readonly envBaseUrls;
     /** baseUrl 指向非官方主机的内置供应商：接受目录外的 model id。 */
     private readonly relayed;
+    /** 模型表只来自发现缓存的供应商：表外的 id 照样合成（与空表相同）。 */
+    private readonly openTables;
     /** config 里写了自己 `channels` 的供应商（内置渠道不因改 baseUrl 作废）。 */
     private readonly userChannels;
     /** config 里写了供应商级 `api` 的供应商（单渠道回落时目录模型跟它走）。 */

package/dist/ai/providers/registry.js

@@ -57,6 +57,8 @@ export class ProviderRegistry {
     envBaseUrls = new Map();
     /** baseUrl 指向非官方主机的内置供应商：接受目录外的 model id。 */
     relayed = new Set();
+    /** 模型表只来自发现缓存的供应商：表外的 id 照样合成（与空表相同）。 */
+    openTables = new Set();
     /** config 里写了自己 `channels` 的供应商（内置渠道不因改 baseUrl 作废）。 */
     userChannels = new Set();
     /** config 里写了供应商级 `api` 的供应商（单渠道回落时目录模型跟它走）。 */
@@ -344,6 +346,8 @@ export class ProviderRegistry {
         const provider = this.providers.get(providerId);
         if (!provider)
             return;
+        if (source === "discovered" && provider.models.length === 0 && provider.requiresApiKey)
+            this.openTables.add(providerId);
         for (const raw of models) {
             this.raw.delete(`${providerId}/${raw.id}`);
             const model = this.materialize(provider, { ...raw, provider: providerId });
@@ -376,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 里本来就带 `@` 且已登记的
@@ -408,11 +411,14 @@ export class ProviderRegistry {
                 const model = provider.models.find((m) => m.id === id);
                 if (model)
                     return { ok: true, model, provider };
-                const relayed = provider.models.length === 0 || this.relayed.has(provider.id);
+                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;