@armadra/agent 0.5.0 → 0.6.0

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

@@ -7,13 +7,14 @@
  * （字段缺失或恒 0）；其余（读到一点、只有写入）→ `inconclusive`（粒度或 TTL 问题）。
  *
  * 计费动作：执行前打印预估（两次 × `--tokens` × 目录输入价，无价 `$?`）；非 TTY 必须 `--yes`
- * （否则退出 2），TTY 下问一次 y/N。`--json` 时预估写 stderr，stdout 只有一个结果对象。
+ * （否则退出 2），TTY 下方向键选一次「继续 / 取消」（choice-prompt.ts）。`--json` 时预估写 stderr，stdout 只有一个结果对象。
  * 协议层不保留原始响应，「usage 字段」列的是该协议解析时读取的字段名。
  */
-import { createInterface } from "node:readline/promises";
 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,21 +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;
 }
-async function confirm() {
-    const rl = createInterface({ input: process.stdin, output: process.stderr });
-    try {
-        return /^y(es)?$/i.test((await rl.question("继续？[y/N] ")).trim());
-    }
-    finally {
-        rl.close();
-    }
-}
 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;
@@ -99,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 confirm())) {
-            io.stderr("ama: 已取消\n");
+        if (!(await confirmContinue({ env: io.env }))) {
+            io.stderr(msg().subcommands.common.cancelled);
             return ExitCode.Ok;
         }
     }
@@ -145,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));
@@ -170,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>;

package/dist/cli/subcommands/models.js

@@ -19,21 +19,23 @@ import { buildRegistry, loadUserLevel } from "./context.js";
 import { CACHE_PROBE_ACTION } from "./models-cache-probe.js";
 import { DISCOVER_ACTION } from "./models-discover.js";
 import { metadataOf, modelFlags, sourcesLine } from "./model-meta.js";
+import { msg } from "../../i18n/index.js";
 const COMMON_VALUE_OPTIONS = ["profile", "auth-file"];
 export const CHECK_TIMEOUT_MS = 30_000;
 async function list(io, registry, only) {
     const providers = registry.list().filter((p) => only === undefined || p.id === only);
     if (only !== undefined && providers.length === 0) {
-        io.stderr(`ama: 供应商不存在：${only}\n`);
+        io.stderr(msg().subcommands.common.providerNotFound(only));
         return ExitCode.NoModel;
     }
     for (const provider of providers) {
         const key = await registry.resolveApiKey(provider.id);
+        const t = msg().subcommands.models;
         const keyText = key.apiKey !== undefined
-            ? `key：${key.source}${key.origin !== undefined ? `（${key.origin}）` : ""}`
+            ? t.keyFrom(key.source, key.origin)
             : provider.requiresApiKey
-                ? "无 key"
-                : "无需 key";
+                ? t.noKey
+                : t.keyNotNeeded;
         io.stdout(`${provider.id}  ${provider.api}  ${keyText}\n`);
         for (const channel of provider.channels ?? [])
             io.stdout(`  @${channel.name}  ${channel.api}  ${channel.baseUrl}\n`);
@@ -49,19 +51,18 @@ async function list(io, registry, only) {
 async function check(io, registry, ref) {
     const found = registry.findModel(ref);
     if (!found.ok) {
-        const hint = found.candidates.length > 0 ? `；候选：${found.candidates.slice(0, 10).join(", ")}` : "";
-        io.stderr(`ama: 模型不存在：${ref}${hint}\n`);
+        io.stderr(msg().subcommands.common.modelNotFound(ref, found.candidates.slice(0, 10)));
         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 started = Date.now();
@@ -74,11 +75,11 @@ async function check(io, registry, ref) {
     const message = await stream.result();
     const ms = Date.now() - started;
     if (message.stopReason === "error" || message.stopReason === "aborted") {
-        io.stderr(`ama: ${provider.id}/${model.id} 失败（${ms} ms）：${message.errorMessage ?? message.stopReason}\n`);
+        io.stderr(msg().subcommands.models.checkFailed(`${provider.id}/${model.id}`, ms, message.errorMessage ?? message.stopReason));
         return ExitCode.RuntimeError;
     }
     const shown = formatModelRef(modelRefOf(model));
-    io.stdout(`${shown} 可用（${model.api}，${ms} ms，stopReason ${message.stopReason}）\n`);
+    io.stdout(msg().subcommands.models.checkOk(shown, model.api, ms, message.stopReason));
     return ExitCode.Ok;
 }
 /**
@@ -94,7 +95,7 @@ const REFRESH_ACTION = {
             ?.split(",")
             .map((p) => p.trim())
             .filter(Boolean);
-        ctx.io.stdout(`内置快照：${snapshotMeta().fetchedAt}；正在拉取 models.dev…\n`);
+        ctx.io.stdout(msg().subcommands.models.refreshing(snapshotMeta().fetchedAt));
         const result = await refreshModelsDev({
             dataDir: ctx.level.dataDir,
             env: ctx.io.env,
@@ -105,7 +106,7 @@ const REFRESH_ACTION = {
         ctx.io.stdout(`${describeRefresh(result)}\n`);
         if (result.status === "failed")
             return ExitCode.RuntimeError;
-        ctx.io.stdout(`已写入 ${modelsDevCachePath(ctx.level.dataDir)}\n`);
+        ctx.io.stdout(msg().subcommands.models.written(modelsDevCachePath(ctx.level.dataDir)));
         return ExitCode.Ok;
     },
 };
@@ -124,11 +125,17 @@ export const MODELS_ACTIONS = Object.freeze({
     discover: DISCOVER_ACTION,
     "cache-probe": CACHE_PROBE_ACTION,
     refresh: REFRESH_ACTION,
-    "refresh-catalog": { ...REFRESH_ACTION, usage: "ama models refresh-catalog（refresh 的旧名）" },
+    // 用法行按界面语言取，用 getter（模块级求值会按 import 时的语言定死）
+    "refresh-catalog": {
+        ...REFRESH_ACTION,
+        get usage() {
+            return msg().subcommands.models.refreshCatalogUsage;
+        },
+    },
 });
-export const MODELS_USAGE = `用法：${Object.values(MODELS_ACTIONS)
-    .map((a) => a.usage)
-    .join("\n      ")}\n`;
+export function modelsUsage() {
+    return msg().subcommands.models.usage(Object.values(MODELS_ACTIONS).map((a) => a.usage));
+}
 function unique(lists) {
     return [...new Set(lists.flatMap((l) => l ?? []))];
 }
@@ -137,12 +144,12 @@ export async function runModels(argv, io, deps) {
     const { positionals, values, flags } = parseSubArgs(argv, unique([...actions.map((a) => a.valueOptions), COMMON_VALUE_OPTIONS]), unique(actions.map((a) => a.flagOptions)));
     const name = positionals[0];
     if (flags.has("help") || name === undefined) {
-        io.stdout(MODELS_USAGE);
+        io.stdout(modelsUsage());
         return flags.has("help") ? ExitCode.Ok : ExitCode.Usage;
     }
     const action = Object.hasOwn(MODELS_ACTIONS, name) ? MODELS_ACTIONS[name] : undefined;
     if (action === undefined)
-        throw new UsageError(`未知的 models 子命令：${name}`);
+        throw new UsageError(msg().subcommands.common.unknownSubcommand("models", name));
     // 选项按全部动作的并集解析；这里再拒绝不属于本动作的（如 `list --json`）。
     for (const option of [...values.keys(), ...flags]) {
         const own = [
@@ -151,13 +158,13 @@ export async function runModels(argv, io, deps) {
             ...(action.flagOptions ?? []),
         ];
         if (!own.includes(option))
-            throw new UsageError(`未知选项：--${option}`);
+            throw new UsageError(msg().subcommands.common.unknownOption(option));
     }
     const args = positionals.slice(1);
     if (action.required !== undefined && args[0] === undefined)
-        throw new UsageError(`ama models ${name} 需要 ${action.required}`);
+        throw new UsageError(msg().subcommands.common.needsArg(`ama models ${name}`, action.required));
     if (deps === undefined) {
-        io.stderr("ama: models 尚未装配（供应商注册表由集成批次注入）\n");
+        io.stderr(msg().subcommands.common.notAssembled("models"));
         return ExitCode.RuntimeError;
     }
     const level = loadUserLevel(io, {
@@ -165,7 +172,7 @@ export async function runModels(argv, io, deps) {
         authFile: values.get("auth-file"),
     });
     for (const warning of level.warnings)
-        io.stderr(`ama: 警告：${warning}\n`);
+        io.stderr(msg().subcommands.common.warning(warning));
     const registry = await buildRegistry(level, io, deps);
     return action.run({ io, registry, level, args, values, flags });
 }

package/dist/cli/subcommands/probe-runner.js

@@ -13,6 +13,7 @@
  * `ama models check` 不走这里：它只发一次，要看到完整回复与耗时。
  */
 import { UsageError } from "../args.js";
+import { msg } from "../../i18n/index.js";
 export const PROBE_TIMEOUT_MS = 15_000;
 export const DEFAULT_PROBE_CONCURRENCY = 6;
 export const MAX_PROBE_CONCURRENCY = 16;
@@ -36,7 +37,7 @@ const sleep = (ms, signal) => new Promise((resolve) => {
 export async function probeOnce(registry, model, apiKey, tuning = {}, signal) {
     const impl = registry.getApi(model.api);
     if (impl === undefined)
-        return { error: `协议 ${model.api} 尚未实现` };
+        return { error: msg().subcommands.probe.apiNotImplemented(model.api) };
     if (signal?.aborted)
         return { aborted: true };
     const timeoutMs = tuning.timeoutMs ?? PROBE_TIMEOUT_MS;
@@ -53,7 +54,7 @@ export async function probeOnce(registry, model, apiKey, tuning = {}, signal) {
         if (signal?.aborted)
             return { aborted: true };
         if (timedOut)
-            return { error: `超时（${Math.round(timeoutMs / 1000)} s 内没有响应）` };
+            return { error: msg().subcommands.probe.timeout(Math.round(timeoutMs / 1000)) };
         return outcome;
     };
     try {
@@ -147,7 +148,7 @@ export class ProbeScheduler {
                 return { aborted: true };
             outcome = await probeOnce(this.registry, model, this.apiKey, this.options, this.signal);
             if (outcome.error !== undefined && RATE_LIMITED.test(outcome.error)) {
-                this.stop(`连续 429 限流：${outcome.error}`);
+                this.stop(msg().subcommands.probe.rateLimitedStop(outcome.error));
                 return outcome;
             }
         }
@@ -208,7 +209,7 @@ export function parseProbeTuning(values) {
             return fallback;
         const n = Number(raw);
         if (!Number.isInteger(n) || n < min || n > max)
-            throw new UsageError(`--${name} 需要 ${min}–${max} 的整数：${raw}`);
+            throw new UsageError(msg().subcommands.probe.intRange(name, min, max, raw));
         return n;
     };
     return {
@@ -219,7 +220,7 @@ export function parseProbeTuning(values) {
 /** 预估文案：`并发 6，单次最长 15 s，预计不超过 150 s`。 */
 export function describeProbePlan(requests, concurrency, timeoutMs) {
     const worst = Math.ceil(requests / concurrency) * Math.ceil(timeoutMs / 1000);
-    return `并发 ${concurrency}，单次最长 ${Math.round(timeoutMs / 1000)} s，预计不超过 ${worst} s`;
+    return msg().subcommands.probe.plan(concurrency, Math.round(timeoutMs / 1000), worst);
 }
 /** 进度：TTY 下单行刷新「探测 18/60」；非 TTY 只在结束时打印一行汇总。 */
 export class ProbeProgress {
@@ -247,12 +248,12 @@ export class ProbeProgress {
     finish() {
         this.clear();
         const seconds = ((Date.now() - this.started) / 1000).toFixed(1);
-        this.write(`探测完成 ${this.done}/${this.total}，用时 ${seconds} s\n`);
+        this.write(msg().subcommands.probe.done(this.done, this.total, seconds));
     }
     draw() {
         if (!this.tty)
             return;
-        this.write(`\r\x1b[2K探测 ${this.done}/${this.total}`);
+        this.write(`\r\x1b[2K${msg().subcommands.probe.progress(this.done, this.total)}`);
         this.shown = true;
     }
     clear() {

package/dist/cli/subcommands/providers-list.js

@@ -8,23 +8,21 @@ import { writeConfigFile } from "../../config/write.js";
 import { ExitCode } from "../exit-codes.js";
 import { buildRegistry } from "./context.js";
 import { userConfig } from "./providers.js";
+import { msg } from "../../i18n/index.js";
 async function keySource(registry, config, id, channel) {
+    const m = msg().subcommands.providersList;
     const raw = channel !== undefined ? config?.channels?.[channel]?.apiKey : config?.apiKey;
     if (raw !== undefined) {
         const kind = classifyKeyValue(raw);
-        return kind === "env-ref"
-            ? raw
-            : kind === "command"
-                ? "!命令（config.json）"
-                : "字面量（config.json）";
+        return kind === "env-ref" ? raw : kind === "command" ? m.keyCommand : m.keyLiteral;
     }
     const resolved = await registry.resolveApiKey(id, channel);
     if (resolved.apiKey === undefined)
-        return channel !== undefined ? "同供应商" : "无";
+        return channel !== undefined ? m.keySameProvider : m.keyNone;
     if (channel !== undefined && resolved.source !== "auth-file")
-        return "同供应商";
+        return m.keySameProvider;
     return resolved.source === "env"
-        ? `环境变量 ${resolved.origin ?? ""}`
+        ? m.keyEnv(resolved.origin ?? "")
         : resolved.source === "auth-file"
             ? "auth.json"
             : resolved.source;
@@ -41,36 +39,49 @@ export async function listProviders(ctx) {
                 (await registry.resolveApiKey(provider.id)).apiKey !== undefined))
             continue;
         shown++;
-        const kind = provider.builtin ? "内置" : "自定义";
         const channels = provider.channels ?? [];
-        ctx.io.stdout(`${provider.id}  ${kind} · ${channels.length > 0 ? `${channels.length} 渠道` : `${provider.api} ${provider.baseUrl}`} · ` +
-            `${provider.models.length} 模型 · key ${await keySource(registry, own, provider.id)}\n`);
+        const t = msg().subcommands.providersList;
+        ctx.io.stdout(t.providerLine({
+            id: provider.id,
+            builtin: provider.builtin,
+            channels: channels.length,
+            endpoint: `${provider.api} ${provider.baseUrl}`,
+            models: provider.models.length,
+            key: await keySource(registry, own, provider.id),
+        }));
         for (const c of channels) {
             const count = provider.models.filter((m) => m.channels?.includes(c.name)).length;
-            ctx.io.stdout(`  @${c.name}  ${c.api}  ${c.baseUrl}  ${count} 模型 · key ${await keySource(registry, own, provider.id, c.name)}\n`);
+            const key = await keySource(registry, own, provider.id, c.name);
+            ctx.io.stdout(t.channelLine(c.name, c.api, c.baseUrl, count, key));
         }
     }
     if (shown === 0)
-        ctx.io.stdout(`没有配置供应商（ama providers add <id> --base-url <url>）\n`);
+        ctx.io.stdout(msg().subcommands.providersList.noProviders);
     return ExitCode.Ok;
 }
 export async function listChannels(ctx, id) {
     const registry = await buildRegistry(ctx.level, ctx.io, ctx.deps);
     const provider = registry.get(id);
     if (provider === undefined) {
-        ctx.io.stderr(`ama: 供应商不存在：${id}\n`);
+        ctx.io.stderr(msg().subcommands.common.providerNotFound(id));
         return ExitCode.NoModel;
     }
     const own = userConfig(ctx.level).providers?.[id];
     if (provider.channels === undefined) {
-        ctx.io.stdout(`${id}：单渠道（${provider.api} ${provider.baseUrl}），${provider.models.length} 模型\n`);
+        ctx.io.stdout(msg().subcommands.providersList.singleChannel(id, provider.api, provider.baseUrl, provider.models.length));
         return ExitCode.Ok;
     }
     for (const c of provider.channels) {
         const models = provider.models.filter((m) => m.channels?.includes(c.name));
-        const mark = c.name === provider.defaultChannel ? "（缺省）" : "";
-        ctx.io.stdout(`@${c.name}${mark}  ${apiShortName(c.api)}  ${c.api}  ${c.baseUrl}  key ${await keySource(registry, own, id, c.name)}\n` +
-            `  ${models.length} 模型${models.length > 0 ? `：${models.map((m) => m.id).join(", ")}` : ""}\n`);
+        ctx.io.stdout(msg().subcommands.providersList.channelDetail({
+            name: c.name,
+            isDefault: c.name === provider.defaultChannel,
+            short: apiShortName(c.api),
+            api: c.api,
+            url: c.baseUrl,
+            key: await keySource(registry, own, id, c.name),
+            models: models.map((m) => m.id),
+        }));
     }
     return ExitCode.Ok;
 }
@@ -80,7 +91,7 @@ export function removeProvider(ctx, id) {
     if (had) {
         delete config.providers?.[id];
         writeConfigFile(ctx.level.userConfigPath, config, { backup: true });
-        ctx.io.stdout(`已从 ${ctx.level.userConfigPath} 删除 ${id}（原文件备份为 config.json.bak）\n`);
+        ctx.io.stdout(msg().subcommands.providersList.removed(ctx.level.userConfigPath, id));
     }
     const auth = readAuthFile(ctx.level.authFile).file;
     let keys = 0;
@@ -88,9 +99,9 @@ export function removeProvider(ctx, id) {
         if (name === id || name.startsWith(`${id}@`))
             keys += removeAuthKey(ctx.level.authFile, name) ? 1 : 0;
     if (keys > 0)
-        ctx.io.stdout(`已删除 ${ctx.level.authFile} 里 ${id} 的 ${keys} 个 key\n`);
+        ctx.io.stdout(msg().subcommands.providersList.keysRemoved(ctx.level.authFile, id, keys));
     if (!had && keys === 0) {
-        ctx.io.stderr(`ama: 没有供应商 ${id}\n`);
+        ctx.io.stderr(msg().subcommands.providersList.noSuchProvider(id));
         return ExitCode.RuntimeError;
     }
     return ExitCode.Ok;