@armadra/agent 0.6.1 → 0.6.2

package/dist/cli/compose-providers.d.ts

@@ -12,7 +12,8 @@
  * - [W6-O] ChatGPT 登录（docs/wave6-plan.md D14）：`chatgpt` 的缺省渠道按 auth.json 条目的 flavor 定（用户写了
  *   `defaultChannel` 时不动）；`AMA_CHATGPT_BASE_URL` 改该渠道地址；`auth.chatgpt.originator` 改 codex 渠道的
  *   `originator` 头；OAuth 刷新拿到 `auth.chatgpt` 配置与同一份 env。
- * - 发现缓存（`<dataDir>/models/discovered/<provider>.json`）并入模型表为空的供应商（discovered-cache.ts）。
+ * - 发现缓存（`<dataDir>/models/discovered/<provider>.json`）并入模型表为空的供应商（discovered-cache.ts）；
+ *   chatgpt 的缓存 flavor 与当前登录不符时视为过期、不并入。
  */
 import type { ApiRegistry } from "../ai/apis/api.js";
 import { ProviderRegistry } from "../ai/providers/registry.js";

package/dist/cli/compose-providers.js

@@ -12,7 +12,8 @@
  * - [W6-O] ChatGPT 登录（docs/wave6-plan.md D14）：`chatgpt` 的缺省渠道按 auth.json 条目的 flavor 定（用户写了
  *   `defaultChannel` 时不动）；`AMA_CHATGPT_BASE_URL` 改该渠道地址；`auth.chatgpt.originator` 改 codex 渠道的
  *   `originator` 头；OAuth 刷新拿到 `auth.chatgpt` 配置与同一份 env。
- * - 发现缓存（`<dataDir>/models/discovered/<provider>.json`）并入模型表为空的供应商（discovered-cache.ts）。
+ * - 发现缓存（`<dataDir>/models/discovered/<provider>.json`）并入模型表为空的供应商（discovered-cache.ts）；
+ *   chatgpt 的缓存 flavor 与当前登录不符时视为过期、不并入。
  */
 import { loadModelsDevIndex } from "../ai/providers/models-dev-cache.js";
 import { ProviderRegistry, discoverLocalModels } from "../ai/providers/registry.js";
@@ -108,8 +109,10 @@ export async function buildProviderRegistry(input, options = {}) {
             registry = make({ provider, apiKey: cli.apiKey });
     }
     // 发现缓存（`ama auth login chatgpt` / `ama models discover chatgpt`）并入模型表为空的供应商
-    if (dataDir !== undefined)
-        mergeDiscoveredModels(registry, dataDir, lazyIndex(() => loadModelsDevIndex(dataDir)));
+    if (dataDir !== undefined) {
+        const flavor = readOAuthEntry(input.authFile, CHATGPT_PROVIDER_ID)?.flavor;
+        mergeDiscoveredModels(registry, dataDir, lazyIndex(() => loadModelsDevIndex(dataDir)), (id) => (id === CHATGPT_PROVIDER_ID ? flavor : undefined));
+    }
     const probe = options.probeLocal ?? env[NO_LOCAL_PROBE_ENV] !== "1";
     if (probe && config.defaultModel === undefined && !anyKeyConfigured(registry)) {
         await probeLocalProviders(registry, options.probeTimeoutMs ?? LOCAL_PROBE_TIMEOUT_MS);

package/dist/cli/startup-steps.js

@@ -4,6 +4,7 @@
  */
 import { describeLookupFailure } from "../ai/providers/suggest.js";
 import { formatModelRef } from "../ai/providers/channels.js";
+import { CHATGPT_PROVIDER_ID } from "../auth/chatgpt/presets.js";
 import { statSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 import { AmaError, StartupError, isAmaError } from "../errors.js";
@@ -126,10 +127,12 @@ export async function resolveModel(args, registry, manager, defaultModel, deps,
     else {
         const change = lastEntry(manager, (e) => e.type === "model_change");
         if (change?.type === "model_change") {
+            // ChatGPT 的渠道跟随当前登录方式：会话里记的渠道不当显式渠道（可能是换登录前的）
+            const channel = change.provider === CHATGPT_PROVIDER_ID ? undefined : change.channel;
             const found = registry.findModel(formatModelRef({
                 provider: change.provider,
                 id: change.modelId,
-                ...(change.channel !== undefined ? { channel: change.channel } : {}),
+                ...(channel !== undefined ? { channel } : {}),
             }));
             if (found.ok)
                 choice = { model: found.model, provider: found.provider };

package/dist/cli/subcommands/models-discover.d.ts

@@ -18,8 +18,9 @@
  * 匹配结果；`--write` 跳过 models.dev 标明不支持工具调用的模型。元数据不写进配置——运行时从缓存补。
  *
  * [W6-O] `chatgpt`：按登录的 flavor 调对应后端的模型列表（SIWC `GET /v1/models` 筛 `visibility: list`；codex
- * `GET /models?client_version=…`），只取 slug 与显示名；`--probe` 不适用（订阅后端只有一种协议）。结果另写进
- * 发现缓存 `<dataDir>/models/discovered/chatgpt.json`（discovered-cache.ts），`/model` 选择器由此列出。
+ * `GET /models?client_version=<codexClientVersion>`，另带上下文窗口 / 输入模态 / 推理强度），取 slug 与显示名；
+ * `--probe` 不适用（订阅后端只有一种协议）。结果另写进发现缓存 `<dataDir>/models/discovered/chatgpt.json`
+ * （discovered-cache.ts，0 个也写），`/model` 选择器由此列出；codex 返回 0 个时提示 codexClientVersion 可能过旧。
  */
 import type { Api, Model, ProviderData, ProviderRegistryApi } from "../../ai/types.js";
 import type { ModelsAction } from "./models.js";
@@ -31,6 +32,7 @@ export declare const PROBE_APIS: readonly Api[];
 export declare function modelsUrl(provider: ProviderData): string;
 export declare function discoverModels(provider: ProviderData, apiKey: string | undefined, options?: {
     timeoutMs?: number;
+    codexClientVersion?: string;
 }): Promise<Model[]>;
 export declare function probeOrder(provider: ProviderData): Api[];
 export interface ProbeOptions {

package/dist/cli/subcommands/models-discover.js

@@ -18,15 +18,16 @@
  * 匹配结果；`--write` 跳过 models.dev 标明不支持工具调用的模型。元数据不写进配置——运行时从缓存补。
  *
  * [W6-O] `chatgpt`：按登录的 flavor 调对应后端的模型列表（SIWC `GET /v1/models` 筛 `visibility: list`；codex
- * `GET /models?client_version=…`），只取 slug 与显示名；`--probe` 不适用（订阅后端只有一种协议）。结果另写进
- * 发现缓存 `<dataDir>/models/discovered/chatgpt.json`（discovered-cache.ts），`/model` 选择器由此列出。
+ * `GET /models?client_version=<codexClientVersion>`，另带上下文窗口 / 输入模态 / 推理强度），取 slug 与显示名；
+ * `--probe` 不适用（订阅后端只有一种协议）。结果另写进发现缓存 `<dataDir>/models/discovered/chatgpt.json`
+ * （discovered-cache.ts，0 个也写），`/model` 选择器由此列出；codex 返回 0 个时提示 codexClientVersion 可能过旧。
  */
 import { authHeaders, mergeHeaders } from "../../ai/http.js";
 import { listChatGptModels } from "../../auth/chatgpt/backend-client.js";
-import { CHATGPT_PROVIDER_ID } from "../../auth/chatgpt/presets.js";
+import { CHATGPT_PROVIDER_ID, codexClientVersion } from "../../auth/chatgpt/presets.js";
 import { liveToken } from "../../auth/oauth/live.js";
 import { discoverLocalModels, materializeModel } from "../../ai/providers/registry.js";
-import { writeDiscoveredCache } from "../../ai/providers/discovered-cache.js";
+import { thinkingMapOf, writeDiscoveredCache, } from "../../ai/providers/discovered-cache.js";
 import { withCustomDefaults } from "../../ai/providers/catalog.js";
 import { describeModelsDev, loadModelsDevIndex } from "../../ai/providers/models-dev-cache.js";
 import { matchLabel, modelsDevFields } from "../../ai/providers/models-dev.js";
@@ -65,11 +66,20 @@ export async function discoverModels(provider, apiKey, options = {}) {
             accessToken: apiKey,
             accountId: live?.accountId,
             originator: channel?.headers?.["originator"],
+            clientVersion: options.codexClientVersion,
         });
         return models.map((m) => {
             const model = withCustomDefaults({ id: m.id }, provider.id, provider.api);
             if (m.name !== undefined)
                 model.name = m.name;
+            if (m.contextWindow !== undefined)
+                model.contextWindow = m.contextWindow;
+            if (m.input !== undefined)
+                model.input = m.input;
+            if (m.reasoningLevels?.some((x) => x !== "none") === true) {
+                model.reasoning = true;
+                model.thinkingLevelMap = thinkingMapOf(m.reasoningLevels);
+            }
             return model;
         });
     }
@@ -191,7 +201,9 @@ async function run(ctx) {
     }
     let found;
     try {
-        found = await discoverModels(provider, key.apiKey);
+        found = await discoverModels(provider, key.apiKey, {
+            codexClientVersion: codexClientVersion(ctx.level.merged.config.auth?.chatgpt, io.env),
+        });
     }
     catch (error) {
         io.stderr(m.listFailed(provider.id, error.message));
@@ -256,17 +268,37 @@ async function run(ctx) {
     }
     return ExitCode.Ok;
 }
-/** chatgpt 的发现结果写进发现缓存（选择器与注册表读它）；写失败不影响列表输出。 */
+/** 发现得到的模型 → 缓存条目（后端给的元数据一并写入；推理强度由映射表还原）。 */
+function cacheEntry(m) {
+    const entry = { id: m.id };
+    if (m.name !== m.id)
+        entry.name = m.name;
+    if (m.contextWindow !== undefined)
+        entry.contextWindow = m.contextWindow;
+    if (m.input.length !== 1 || m.input[0] !== "text")
+        entry.input = [...m.input];
+    if (m.reasoning && m.thinkingLevelMap !== undefined)
+        entry.reasoningLevels = Object.entries(m.thinkingLevelMap).flatMap(([level, value]) => typeof value !== "string" ? [] : level === "off" ? ["none"] : [level]);
+    return entry;
+}
+/**
+ * chatgpt 的发现结果写进发现缓存（选择器与注册表读它；0 个也写，免得残留另一 flavor 的缓存）；写失败不影响
+ * 列表输出。codex 返回 0 个时提示 codexClientVersion 可能过旧。
+ */
 function cacheChatGpt(ctx, found, apiKey) {
+    const flavor = liveToken(apiKey)?.flavor;
     try {
-        const flavor = liveToken(apiKey)?.flavor;
-        const models = found.map((m) => ({ id: m.id, ...(m.name !== m.id ? { name: m.name } : {}) }));
+        const models = found.map(cacheEntry);
         const path = writeDiscoveredCache(ctx.level.dataDir, CHATGPT_PROVIDER_ID, { models, flavor });
         ctx.io.stdout(msg().subcommands.discover.cached(path));
     }
     catch (error) {
         ctx.io.stderr(`ama: ${error.message}\n`);
     }
+    if (found.length === 0 && flavor === "codex") {
+        const version = codexClientVersion(ctx.level.merged.config.auth?.chatgpt, ctx.io.env);
+        ctx.io.stderr(`${msg().auth.login.codexNoModels(version)}\n`);
+    }
 }
 export const DISCOVER_ACTION = {
     usage: "ama models discover <provider> [--probe] [--write] [--limit <n>] [--concurrency <n>] [--probe-timeout <ms>]",

package/dist/config/json-schema.js

@@ -180,6 +180,7 @@ function w6Sections() {
                 clientId: str(),
                 issuer: str(),
                 originator: str(),
+                codexClientVersion: str(),
                 redirectPorts: {
                     type: "array",
                     items: { type: "integer", minimum: 0, maximum: 65535 },

package/dist/config/key-docs.js

@@ -10,6 +10,7 @@
  *   DISPLAY_DEFAULTS 相同，DISPLAY_DEFAULTS 本身通过 `validateConfig`。
  */
 import { DEFAULT_IDLE_TIMEOUT_MS } from "../ai/http.js";
+import { DEFAULT_CODEX_CLIENT_VERSION } from "../auth/chatgpt/presets.js";
 import { messagesFor, msg } from "../i18n/index.js";
 import { DEFAULT_INLINE_BUDGET } from "../codemode/declarations.js";
 import { DEFAULT_CONFIG, mergeConfig } from "./merge.js";
@@ -33,7 +34,12 @@ const IMPLICIT_DEFAULTS = {
         subagents: "read",
     },
     auth: {
-        chatgpt: { flavor: "siwc", issuer: "https://auth.openai.com", originator: "codex_cli_rs" },
+        chatgpt: {
+            flavor: "siwc",
+            issuer: "https://auth.openai.com",
+            originator: "codex_cli_rs",
+            codexClientVersion: DEFAULT_CODEX_CLIENT_VERSION,
+        },
     },
     checkpoints: { ...DEFAULT_CHECKPOINTS_CONFIG },
     sandbox: { enabled: "auto", bash: "off", network: "deny", writable: [] },

package/dist/config/schema-w6.d.ts

@@ -9,7 +9,7 @@ export declare const W6_CONFIG_KEYS: readonly ["memory", "auth"];
 /** 已有 `ui` 段新增的键。 */
 export declare const W6_UI_KEYS: readonly ["language", "replyLanguage", "agentBar"];
 export declare const MEMORY_KEYS: readonly ["enabled", "scopes", "indexMaxBytes", "fileMaxBytes", "maxFiles", "subagents"];
-export declare const CHATGPT_AUTH_KEYS: readonly ["flavor", "clientId", "issuer", "originator", "redirectPorts"];
+export declare const CHATGPT_AUTH_KEYS: readonly ["flavor", "clientId", "issuer", "originator", "codexClientVersion", "redirectPorts"];
 export declare function checkUiW6(c: Checker, ui: Obj, path: string): void;
 /** 第六波顶层段的校验（validateConfig 末尾调用）。 */
 export declare function validateConfigW6(c: Checker, config: Obj): void;

package/dist/config/schema-w6.js

@@ -24,6 +24,7 @@ export const CHATGPT_AUTH_KEYS = [
     "clientId",
     "issuer",
     "originator",
+    "codexClientVersion",
     "redirectPorts",
 ];
 export function checkUiW6(c, ui, path) {
@@ -63,7 +64,7 @@ export function validateConfigW6(c, config) {
             return;
         c.keys(chatgpt, cp, CHATGPT_AUTH_KEYS);
         c.oneOf(chatgpt, "flavor", cp, CHATGPT_FLAVORS);
-        for (const key of ["clientId", "issuer", "originator"])
+        for (const key of ["clientId", "issuer", "originator", "codexClientVersion"])
             c.string(chatgpt, key, cp);
         checkPorts(c, chatgpt, "redirectPorts", cp);
     });

package/dist/config/types-w6.d.ts

@@ -53,6 +53,11 @@ export interface ChatGptAuthConfig {
     issuer?: string;
     /** codex flavor 的 `originator` 请求头，缺省 codex_cli_rs。 */
     originator?: string;
+    /**
+     * codex flavor 模型列表的 `client_version`（Codex CLI 版本号，后端按它过滤模型），缺省见
+     * `DEFAULT_CODEX_CLIENT_VERSION`；`AMA_CHATGPT_CODEX_CLIENT_VERSION` 优先。
+     */
+    codexClientVersion?: string;
     /** 本地回调端口（依次尝试；0 = 任意空闲端口）。 */
     redirectPorts?: number[];
 }

package/dist/i18n/catalog.d.ts

@@ -1344,6 +1344,7 @@ declare const en: {
             "auth.chatgpt.clientId": string;
             "auth.chatgpt.issuer": string;
             "auth.chatgpt.originator": string;
+            "auth.chatgpt.codexClientVersion": string;
             "auth.chatgpt.redirectPorts": string;
             skills: string;
             "skills.dirs": string;
@@ -1974,6 +1975,12 @@ declare const en: {
             freePlanHint: (plan: string) => string;
             modelHint: string;
             modelsCached: (count: number) => string;
+            siwcEligibilityHint: string;
+            codexNoModels: (version: string) => string;
+        };
+        request: {
+            notEligible: string;
+            flavorMismatch: (current: string, ref: string, pinned: string) => string;
         };
         errors: {
             portsBusy: (ports: string, codex: boolean) => string;

package/dist/i18n/messages/auth.d.ts

@@ -46,6 +46,12 @@ export declare const en: {
         freePlanHint: (plan: string) => string;
         modelHint: string;
         modelsCached: (count: number) => string;
+        siwcEligibilityHint: string;
+        codexNoModels: (version: string) => string;
+    };
+    request: {
+        notEligible: string;
+        flavorMismatch: (current: string, ref: string, pinned: string) => string;
     };
     errors: {
         portsBusy: (ports: string, codex: boolean) => string;
@@ -137,6 +143,12 @@ export declare const zh: {
         freePlanHint: (plan: string) => string;
         modelHint: string;
         modelsCached: (count: number) => string;
+        siwcEligibilityHint: string;
+        codexNoModels: (version: string) => string;
+    };
+    request: {
+        notEligible: string;
+        flavorMismatch: (current: string, ref: string, pinned: string) => string;
     };
     errors: {
         portsBusy: (ports: string, codex: boolean) => string;

package/dist/i18n/messages/auth.js

@@ -47,6 +47,16 @@ export const en = {
         freePlanHint: (plan) => `Note: the "${plan}" plan may not include subscription usage for ama.`,
         modelHint: "Use it with --model chatgpt/<model>; list the models your account can use with ama models discover chatgpt.",
         modelsCached: (count) => `Your account can use ${count} model(s); pick one with /model or --model chatgpt/<model>.`,
+        siwcEligibilityHint: "Whether this account can share its plan usage with ama is only confirmed on the first request.",
+        codexNoModels: (version) => `The codex backend returned no models. codexClientVersion (${version}) may be too old: set a newer Codex CLI version with ama config set auth.chatgpt.codexClientVersion <version>, then run ama models discover chatgpt.`,
+    },
+    request: {
+        notEligible: "this ChatGPT account cannot share plan usage with ama (403 subscription_sharing_user_not_eligible). Possible causes:\n" +
+            "  1. Plan: plan usage is shared with Plus / Pro only\n" +
+            "  2. Workspace account: Team / Enterprise / Edu workspaces may not offer it\n" +
+            "  3. Region restriction, or not yet rolled out during the preview (most likely when a Pro account still gets this error)\n" +
+            "You can sign in the other way instead: ama auth login chatgpt --flavor codex",
+        flavorMismatch: (current, ref, pinned) => `signed in with ${current}, but ${ref} pins the @${pinned} channel. Drop @${pinned} so the channel follows the sign-in, or run ama auth login chatgpt --flavor ${pinned}`,
     },
     errors: {
         portsBusy: (ports, codex) => `callback port ${ports} is in use: finish the other sign-in first, or use --paste${codex ? " / --device" : ""}`,
@@ -145,6 +155,16 @@ export const zh = {
         freePlanHint: (plan) => `注意：「${plan}」计划可能不含给 ama 用的订阅额度。`,
         modelHint: "用 --model chatgpt/<模型> 使用；账户可用的模型用 ama models discover chatgpt 查看。",
         modelsCached: (count) => `账户可用 ${count} 个模型，用 /model 或 --model chatgpt/<模型> 选择。`,
+        siwcEligibilityHint: "这个账户能否把套餐额度共享给 ama，要到首次请求时才能确认。",
+        codexNoModels: (version) => `codex 后端没有返回模型，可能是 codexClientVersion（${version}）过旧：用 ama config set auth.chatgpt.codexClientVersion <版本> 设为较新的 Codex CLI 版本，再运行 ama models discover chatgpt。`,
+    },
+    request: {
+        notEligible: "这个 ChatGPT 账户不能把套餐额度共享给 ama（403 subscription_sharing_user_not_eligible）。可能的原因：\n" +
+            "  1. 账户套餐：额度共享只对 Plus / Pro 开放\n" +
+            "  2. 工作空间账户：Team / Enterprise / Edu 工作空间可能未开放\n" +
+            "  3. 地区受限，或预览期尚未开放（Pro 账户仍报此错时最可能是这一条）\n" +
+            "可以改用另一种登录方式：ama auth login chatgpt --flavor codex",
+        flavorMismatch: (current, ref, pinned) => `当前以 ${current} 方式登录，但 ${ref} 显式指定了 @${pinned} 渠道。去掉 @${pinned} 让渠道跟随登录方式，或运行 ama auth login chatgpt --flavor ${pinned}`,
     },
     errors: {
         portsBusy: (ports, codex) => `回调端口 ${ports} 被占用：请先结束其它登录，或用 --paste${codex ? " / --device" : ""}`,

package/dist/i18n/messages/config-keys.d.ts

@@ -71,6 +71,7 @@ export declare const en: {
         "auth.chatgpt.clientId": string;
         "auth.chatgpt.issuer": string;
         "auth.chatgpt.originator": string;
+        "auth.chatgpt.codexClientVersion": string;
         "auth.chatgpt.redirectPorts": string;
         skills: string;
         "skills.dirs": string;
@@ -214,6 +215,7 @@ export declare const zh: {
         "auth.chatgpt.clientId": string;
         "auth.chatgpt.issuer": string;
         "auth.chatgpt.originator": string;
+        "auth.chatgpt.codexClientVersion": string;
         "auth.chatgpt.redirectPorts": string;
         skills: string;
         "skills.dirs": string;

package/dist/i18n/messages/config-keys.js

@@ -118,6 +118,7 @@ const keysEn = {
     "auth.chatgpt.clientId": "OAuth client id",
     "auth.chatgpt.issuer": "Authorization server (override with AMA_CHATGPT_ISSUER for tests)",
     "auth.chatgpt.originator": "originator request header for the codex flavor",
+    "auth.chatgpt.codexClientVersion": "Codex CLI version sent as client_version when listing codex-flavor models (the backend hides models newer than it); AMA_CHATGPT_CODEX_CLIENT_VERSION overrides",
     "auth.chatgpt.redirectPorts": "Local callback ports, tried in order; 0 = any free port",
     skills: "Skills",
     "skills.dirs": "Extra skill directories; accumulated across levels",
@@ -236,6 +237,7 @@ const keysZh = {
     "auth.chatgpt.clientId": "OAuth 客户端 id",
     "auth.chatgpt.issuer": "授权服务器（测试用 AMA_CHATGPT_ISSUER 覆盖）",
     "auth.chatgpt.originator": "codex flavor 的 originator 请求头",
+    "auth.chatgpt.codexClientVersion": "codex flavor 列模型时作为 client_version 发送的 Codex CLI 版本号（后端不给比它新的模型）；AMA_CHATGPT_CODEX_CLIENT_VERSION 优先",
     "auth.chatgpt.redirectPorts": "本地回调端口，依次尝试；0 = 任意空闲端口",
     skills: "Skill",
     "skills.dirs": "追加的 Skill 目录；各层累加",

package/dist/i18n/messages/config.d.ts

@@ -71,6 +71,7 @@ export declare const en: {
         "auth.chatgpt.clientId": string;
         "auth.chatgpt.issuer": string;
         "auth.chatgpt.originator": string;
+        "auth.chatgpt.codexClientVersion": string;
         "auth.chatgpt.redirectPorts": string;
         skills: string;
         "skills.dirs": string;
@@ -326,6 +327,7 @@ export declare const zh: {
         "auth.chatgpt.clientId": string;
         "auth.chatgpt.issuer": string;
         "auth.chatgpt.originator": string;
+        "auth.chatgpt.codexClientVersion": string;
         "auth.chatgpt.redirectPorts": string;
         skills: string;
         "skills.dirs": string;

package/docs/en/providers.md

@@ -170,9 +170,11 @@ ama auth logout chatgpt                # siwc revokes the refresh token first, t
 | Quota              | only known when exceeded (429); set a weekly cap for ama under ChatGPT → Settings → Usage → App limits                                                                                                                  | response headers, `codex.rate_limits` events, `ama auth status` queries `wham/usage`                                                                                            |
 | Logout             | calls `revocation_endpoint`, then deletes locally                                                                                                                                                                       | deletes locally only                                                                                                                                                            |
 
-**Model list**: `chatgpt` has no built-in model table (`chatgpt/<slug>` accepts any slug). After a successful `ama auth login chatgpt`, ama calls the model list endpoint once (siwc `GET /v1/models`, codex `GET /models`; read-only, no usage consumed; failures are silent and the output suggests `ama models discover chatgpt` instead) and caches the slugs and display names available to the account, with the flavor and a timestamp, in `<dataDir>/models/discovered/chatgpt.json`; `ama models discover chatgpt` rewrites the cache and `ama auth logout chatgpt` deletes it. When the registry is assembled the cache is merged into providers whose model table is empty, with metadata filled from the models.dev snapshot, so the `/model` picker and `ama models list` show the models; slugs missing from the cache still work with `--model chatgpt/<slug>`.
+**Model list**: `chatgpt` has no built-in model table (`chatgpt/<slug>` accepts any slug). After a successful `ama auth login chatgpt`, ama deletes the old cache and calls the model list endpoint once (siwc `GET /v1/models`, codex `GET /models?client_version=…`; read-only, no usage consumed; failures are silent and the output suggests `ama models discover chatgpt` instead) and caches the slugs and display names available to the account, with the flavor and a timestamp, in `<dataDir>/models/discovered/chatgpt.json` — an empty list is written as well when no model comes back, so no cache from the other sign-in method is left behind; `ama models discover chatgpt` rewrites the cache and `ama auth logout chatgpt` deletes it. When the registry is assembled the cache is merged into providers whose model table is empty, with metadata filled from the models.dev snapshot (the context window, input modalities and reasoning efforts reported by the codex backend are cached too and used when models.dev has nothing), so the `/model` picker and `ama models list` show the models; a cache whose flavor differs from the current sign-in counts as stale and is not merged (the picker suggests discovering again). Slugs missing from the cache still work with `--model chatgpt/<slug>`.
 
-The default channel of `chatgpt` is chosen at assembly time from the flavor of the auth.json entry; `provider/model@siwc|codex` can name it explicitly but must match the signed-in flavor (otherwise `chatgpt_flavor_mismatch`).
+**codex `client_version`**: the codex backend filters models by `client_version` (each model has a minimum client version; omitting the parameter is a 400), and ama sends a Codex CLI version (default `0.160.0`), not its own version. If codex returns no models at login or discover time, that version is most likely too old: set a newer Codex CLI version with `ama config set auth.chatgpt.codexClientVersion <version>` (user level) or the environment variable `AMA_CHATGPT_CODEX_CLIENT_VERSION` (takes precedence), then run `ama models discover chatgpt`. Inference requests carry no version.
+
+**The channel follows the sign-in method**: the default channel of `chatgpt` is chosen at assembly time from the flavor of the auth.json entry; on top of that every request picks the channel from the flavor of the token it uses — a model reference without `@channel` automatically uses the current sign-in method's channel (endpoint, channel headers such as `originator`, and the request-body allowlist all switch), so after `ama auth logout` and signing in the other way, a running session's next request goes to the new channel without a restart; when a session is resumed, the channel recorded in it does not count as explicit either. Only an explicit `provider/model@siwc|codex` that differs from the sign-in method reports `chatgpt_flavor_mismatch` (suggesting to drop `@channel` or switch the sign-in method).
 
 **Credentials**: a `{ "type": "oauth", … }` entry in auth.json (file mode 0600); `ama auth list` only shows `oauth · <flavor> · <plan>`. The access token is refreshed automatically when less than 5 minutes remain or a request returns 401; several ama processes (several nodes on the canvas) share one auth.json, and refreshes are serialized through `auth.json.lock` (re-read after taking the lock; if another process already refreshed, its token is used), so refresh-token rotation never knocks another process out. When refreshing fails permanently the entry is marked `needsLogin` (tokens are not deleted), requests report `auth_expired`, and you sign in again with `ama auth login chatgpt` as prompted. Raw tokens, codes and id_tokens never reach logs, sessions, events or errors. Logins of other applications (Codex CLI and others) are never read or imported.
 
@@ -184,12 +186,14 @@ The default channel of `chatgpt` is chosen at assembly time from the flavor of t
 | ---------------- | ------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------- |
 | `quota_exceeded` | siwc 429 `subscription_sharing_usage_limit_exceeded`; codex 429 `usage_limit_reached` / `usage_not_included` | no retry; carries the reset time and emits `quota_update` |
 | `auth_expired`   | a 401 still failing after one refresh, a permanently failed refresh, an entry marked `needsLogin`            | no retry; run `ama auth login chatgpt` again              |
-| `not_eligible`   | siwc 403 `subscription_sharing_user_not_eligible`                                                            | no retry, no re-login                                     |
+| `not_eligible`   | siwc 403 `subscription_sharing_user_not_eligible`                                                            | no retry, no re-login; see troubleshooting below          |
 | (as is)          | 503 and similar                                                                                              | the session layer's existing backoff retries              |
 
+**Troubleshooting `not_eligible`**: the account cannot share its plan usage with ama. Possible causes: the plan (sharing is offered to Plus / Pro only); a workspace account (Team / Enterprise / Edu may not offer it); a region restriction or a preview that has not rolled out yet — **the most likely cause when a Pro account still gets this error**. You can sign in with `ama auth login chatgpt --flavor codex` instead. A successful siwc login only means authorization passed; whether plan usage can be shared is only confirmed on the first request.
+
 **Usage**: subscription requests record `usage.cost = 0` with `billing: "subscription"`; `/session` lists "subscription usage" separately (requests, tokens, cache hit rate, no USD conversion) together with the latest quota; the `quota_update` event is forwarded as is over RPC and has the same name among host events.
 
-**Overrides** (for tests or a future own client): `auth.chatgpt.clientId` / `issuer` / `originator` / `redirectPorts` (user level and profile only), environment variables `AMA_CHATGPT_CLIENT_ID`, `AMA_CHATGPT_ISSUER`, `AMA_CHATGPT_BASE_URL` (changes the address of the current flavor's channel).
+**Overrides** (for tests or a future own client): `auth.chatgpt.clientId` / `issuer` / `originator` / `codexClientVersion` / `redirectPorts` (user level and profile only), environment variables `AMA_CHATGPT_CLIENT_ID`, `AMA_CHATGPT_ISSUER`, `AMA_CHATGPT_BASE_URL` (changes the address of the current flavor's channel), `AMA_CHATGPT_CODEX_CLIENT_VERSION`.
 
 **Embedding hosts**: with a profile ama never starts an interactive login; when `chatgpt` is used and the login has expired the request reports `auth_expired`, and the host guides the user to run `ama auth login chatgpt --paste` in a terminal. Hosts never read, store or forward tokens; they only consume `quota_update` and `auth_expired` / `quota_exceeded`.
 

package/docs/providers.md

@@ -185,14 +185,25 @@ ama auth logout chatgpt                # siwc 先撤销 refresh token 再删本
 | 配额     | 只在超限（429）时可知；在 ChatGPT → 设置 → Usage → App limits 给 ama 设周上限                                                                       | 响应头、`codex.rate_limits` 事件、`ama auth status` 查 `wham/usage`                                                                                   |
 | 登出     | 调 `revocation_endpoint` 撤销，再删本地                                                                                                             | 只删本地                                                                                                                                              |
 
-**模型列表**：`chatgpt` 没有内置模型表（`chatgpt/<slug>` 任意接受）。`ama auth login chatgpt` 成功后自动调一次模型
-列表接口（siwc `GET /v1/models`、codex `GET /models`，只读、不消耗额度；失败静默，改提示 `ama models discover chatgpt`），
-把账户可用的 slug 与显示名连同 flavor、时间戳缓存到 `<dataDir>/models/discovered/chatgpt.json`；`ama models discover
+**模型列表**：`chatgpt` 没有内置模型表（`chatgpt/<slug>` 任意接受）。`ama auth login chatgpt` 成功后先删旧缓存，再调一次
+模型列表接口（siwc `GET /v1/models`、codex `GET /models?client_version=…`，只读、不消耗额度；失败静默，改提示
+`ama models discover chatgpt`），把账户可用的 slug 与显示名连同 flavor、时间戳缓存到
+`<dataDir>/models/discovered/chatgpt.json`——返回 0 个也写空表，免得残留另一种登录方式的缓存；`ama models discover
 chatgpt` 也重写这份缓存，`ama auth logout chatgpt` 删掉它。组装注册表时缓存并入模型表为空的供应商，元数据用 models.dev
-快照补全，`/model` 选择器、`ama models list` 照常列出；缓存里没有的 slug 仍可 `--model chatgpt/<slug>` 使用。
+快照补全（codex 后端另给的上下文窗口、输入模态、推理强度也存进缓存，models.dev 补不到时用它），`/model` 选择器、
+`ama models list` 照常列出；缓存的 flavor 与当前登录不符时视为过期、不并入（选择器提示重新发现）。缓存里没有的 slug
+仍可 `--model chatgpt/<slug>` 使用。
 
-`chatgpt` 的缺省渠道在组装时按 auth.json 条目的 flavor 决定；`provider/model@siwc|codex` 可显式指定，但必须与登录的
-flavor 一致（否则报 `chatgpt_flavor_mismatch`）。
+**codex 的 `client_version`**：codex 后端按 `client_version` 过滤模型（每个模型有最低客户端版本，不带参数报 400），
+ama 发的是 Codex CLI 的版本号（缺省 `0.160.0`），而不是 ama 自己的版本。登录或 discover 时 codex 返回 0 个模型，多半是
+这个版本过旧：用 `ama config set auth.chatgpt.codexClientVersion <版本>`（用户级）或环境变量
+`AMA_CHATGPT_CODEX_CLIENT_VERSION`（优先）设成较新的 Codex CLI 版本，再 `ama models discover chatgpt`。推理请求不带版本号。
+
+**渠道跟随登录方式**：`chatgpt` 的缺省渠道在组装时按 auth.json 条目的 flavor 决定；此外每次请求按当次 token 所属的
+flavor 选渠道——模型引用没写 `@渠道` 时自动用当前登录方式的渠道（端点、`originator` 等渠道头、请求体白名单一起换），
+所以运行中的会话在 `ama auth logout` 后换另一种方式登录，下一次请求就走新渠道，不用重启；恢复会话时，会话里记录的渠道
+也不算显式。只有显式写了 `provider/model@siwc|codex` 且与登录方式不符时才报 `chatgpt_flavor_mismatch`（提示去掉
+`@渠道` 或换登录方式）。
 
 **凭据**：auth.json 的 `{ "type": "oauth", … }` 条目（文件 0600），`ama auth list` 只显示 `oauth · <flavor> · <计划>`。
 access token 剩余不到 5 分钟或请求返回 401 时自动刷新；多个 ama 进程（画布上的多个节点）共享一个 auth.json，刷新经
@@ -214,15 +225,19 @@ developer 消息（前缀依然稳定）。compat `toolsInNamespace: true` 时
 | ---------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------- |
 | `quota_exceeded` | siwc 429 `subscription_sharing_usage_limit_exceeded`；codex 429 `usage_limit_reached` / `usage_not_included` | 不重试；附重置时间并发 `quota_update` |
 | `auth_expired`   | 401 刷新一次仍失败、刷新永久失败、条目 `needsLogin`                                                          | 不重试；重新 `ama auth login chatgpt` |
-| `not_eligible`   | siwc 403 `subscription_sharing_user_not_eligible`                                                            | 不重试、不重登                        |
+| `not_eligible`   | siwc 403 `subscription_sharing_user_not_eligible`                                                            | 不重试、不重登；排查见下              |
 | （原样）         | 503 等                                                                                                       | 走会话层现有的退避重试                |
 
+**`not_eligible` 排查**：账户不能把套餐额度共享给 ama。可能的原因：账户套餐（额度共享只对 Plus / Pro 开放）；工作空间
+账户（Team / Enterprise / Edu 可能未开放）；地区受限或预览期尚未开放——**Pro 账户仍报此错时最可能是这一条**。可以改用
+`ama auth login chatgpt --flavor codex`。siwc 登录成功只说明授权通过，能否共享额度要到首次请求才能确认。
+
 **用量**：订阅请求 `usage.cost = 0` 并标 `billing: "subscription"`；`/session` 单列「订阅用量」（请求数、token、
 缓存命中率，不折算美元）与最近一次配额；事件 `quota_update`（RPC 原样转发，宿主事件同名）。
 
-**覆盖**（测试或将来换自有客户端用）：`auth.chatgpt.clientId` / `issuer` / `originator` / `redirectPorts`（只认用户级
-与 profile），环境变量 `AMA_CHATGPT_CLIENT_ID`、`AMA_CHATGPT_ISSUER`、`AMA_CHATGPT_BASE_URL`（改当前 flavor 渠道的
-地址）。
+**覆盖**（测试或将来换自有客户端用）：`auth.chatgpt.clientId` / `issuer` / `originator` / `codexClientVersion` /
+`redirectPorts`（只认用户级与 profile），环境变量 `AMA_CHATGPT_CLIENT_ID`、`AMA_CHATGPT_ISSUER`、`AMA_CHATGPT_BASE_URL`
+（改当前 flavor 渠道的地址）、`AMA_CHATGPT_CODEX_CLIENT_VERSION`。
 
 **嵌入宿主**：有 profile 时 ama 不发起交互式登录；用到 `chatgpt` 而登录失效时请求报 `auth_expired`，由宿主引导用户
 在终端执行 `ama auth login chatgpt --paste`。宿主不读、不存、不转发 token，只消费 `quota_update` 与

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armadra/agent",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "A coding and coordination agent that runs standalone or embedded in Armadra",
   "type": "module",
   "keywords": [