@armadra/agent 0.5.1 → 0.6.0

package/dist/cli/subcommands/memory.js

@@ -0,0 +1,189 @@
+/**
+ * `ama memory list|show|edit|rm|path|enable|disable`（docs/wave6-plan.md §3.5）。[W6-M]
+ *
+ * - 作用域按用户级配置（`memory.scopes`，缺省 user + project）；项目作用域以 cwd 定位，需项目已受信任
+ *   （trust.json 记录），否则跳过并提示。`memory.enabled` 为 false 时照样能看、能改（条目保留但不使用）。
+ * - `list` / `show` / `path` 只读；`edit` 在 `$EDITOR` 里改副本，存回时同样查凭据与上限；`rm` 在终端里确认，
+ *   非终端需 `--yes`。
+ * - `enable` / `disable` 经 `config/edit.ts`（W6-S）改用户级 `config.json` 的 `memory.enabled`（校验、原子写 + `.bak`）。
+ */
+import { loadConfigFile } from "../../config/load.js";
+import { CONFIG_FILE, resolveConfigDir, resolveDataDir, userFile } from "../../config/paths.js";
+import { findTrustEntry, readTrustFile } from "../../config/trust.js";
+import { ConfigEditError, setConfigValue } from "../../config/edit.js";
+import { msg } from "../../i18n/index.js";
+import { editMemory } from "../../memory/edit.js";
+import { logicalPath, projectRootOf, standaloneRoots, } from "../../memory/paths.js";
+import { findOne, listText, memoryErrorText, scopeSummaries } from "../../memory/report.js";
+import { DEFAULT_MEMORY_LIMITS, MemoryStore } from "../../memory/store.js";
+import { editExternally } from "../../modes/interactive/external-editor.js";
+import { parseSubArgs, UsageError } from "../args.js";
+import { confirmContinue } from "../choice-prompt.js";
+import { ExitCode } from "../exit-codes.js";
+function load(io) {
+    const configDir = resolveConfigDir({ env: io.env });
+    const dataDir = resolveDataDir({ env: io.env });
+    const configPath = userFile({ configDir }, CONFIG_FILE);
+    const memory = loadConfigFile("config", configPath)?.value.memory ?? {};
+    const scopes = memory.scopes ?? ["user", "project"];
+    const notes = [];
+    let projectRoot;
+    if (scopes.includes("project")) {
+        const trusted = findTrustEntry(readTrustFile(configDir).entries, io.cwd)?.trusted === true;
+        if (trusted)
+            projectRoot = projectRootOf(io.cwd);
+        else
+            notes.push(msg().memory.cli.untrusted(io.cwd));
+    }
+    if (memory.enabled !== true)
+        notes.push(msg().memory.cli.disabledNote);
+    const roots = standaloneRoots({ dataDir, projectRoot, user: scopes.includes("user") });
+    const limits = {
+        indexMaxBytes: memory.indexMaxBytes ?? DEFAULT_MEMORY_LIMITS.indexMaxBytes,
+        fileMaxBytes: memory.fileMaxBytes ?? DEFAULT_MEMORY_LIMITS.fileMaxBytes,
+        maxFiles: memory.maxFiles ?? DEFAULT_MEMORY_LIMITS.maxFiles,
+    };
+    const store = new MemoryStore(roots, limits, projectRoot === undefined ? {} : { projectRoot });
+    return { store, notes };
+}
+function scopeFilter(store, raw) {
+    if (raw === undefined || raw === "all")
+        return store.scopes();
+    if (raw !== "user" && raw !== "project")
+        throw new UsageError(msg().memory.cli.unknownScope(raw));
+    return store.scopes().filter((s) => s === raw);
+}
+/** 改用户级 `memory.enabled`（W6-S 的编辑核心：写前重读、只改这一项、校验、原子写 + `.bak`）。 */
+function setEnabled(io, enabled) {
+    const m = msg().memory.cli;
+    try {
+        const result = setConfigValue({
+            configDir: resolveConfigDir({ env: io.env }),
+            cwd: io.cwd,
+            env: io.env,
+            scope: "user",
+            key: "memory.enabled",
+            value: enabled,
+        });
+        io.stdout(`${enabled ? m.enabled(result.path) : m.disabled(result.path)}\n`);
+        return ExitCode.Ok;
+    }
+    catch (error) {
+        if (!(error instanceof ConfigEditError))
+            throw error;
+        io.stderr(`${error.message}\n`);
+        return ExitCode.Config;
+    }
+}
+export async function runMemory(argv, io, deps = {}) {
+    const m = msg().memory;
+    const { positionals, values, flags } = parseSubArgs(argv, ["scope"], ["json", "yes"]);
+    const [sub, ...rest] = positionals;
+    if (flags.has("help") || sub === undefined) {
+        io.stdout(m.cli.usage);
+        return sub === undefined && !flags.has("help") ? ExitCode.Usage : ExitCode.Ok;
+    }
+    const ctx = load(io);
+    const { store } = ctx;
+    const name = rest.join(" ");
+    const notes = () => {
+        for (const note of ctx.notes)
+            io.stderr(`${note}\n`);
+    };
+    try {
+        switch (sub) {
+            case "list": {
+                const scopes = scopeFilter(store, values.get("scope"));
+                if (flags.has("json")) {
+                    const out = scopeSummaries(store, scopes).map((s) => ({
+                        scope: s.scope,
+                        path: logicalPath(s.scope),
+                        dir: store.root(s.scope),
+                        indexBytes: s.indexBytes,
+                        omitted: s.omitted,
+                        entries: s.entries,
+                    }));
+                    io.stdout(`${JSON.stringify(out, null, 2)}\n`);
+                }
+                else
+                    io.stdout(`${listText(store, { scopes })}\n`);
+                notes();
+                return ExitCode.Ok;
+            }
+            case "path": {
+                for (const scope of scopeFilter(store, values.get("scope")))
+                    io.stdout(`${scope}\t${store.root(scope) ?? ""}\n`);
+                notes();
+                return ExitCode.Ok;
+            }
+            case "show": {
+                if (name === "")
+                    throw new UsageError(m.cli.needName(sub));
+                const found = findOne(store, name);
+                if (!found.ok) {
+                    io.stderr(`${found.message}\n`);
+                    return ExitCode.Usage;
+                }
+                io.stdout(`${(store.readRaw(found.entry) ?? "").trimEnd()}\n`);
+                return ExitCode.Ok;
+            }
+            case "edit": {
+                const scope = values.get("scope");
+                const target = name !== "" ? name : scope === undefined ? undefined : scopeFilter(store, scope)[0];
+                const edit = deps.edit ??
+                    ((text, file) => editExternally(text, file, {
+                        env: io.env,
+                        suspend: () => undefined,
+                        resume: () => undefined,
+                    }));
+                const outcome = await editMemory(store, target, edit);
+                if (outcome.status === "not_found") {
+                    io.stderr(`${outcome.message}\n`);
+                    return ExitCode.Usage;
+                }
+                io.stdout(`${outcome.status === "saved"
+                    ? m.command.saved(outcome.path)
+                    : outcome.status === "cancelled"
+                        ? m.command.editCancelled
+                        : m.command.unchanged}\n`);
+                return ExitCode.Ok;
+            }
+            case "rm": {
+                if (name === "")
+                    throw new UsageError(m.cli.needName(sub));
+                const found = findOne(store, name);
+                if (!found.ok) {
+                    io.stderr(`${found.message}\n`);
+                    return ExitCode.Usage;
+                }
+                const path = logicalPath(found.entry.scope, found.entry.file);
+                if (!flags.has("yes")) {
+                    if (!io.stdinIsTTY && deps.confirm === undefined) {
+                        io.stderr(`${m.cli.needsYes}\n`);
+                        return ExitCode.Usage;
+                    }
+                    const question = m.cli.confirmRemove(path);
+                    const ok = await (deps.confirm ?? ((q) => confirmContinue({ question: q, env: io.env })))(question);
+                    if (!ok)
+                        return ExitCode.Ok;
+                }
+                await store.remove(found.entry);
+                io.stdout(`${m.command.deleted(path)}\n`);
+                return ExitCode.Ok;
+            }
+            case "enable":
+            case "disable":
+                return setEnabled(io, sub === "enable");
+            default:
+                throw new UsageError(m.cli.usage.trimEnd());
+        }
+    }
+    catch (error) {
+        if (error instanceof UsageError) {
+            io.stderr(`${error.message}\n`);
+            return ExitCode.Usage;
+        }
+        io.stderr(`${memoryErrorText(error)}\n`);
+        return ExitCode.RuntimeError;
+    }
+}

package/dist/cli/subcommands/model-meta.js

@@ -4,6 +4,7 @@
  */
 import { sourceText } from "../../ai/providers/enrich.js";
 import { matchLabel } from "../../ai/providers/models-dev.js";
+import { msg } from "../../i18n/index.js";
 export function compactTokens(n) {
     if (n === undefined)
         return "?";
@@ -20,12 +21,13 @@ export function metadataOf(registry, providerId, modelId) {
 }
 /** `ctx 262k · out 64k · 思考 · 图片 · 渠道 chat,messages`。 */
 export function modelFlags(model) {
+    const t = msg().subcommands.modelMeta;
     return [
         `ctx ${compactTokens(model.contextWindow)}`,
         `out ${compactTokens(model.maxTokens)}`,
-        model.reasoning ? "思考" : undefined,
-        model.input.includes("image") ? "图片" : undefined,
-        model.channels !== undefined ? `渠道 ${model.channels.join(",")}` : undefined,
+        model.reasoning ? t.reasoning : undefined,
+        model.input.includes("image") ? t.image : undefined,
+        model.channels !== undefined ? t.channels(model.channels) : undefined,
     ]
         .filter((x) => x !== undefined)
         .join(" · ");
@@ -40,15 +42,15 @@ export function sourcesLine(metadata) {
     const values = Object.values(metadata.sources);
     if (values.every((s) => s === "catalog" || s === "default") && !metadata.looked)
         return undefined;
+    const t = msg().subcommands.modelMeta;
     const label = {
         contextWindow: "ctx",
         maxTokens: "out",
-        input: "图片",
-        reasoning: "思考",
-        cost: "价格",
+        input: t.image,
+        reasoning: t.reasoning,
+        cost: t.price,
     };
     const parts = Object.keys(label).map((field) => `${label[field]} ${sourceText(metadata.sources[field])}`);
-    const match = metadata.looked ? `；models.dev ${matchLabel(metadata.match)}` : "";
-    const tools = metadata.toolCall === false ? "；不支持工具调用" : "";
-    return `来源 ${parts.join(" · ")}${match}${tools}`;
+    const match = metadata.looked ? matchLabel(metadata.match) : undefined;
+    return t.sources(parts, match, metadata.toolCall === false);
 }

package/dist/cli/subcommands/models-cache-probe.js

@@ -14,6 +14,7 @@ import { priceTokens } from "../../ai/cost.js";
 import { UsageError } from "../args.js";
 import { confirmContinue } from "../choice-prompt.js";
 import { ExitCode } from "../exit-codes.js";
+import { msg } from "../../i18n/index.js";
 export const PROBE_DEFAULT_TOKENS = 2048;
 export const PROBE_DEFAULT_GAP_MS = 3000;
 export const PROBE_REQUEST_TIMEOUT_MS = 60_000;
@@ -56,17 +57,16 @@ export function judgeProbe(first, second) {
     return any === 0 ? "silent" : "inconclusive";
 }
 export function probeAdvice(verdict, model, samples = []) {
+    const t = msg().subcommands.cacheProbe;
     if (verdict === "silent") {
         // 实测：同一中转的 Kimi 间隔 3 s 两次都是 0、间隔更久才命中——字段存在时提示写入延迟的可能
-        const present = samples.some((s) => s.cacheReported === true)
-            ? "（响应里有缓存字段但恒为 0；也可能是缓存写入有延迟，可加大 --gap-ms 再测一次）"
-            : "";
-        return `可在 config 里设 providers.${model.provider}.compat.cacheReporting: "silent"，状态栏将显示未报告${present}`;
+        const present = samples.some((s) => s.cacheReported === true);
+        return t.adviceSilent(model.provider, present);
     }
     if (verdict === "inconclusive")
-        return "第二次只读到少量缓存或只有写入：可能是缓存粒度或 TTL 问题，可加大 --tokens 或缩短 --gap-ms 重试";
+        return t.adviceInconclusive;
     if (model.promptCache === undefined)
-        return `可自填 promptCache.short 以启用保温（providers.${model.provider}.modelOverrides: [{ "id": "${model.id}", "promptCache": { "short": 300 } }]）`;
+        return t.advicePromptCache(model.provider, model.id);
     return undefined;
 }
 function intOption(ctx, name, fallback, min) {
@@ -75,12 +75,13 @@ function intOption(ctx, name, fallback, min) {
         return fallback;
     const value = Number(raw);
     if (!Number.isInteger(value) || value < min)
-        throw new UsageError(`--${name} 应为不小于 ${min} 的整数`);
+        throw new UsageError(msg().subcommands.cacheProbe.intAtLeast(name, min));
     return value;
 }
 function sampleLine(index, s) {
-    const field = s.cacheReported === undefined ? "?" : s.cacheReported ? "有" : "无";
-    return `#${index}  input ${s.input} · cacheRead ${s.cacheRead} · cacheWrite ${s.cacheWrite} · 缓存字段 ${field}`;
+    const t = msg().subcommands.cacheProbe;
+    const field = s.cacheReported === undefined ? "?" : s.cacheReported ? t.yes : t.no;
+    return t.sample(index, s.input, s.cacheRead, s.cacheWrite, field);
 }
 async function run(ctx) {
     const { io, registry } = ctx;
@@ -90,31 +91,33 @@ async function run(ctx) {
     const json = ctx.flags.has("json");
     const found = registry.findModel(ref);
     if (!found.ok) {
-        io.stderr(`ama: 模型不存在：${ref}\n`);
+        io.stderr(msg().subcommands.common.modelNotFound(ref));
         return ExitCode.NoModel;
     }
     const { model, provider } = found;
     const key = await registry.resolveApiKey(provider.id, model.channel);
     if (key.apiKey === undefined && provider.requiresApiKey) {
-        io.stderr(`ama: ${provider.id} 没有 API key（ama auth set ${provider.id}）\n`);
+        io.stderr(msg().subcommands.common.noApiKey(provider.id));
         return ExitCode.NoModel;
     }
     const api = registry.getApi(model.api);
     if (api === undefined) {
-        io.stderr(`ama: 协议 ${model.api} 尚未实现\n`);
+        io.stderr(msg().subcommands.common.apiNotImplemented(model.api));
         return ExitCode.RuntimeError;
     }
     const estimate = priceTokens(model, { input: tokens * 2, output: 32 });
     const name = `${provider.id}/${model.id}`;
-    const head = `cache-probe ${name}（${model.api}）· 前缀约 ${tokens} token · 间隔 ${gapMs} ms\n预估花费：${estimate === undefined ? "$?" : `$${estimate.toFixed(4)}`}（两次 × ${tokens} token × 目录价）\n`;
+    const t = msg().subcommands.cacheProbe;
+    const cost = estimate === undefined ? "$?" : `$${estimate.toFixed(4)}`;
+    const head = t.head(name, model.api, tokens, gapMs, cost);
     (json ? io.stderr : io.stdout)(head);
     if (!ctx.flags.has("yes")) {
         if (!io.stdinIsTTY) {
-            io.stderr("ama: cache-probe 会发两次计费请求，非交互环境需加 --yes\n");
+            io.stderr(t.needsYes);
             return ExitCode.Usage;
         }
         if (!(await confirmContinue({ env: io.env }))) {
-            io.stderr("ama: 已取消\n");
+            io.stderr(msg().subcommands.common.cancelled);
             return ExitCode.Ok;
         }
     }
@@ -136,7 +139,7 @@ async function run(ctx) {
         })
             .result();
         if (message.stopReason === "error" || message.stopReason === "aborted") {
-            io.stderr(`ama: 第 ${i + 1} 次请求失败：${message.errorMessage ?? message.stopReason}\n`);
+            io.stderr(t.requestFailed(i + 1, message.errorMessage ?? message.stopReason));
             return ExitCode.RuntimeError;
         }
         samples.push(sampleOf(message.usage));
@@ -161,14 +164,14 @@ async function run(ctx) {
         return ExitCode.Ok;
     }
     const share = first.promptTokens > 0
-        ? `（第二次读到前缀的 ${Math.round((second.cacheRead / first.promptTokens) * 100)}%）`
+        ? t.share(Math.round((second.cacheRead / first.promptTokens) * 100))
         : "";
     io.stdout([
         sampleLine(1, first),
         sampleLine(2, second),
-        ...(fields.length > 0 ? [`usage 字段（${model.api} 读取）：${fields.join(" / ")}`] : []),
-        `判定：${verdict}${share}`,
-        ...(advice !== undefined ? [`建议：${advice}`] : []),
+        ...(fields.length > 0 ? [t.usageFields(model.api, fields)] : []),
+        t.verdict(verdict, share),
+        ...(advice !== undefined ? [t.advice(advice)] : []),
     ].join("\n") + "\n");
     return ExitCode.Ok;
 }

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

@@ -16,6 +16,9 @@
  *
  * models.dev：列表之后按需刷新缓存（24 小时内不重拉），每个模型标出上下文、输出、图片、工具调用与
  * 匹配结果；`--write` 跳过 models.dev 标明不支持工具调用的模型。元数据不写进配置——运行时从缓存补。
+ *
+ * [W6-O] `chatgpt`：按登录的 flavor 调对应后端的模型列表（SIWC `GET /v1/models` 筛 `visibility: list`；codex
+ * `GET /models?client_version=…`），只取 slug 与显示名；`--probe` 不适用（订阅后端只有一种协议）。
  */
 import type { Api, Model, ProviderData, ProviderRegistryApi } from "../../ai/types.js";
 import type { ModelsAction } from "./models.js";

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

@@ -16,8 +16,14 @@
  *
  * models.dev：列表之后按需刷新缓存（24 小时内不重拉），每个模型标出上下文、输出、图片、工具调用与
  * 匹配结果；`--write` 跳过 models.dev 标明不支持工具调用的模型。元数据不写进配置——运行时从缓存补。
+ *
+ * [W6-O] `chatgpt`：按登录的 flavor 调对应后端的模型列表（SIWC `GET /v1/models` 筛 `visibility: list`；codex
+ * `GET /models?client_version=…`），只取 slug 与显示名；`--probe` 不适用（订阅后端只有一种协议）。
  */
 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 { liveToken } from "../../auth/oauth/live.js";
 import { discoverLocalModels, materializeModel } from "../../ai/providers/registry.js";
 import { withCustomDefaults } from "../../ai/providers/catalog.js";
 import { describeModelsDev, loadModelsDevIndex } from "../../ai/providers/models-dev-cache.js";
@@ -26,6 +32,7 @@ import { existsSync } from "node:fs";
 import { loadConfigFile } from "../../config/load.js";
 import { writeConfigFile } from "../../config/write.js";
 import { UsageError } from "../args.js";
+import { msg } from "../../i18n/index.js";
 import { ExitCode } from "../exit-codes.js";
 import { compactTokens } from "./model-meta.js";
 import { describeProbePlan, parseProbeTuning, ProbeProgress, ProbeScheduler, } from "./probe-runner.js";
@@ -47,6 +54,23 @@ export function modelsUrl(provider) {
 }
 export async function discoverModels(provider, apiKey, options = {}) {
     const timeoutMs = options.timeoutMs ?? DISCOVER_TIMEOUT_MS;
+    if (provider.id === CHATGPT_PROVIDER_ID && apiKey !== undefined) {
+        const live = liveToken(apiKey);
+        const flavor = live?.flavor ?? (provider.defaultChannel === "codex" ? "codex" : "siwc");
+        const channel = provider.channels?.find((c) => c.name === flavor);
+        const models = await listChatGptModels(fetch, channel?.baseUrl ?? provider.baseUrl, {
+            flavor,
+            accessToken: apiKey,
+            accountId: live?.accountId,
+            originator: channel?.headers?.["originator"],
+        });
+        return models.map((m) => {
+            const model = withCustomDefaults({ id: m.id }, provider.id, provider.api);
+            if (m.name !== undefined)
+                model.name = m.name;
+            return model;
+        });
+    }
     if (!provider.requiresApiKey && apiKey === undefined)
         return discoverLocalModels(provider, { timeoutMs });
     const anthropic = provider.api === "anthropic-messages";
@@ -114,17 +138,18 @@ function parseLimit(raw) {
         return DEFAULT_PROBE_LIMIT;
     const n = Number(raw);
     if (!Number.isInteger(n) || n < 1)
-        throw new UsageError(`--limit 需要正整数：${raw}`);
+        throw new UsageError(msg().subcommands.discover.limitPositive(raw));
     return n;
 }
 /** 把新条目合并进用户级 config.json；返回写入条数。 */
 function writeEntries(ctx, provider, entries, notes) {
     const { io } = ctx;
+    const m = msg().subcommands.discover;
     const path = ctx.level.userConfigPath;
     const config = structuredClone(loadConfigFile("config", path)?.value ?? { version: 1 });
     const providers = (config.providers ??= {});
     if (providers[provider.id] === undefined && !provider.builtin) {
-        io.stderr(`ama: ${provider.id} 不在用户级配置（${path}）里，未写入\n`);
+        io.stderr(m.notInUserConfig(provider.id, path));
         return 0;
     }
     const target = (providers[provider.id] ??= {});
@@ -133,34 +158,33 @@ function writeEntries(ctx, provider, entries, notes) {
     const added = entries.filter((entry) => !existing.has(entry.id));
     const kept = entries.length - added.length;
     if (added.length === 0) {
-        io.stdout(`\n没有新模型要写入${kept > 0 ? `（${kept} 个已存在，未覆盖）` : ""}\n`);
+        io.stdout(m.nothingToWrite(kept));
         return 0;
     }
     models.push(...added);
     const backup = existsSync(path);
     writeConfigFile(path, config, { backup: true });
-    io.stdout(`\n已写入 ${path}：${provider.id} 新增 ${added.length} 个模型` +
-        `${kept > 0 ? `，${kept} 个已存在未覆盖` : ""}${backup ? `（原文件备份为 ${path}.bak）` : ""}\n`);
+    io.stdout(m.written(path, provider.id, added.length, kept, backup));
     if (notes.noTools.size > 0)
-        io.stdout(`跳过不支持工具调用的模型（models.dev）：${[...notes.noTools].join(", ")}\n`);
+        io.stdout(m.skippedNoTools([...notes.noTools].join(", ")));
     const blind = added.filter((entry) => notes.unmatched.has(entry.id)).map((entry) => entry.id);
     if (blind.length > 0)
-        io.stderr(`ama: 警告：${blind.join(", ")} 在 models.dev 未匹配，没有 contextWindow，自动压缩关闭；` +
-            `需要时在 config.json 里补上或写 modelsDev\n`);
+        io.stderr(m.unmatchedWarning(blind.join(", ")));
     return added.length;
 }
 async function run(ctx) {
     const { io, registry } = ctx;
+    const m = msg().subcommands.discover;
     const id = ctx.args[0] ?? "";
     const limit = parseLimit(ctx.values.get("limit"));
     const provider = registry.get(id);
     if (provider === undefined) {
-        io.stderr(`ama: 供应商不存在：${id}\n`);
+        io.stderr(msg().subcommands.common.providerNotFound(id));
         return ExitCode.NoModel;
     }
     const key = await registry.resolveApiKey(provider.id);
     if (key.apiKey === undefined && provider.requiresApiKey) {
-        io.stderr(`ama: ${provider.id} 没有 API key（ama auth set ${provider.id}）\n`);
+        io.stderr(msg().subcommands.common.noApiKey(provider.id));
         return ExitCode.NoModel;
     }
     let found;
@@ -168,11 +192,11 @@ async function run(ctx) {
         found = await discoverModels(provider, key.apiKey);
     }
     catch (error) {
-        io.stderr(`ama: ${provider.id} 模型列表获取失败：${error.message}\n`);
+        io.stderr(m.listFailed(provider.id, error.message));
         return ExitCode.RuntimeError;
     }
     const configured = new Map(provider.models.map((m) => [m.id, m]));
-    io.stdout(`${provider.id}：发现 ${found.length} 个模型（${modelsUrl(provider)}）\n`);
+    io.stdout(m.found(provider.id, found.length, modelsUrl(provider)));
     // models.dev 只读本地（快照 ⊕ `ama models refresh` 的覆盖），不联网。
     const mdIndex = loadModelsDevIndex(ctx.level.dataDir);
     io.stdout(`${describeModelsDev(ctx.level.dataDir)}\n`);
@@ -187,14 +211,14 @@ async function run(ctx) {
         if (match === undefined)
             unmatched.add(model.id);
         const meta = fields === undefined
-            ? "  models.dev 未匹配"
+            ? m.unmatched
             : `  ctx ${compactTokens(fields.contextWindow)} · out ${compactTokens(fields.maxTokens)}` +
-                `${fields.input?.includes("image") ? " · 图片" : ""}${fields.reasoning ? " · 思考" : ""}` +
-                `${fields.toolCall === false ? " · 不支持工具调用" : ""} · ${matchLabel(match)}`;
-        io.stdout(`  ${model.id}${known !== undefined ? `  已配置（${known.api}）` : ""}${meta}\n`);
+                `${fields.input?.includes("image") ? m.image : ""}${fields.reasoning ? m.reasoning : ""}` +
+                `${fields.toolCall === false ? m.noTools : ""} · ${matchLabel(match)}`;
+        io.stdout(`  ${model.id}${known !== undefined ? m.configured(known.api) : ""}${meta}\n`);
     }
     const write = ctx.flags.has("write");
-    if (!ctx.flags.has("probe")) {
+    if (!ctx.flags.has("probe") || provider.id === CHATGPT_PROVIDER_ID) {
         if (write)
             writeEntries(ctx, provider, found.filter((m) => !noTools.has(m.id)).map((m) => ({ id: m.id })), { noTools, unmatched });
         return ExitCode.Ok;
@@ -203,15 +227,14 @@ async function run(ctx) {
     const count = Math.min(limit, ids.length);
     const order = probeOrder(provider);
     const tuning = parseProbeTuning(ctx.values);
-    io.stdout(`\n探测协议：${count} 个模型（${order.join(" → ")}），最多 ${count * order.length} 次请求` +
-        `${ids.length > count ? `；另有 ${ids.length - count} 个超出 --limit ${limit}，未探测` : ""}\n` +
+    io.stdout(m.probeHeader(count, order.join(" → "), count * order.length, ids.length - count, limit) +
         `${describeProbePlan(count * order.length, tuning.concurrency, tuning.timeoutMs)}\n`);
     let stopped;
     const progress = new ProbeProgress(io.stdout, io.stdoutIsTTY, count);
     const probed = await probeModelApis(registry, provider, ids, limit, {
         ...tuning,
         onSettled: () => progress.tick(),
-        onResult: (modelId, api) => progress.line(`  ${modelId}  ${api ?? "不可用（三种协议均失败）"}\n`),
+        onResult: (modelId, api) => progress.line(`  ${modelId}  ${api ?? m.unavailable}\n`),
         onStop: (reason) => (stopped = reason),
     });
     progress.finish();
@@ -224,7 +247,7 @@ async function run(ctx) {
         writeEntries(ctx, provider, entries, { noTools, unmatched });
     }
     if (stopped !== undefined) {
-        io.stderr(`ama: 探测提前停止（${stopped}）\n`);
+        io.stderr(m.probeStopped(stopped));
         return ExitCode.RuntimeError;
     }
     return ExitCode.Ok;

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

@@ -38,5 +38,5 @@ export interface ModelsAction {
 export declare const CHECK_TIMEOUT_MS = 30000;
 /** 动作表：键是子命令名，顺序即用法文本顺序。 */
 export declare const MODELS_ACTIONS: Readonly<Record<string, ModelsAction>>;
-export declare const MODELS_USAGE: string;
+export declare function modelsUsage(): string;
 export declare function runModels(argv: readonly string[], io: CliIo, deps: Pick<RuntimeDeps, "providers"> | undefined): Promise<number>;