@nvae/llmswitch 1.2.0 → 1.3.0

package/dist/commands/gateway-cmd.js

@@ -1,5 +1,5 @@
 import { Option } from "commander";
-import { cancel, confirm, isCancel, password, select, text } from "@clack/prompts";
+import { confirm, isCancel, password, select, text } from "@clack/prompts";
 import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, watchFile, } from "node:fs";
 import { isApiFormat } from "../types.js";
 import { formatLabel } from "../formats/compatibility.js";
@@ -14,13 +14,32 @@ import { gatewayBaseUrl, gatewayRootUrl, readGatewayState } from "../gateway/sta
 import { parseGatewayPort } from "../gateway/runtime.js";
 import { createGatewayKey, deleteGatewayKey, listGatewayKeys, peekDailyQuota, peekRateLimit, publicKeyView, resetRateLimits, revokeGatewayKey, rotateGatewayKey, updateGatewayKey, } from "../gateway/keys.js";
 import { parseBridgeRuntimeLimits } from "../bridge/runtime.js";
+import { renderTable } from "../utils/display.js";
 import { rotateGatewayLogIfNeeded } from "../gateway/manager.js";
 import { deleteGatewayProvider, deleteGatewayRoute, importProvidersFromProfiles, listGatewayProviders, listGatewayRoutes, publicProviderView, readGatewayConfig, requireGatewayProvider, saveGatewayProvider, saveGatewayRoute, writeGatewayConfig, } from "../gateway/store.js";
-import { listRoutableModelIds, listRoutableModels, resolveModelRoute } from "../gateway/router.js";
+import { listRoutableModelIds, listRoutableModels, resolveModelRoute, splitQualified, } from "../gateway/router.js";
 import { resetUsage, summarizeUsage } from "../gateway/usage.js";
 import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, } from "../gateway/types.js";
+/**
+ * `path=` marker for the provider list. `v1` is the default and stays implicit;
+ * an empty prefix means "hit baseUrl directly" and must be shown — the previous
+ * condition excluded the empty string, so that case silently rendered nothing.
+ */
+function formatPathPrefix(pathPrefix) {
+    if (pathPrefix === undefined || pathPrefix === "v1")
+        return "";
+    return pathPrefix === "" ? " path=(直连)" : ` path=${pathPrefix}`;
+}
+/**
+ * Abort a gateway command. Uses the same `错误：` prefix on stderr as the rest of
+ * the CLI (see cli.ts) instead of clack's boxed output, so piped consumers get a
+ * consistent, parseable line. Cancellations are printed as-is.
+ */
 function bail(message) {
-    cancel(message);
+    if (message === "已取消")
+        console.error(message);
+    else
+        console.error(`错误：${message}`);
     process.exit(1);
 }
 function formatDuration(totalSeconds) {
@@ -223,9 +242,17 @@ function registerUsageCommands(gateway) {
             return;
         }
         console.log(`统计范围：最近 ${days} 天\n`);
-        console.log("日期        请求数  输入tokens  输出tokens  Key      供应商        模型");
-        for (const row of rows) {
-            console.log(`${row.day}  ${String(row.requests).padStart(5)}  ${String(row.inputTokens).padStart(10)}  ${String(row.outputTokens).padStart(10)}  ${row.key.padEnd(8)} ${row.provider.padEnd(12)} ${row.model}`);
+        // 中文表头占两列宽，用 padEnd 会错位，改按显示宽度排版。
+        for (const line of renderTable(rows, [
+            { header: "日期", value: (r) => r.day },
+            { header: "请求数", value: (r) => String(r.requests), align: "right" },
+            { header: "输入 tokens", value: (r) => String(r.inputTokens), align: "right" },
+            { header: "输出 tokens", value: (r) => String(r.outputTokens), align: "right" },
+            { header: "Key", value: (r) => r.key },
+            { header: "供应商", value: (r) => r.provider },
+            { header: "模型", value: (r) => r.model },
+        ])) {
+            console.log(line);
         }
     });
     usage
@@ -293,6 +320,12 @@ function registerServerCommands(gateway) {
         const data = {
             alive: probe.healthy,
             reachable: probe.reachable,
+            // 文本区区分三态，JSON 之前只有两个布尔，脚本无法还原「端口被占用」。
+            state: probe.healthy
+                ? "running"
+                : probe.reachable
+                    ? "port_occupied"
+                    : "stopped",
             listener: state.listener,
             rootUrl: gatewayRootUrl(state),
             openaiBaseUrl: gatewayBaseUrl(state),
@@ -310,13 +343,18 @@ function registerServerCommands(gateway) {
             console.log(JSON.stringify(data, null, 2));
             return;
         }
-        console.log(`状态：${data.alive ? "运行中" : data.reachable ? "端口被占用（非本网关）" : "未运行"}`);
+        console.log(`状态：${data.state === "running"
+            ? "运行中"
+            : data.state === "port_occupied"
+                ? "端口被占用（非本网关）"
+                : "未运行"}`);
         if (data.alive && probe.uptimeSeconds !== undefined) {
             console.log(`已运行：${formatDuration(probe.uptimeSeconds)}`);
         }
         if (data.alive && probe.stats) {
             const stats = probe.stats;
-            console.log(`请求：共 ${stats.requests} 次（4xx ${stats.errors4xx}，5xx ${stats.errors5xx}），并发 ${stats.activeConnections}/${stats.maxConcurrency}`);
+            console.log(`请求：共 ${stats.requests} 次（4xx ${stats.errors4xx}，5xx ${stats.errors5xx}），` +
+                `并发 ${stats.activeConnections}${stats.maxConcurrency > 0 ? `/${stats.maxConcurrency}` : "（不限）"}`);
         }
         console.log(`监听：${data.listener.bindHost}:${data.listener.port}${data.listener.allowRemote ? "（已对外暴露）" : "（仅本机）"}`);
         console.log(`OpenAI base：${data.openaiBaseUrl}`);
@@ -397,7 +435,7 @@ function registerProviderCommands(gateway) {
             return;
         }
         for (const item of providers) {
-            console.log(`${item.enabled ? "●" : "○"} ${item.name}（${item.displayName}） ${item.apiFormat} ${item.baseUrl} key=${item.apiKey} priority=${item.priority} models=${item.models.length}${item.pathPrefix && item.pathPrefix !== "v1" ? ` path=${item.pathPrefix || "(直连)"}` : ""}${item.headerNames?.length ? ` headers=${item.headerNames.join("/")}` : ""}`);
+            console.log(`${item.enabled ? "●" : "○"} ${item.name}（${item.displayName}） ${item.apiFormat} ${item.baseUrl} key=${item.apiKey} priority=${item.priority} models=${item.models.length}${formatPathPrefix(item.pathPrefix)}${item.headerNames?.length ? ` headers=${item.headerNames.join("/")}` : ""}`);
         }
     });
     provider
@@ -416,10 +454,12 @@ function registerProviderCommands(gateway) {
         .argParser((value, previous) => parseHeaderEntry(value, previous ?? {}))
         .default({}))
         .action(async (opts) => {
-        const baseUrl = opts.baseUrl ?? (await promptText("API 地址（base URL）"));
+        const baseUrl = opts.baseUrl ??
+            (await promptText("API 地址（base URL）", "请改用 --base-url <url>。"));
         if (!baseUrl)
             bail("已取消");
-        const apiKey = opts.apiKey ?? (await promptSecret("API Key（本地上游可留空）"));
+        const apiKey = opts.apiKey ??
+            (await promptSecret("API Key（本地上游可留空）", "请改用 --api-key <key>。"));
         let apiFormat;
         if (opts.format) {
             if (!isApiFormat(opts.format)) {
@@ -571,18 +611,22 @@ function registerProviderCommands(gateway) {
                 }
             }
         }
+        const models = result.modelsEndpoint;
+        const completion = result.completion;
+        // 退出码要在 JSON 分支之前决定，否则脚本用 --json 时拿不到失败信号。
+        const allOk = models?.ok && (!completion || completion.ok);
+        if (!allOk)
+            process.exitCode = 1;
         if (opts.json) {
-            console.log(JSON.stringify(result, null, 2));
+            console.log(JSON.stringify({ ...result, ok: Boolean(allOk) }, null, 2));
             return;
         }
-        const models = result.modelsEndpoint;
         if (models?.ok) {
             console.log(`模型列表：OK（${models.count} 个，${result.modelsLatencyMs}ms）`);
         }
         else {
             console.log(`模型列表：失败 — ${models?.error ?? "未知错误"}`);
         }
-        const completion = result.completion;
         if (completion) {
             if (completion.ok) {
                 console.log(`补全请求：OK（HTTP ${completion.status}，${completion.latencyMs}ms）`);
@@ -591,9 +635,6 @@ function registerProviderCommands(gateway) {
                 console.log(`补全请求：失败 — ${completion.error ?? `HTTP ${completion.status}`}`);
             }
         }
-        const allOk = models?.ok && (!completion || completion.ok);
-        if (!allOk)
-            process.exitCode = 1;
     });
     provider
         .command("refresh-models")
@@ -809,6 +850,7 @@ function registerKeyCommands(gateway) {
         .option("--models <list>", "限定可用模型，逗号分隔（覆盖）")
         .option("--formats <list>", "限定可用接口格式：openai-chat,anthropic,openai-responses（覆盖）")
         .option("--rate-limit <rpm>", "每分钟请求上限；-1 表示完全不限流，0 表示继承全局默认")
+        .option("--daily-requests <n>", "每日请求配额（UTC 日重置，0 表示不限）")
         .option("--expires-in-days <n>", "新的有效期天数（从现在起算）；0 表示永不过期")
         .action((idOrName, opts) => {
         const patch = {};
@@ -841,11 +883,11 @@ function registerKeyCommands(gateway) {
             patch.expiresInDays = value;
         }
         if (!Object.keys(patch).length) {
-            bail("没有指定任何修改项；可用 --name/--providers/--models/--formats/--rate-limit/--expires-in-days");
+            bail("没有指定任何修改项；可用 --name/--providers/--models/--formats/--rate-limit/--daily-requests/--expires-in-days");
         }
         const updated = updateGatewayKey(idOrName, patch);
         console.log(`已更新 ${updated.id}（${updated.name}）`);
-        console.log(JSON.stringify(publicKeyView(updated), null, 2));
+        console.log("当前作用域与限额：llms gateway key list");
     });
     key
         .command("rotate")
@@ -918,13 +960,10 @@ function registerRouteCommands(gateway) {
         .option("--fallback <list>", "fallback 列表，逗号分隔，支持 provider 或 provider/model")
         .action((alias, opts) => {
         const fallbacks = splitList(opts.fallback).map((entry) => {
-            const index = entry.indexOf("/");
-            if (index <= 0)
-                return { provider: entry };
-            return {
-                provider: entry.slice(0, index),
-                model: entry.slice(index + 1),
-            };
+            // 与 router 解析请求模型 id 的规则保持一致：provider/model 与
+            // provider:model 都认，否则用户按文档写 `provider:model` 会被静默错配。
+            const qualified = splitQualified(entry);
+            return qualified ? qualified : { provider: entry };
         });
         const saved = saveGatewayRoute({
             alias,
@@ -952,10 +991,40 @@ function registerConfigCommands(gateway) {
     config
         .command("show", { isDefault: true })
         .description("显示当前配置与生效的运行时限额")
-        .action(() => {
+        .option("--json", "JSON 输出")
+        .action((opts) => {
         const config = readGatewayConfig();
         const limits = parseBridgeRuntimeLimits();
-        console.log(JSON.stringify({ config, runtimeLimits: limits }, null, 2));
+        if (opts.json) {
+            console.log(JSON.stringify({ config, runtimeLimits: limits }, null, 2));
+            return;
+        }
+        // 其他命令都是「文本为主，--json 可选」，这里以前只吐 JSON，风格不一致。
+        console.log(`兜底供应商：${config.defaultProvider ?? "（未设置）"}`);
+        console.log(`默认限流：${config.rateLimitPerMinute > 0 ? `${config.rateLimitPerMinute} 次/分钟` : "不限"}`);
+        console.log(`Provider fallback：${config.fallback.enabled ? "启用" : "关闭"}` +
+            `（最多尝试 ${config.fallback.maxAttempts} 个上游，触发状态码 ${config.fallback.retryStatuses.join("/") || "无"}）`);
+        console.log(`CORS 来源：${config.corsOrigins?.length ? config.corsOrigins.join(", ") : "（未开启）"}`);
+        console.log("");
+        console.log("运行时限额（环境变量可调，与 bridge 共用）：");
+        for (const line of renderTable([
+            {
+                k: "最大并发",
+                v: limits.maxConcurrency > 0 ? String(limits.maxConcurrency) : "不限",
+                env: "LLM_SWITCH_MAX_CONCURRENCY",
+            },
+            { k: "请求体上限", v: `${limits.maxBodyBytes} B`, env: "LLM_SWITCH_MAX_BODY_BYTES" },
+            { k: "上游响应上限", v: `${limits.maxResponseBytes} B`, env: "LLM_SWITCH_MAX_RESPONSE_BYTES" },
+            { k: "连接超时", v: `${limits.connectTimeoutMs} ms`, env: "LLM_SWITCH_CONNECT_TIMEOUT_MS" },
+            { k: "流式空闲超时", v: `${limits.idleTimeoutMs} ms`, env: "LLM_SWITCH_IDLE_TIMEOUT_MS" },
+            { k: "单请求总超时", v: `${limits.totalTimeoutMs} ms`, env: "LLM_SWITCH_TOTAL_TIMEOUT_MS" },
+        ], [
+            { header: "项目", value: (r) => r.k },
+            { header: "当前值", value: (r) => r.v, align: "right" },
+            { header: "环境变量", value: (r) => r.env },
+        ])) {
+            console.log(`  ${line}`);
+        }
     });
     config
         .command("set")
@@ -1009,23 +1078,35 @@ function registerConfigCommands(gateway) {
             next.rateLimitPerMinute = value;
         }
         writeGatewayConfig(next);
-        console.log(JSON.stringify(readGatewayConfig(), null, 2));
+        console.log("已更新网关配置。当前生效值：llms gateway config show");
     });
 }
 // --- prompts ----------------------------------------------------------------
-async function promptText(message) {
+/**
+ * clack 在非 TTY 下会永久等待输入，表现为「命令卡住」而不是报错。
+ * 每个交互入口先在这里挡一次，并说明该用哪个参数改成非交互。
+ */
+function requireTty(what, hint) {
+    if (process.stdin.isTTY)
+        return;
+    bail(`${what}需要交互式终端（当前 stdin 不是 TTY）。${hint}`);
+}
+async function promptText(message, hint) {
+    requireTty(message, hint ?? "请在终端中运行，或改用对应命令行参数。");
     const value = await text({ message });
     if (isCancel(value))
         bail("已取消");
     return String(value ?? "").trim();
 }
-async function promptSecret(message) {
+async function promptSecret(message, hint) {
+    requireTty(message, hint ?? "请在终端中运行，或改用对应命令行参数。");
     const value = await password({ message });
     if (isCancel(value))
         bail("已取消");
     return String(value ?? "").trim();
 }
 async function promptFormat() {
+    requireTty("接口类型选择", "自动探测失败，请改用 --format <openai-chat|anthropic|openai-responses>。");
     const value = await select({
         message: "无法自动识别接口类型，请选择",
         options: [

package/dist/commands/home-cmd.js

@@ -1,7 +1,25 @@
+import { TOOLS, isTool } from "../types.js";
 import { pickSetupTool, runToolFlow } from "./setup-cmd.js";
-/** 无子命令时：选择工具 → 连贯启动（未配置则自动引导）。 */
+/**
+ * 无子命令时：选择工具 → 连贯启动（未配置则自动引导）。
+ *
+ * 这里额外声明一个可选位置参数，专门用来接住不匹配任何子命令的输入。
+ * 若不声明，commander 会把 `llms nosuchcmd` 报成「too many arguments,
+ * expected 0 arguments」——既看不出是命令拼错，也无法给出可用命令提示。
+ */
 export function registerHomeCommand(program) {
-    program.action(async () => {
+    program
+        .argument("[command]", `子命令或工具名：${TOOLS.join(" | ")}（省略则交互选择）`)
+        .action(async (commandArg) => {
+        if (commandArg) {
+            // 能走到这里说明它没匹配上任何已注册子命令。
+            if (!isTool(commandArg)) {
+                throw new Error(`未知命令「${commandArg}」。工具可选：${TOOLS.join("、")}；` +
+                    `完整命令列表：llms --help`);
+            }
+            await runToolFlow(commandArg);
+            return;
+        }
         const tool = await pickSetupTool();
         await runToolFlow(tool);
     });

package/dist/commands/launch-cmd.js

@@ -20,6 +20,7 @@ export function registerLaunchCommand(program) {
         .option("-m, --model <id>", "要启用的模型 ID")
         .option("-p, --profile <name>", "指定 profile（默认：包含该模型的 profile / 当前启用）")
         .option("--print-only", "只写入配置，不启动 CLI")
+        .option("--save", "把本次模型存为该供应商的默认模型（默认不改动已保存的配置）")
         .option("--dry-run", "只打印计划，不写配置、不启动")
         .option("--json", "JSON 输出")
         .action(async (toolArg, parts = [], opts) => {
@@ -59,6 +60,7 @@ export function registerLaunchCommand(program) {
                 binary: resolveBinary(toolArg),
                 args: passthrough,
                 dryRun: true,
+                saved: false,
             };
             if (opts.json) {
                 console.log(JSON.stringify(plan, null, 2));
@@ -77,6 +79,7 @@ export function registerLaunchCommand(program) {
             profile: opts.profile,
             args: passthrough,
             printOnly: opts.printOnly,
+            save: opts.save,
         });
         if (opts.json) {
             console.log(JSON.stringify({
@@ -87,6 +90,7 @@ export function registerLaunchCommand(program) {
                 args: plan.args,
                 configPath: plan.configPath,
                 applied: plan.applied,
+                saved: plan.saved,
                 printOnly: Boolean(opts.printOnly),
             }, null, 2));
             return;

package/dist/commands/launch.js

@@ -26,29 +26,52 @@ export async function launchTool(options) {
         model: options.model,
         profile: options.profile,
     });
-    if (profile.models.default !== model) {
-        if (!profile.models.list.includes(model)) {
-            profile.models.list.push(model);
-        }
-        profile.models.default = model;
-        saveProfile(tool, profile);
-        profile = requireProfile(tool, profile.name);
+    // 模型名打错时上游只会返回一个含糊的 404，这里先把疑点点出来。
+    if (!profile.models.list.includes(model)) {
+        console.error(`注意：模型「${model}」不在 ${tool}/${profile.name} 的模型列表中，仍按原样发给上游。` +
+            `确认可用后可加 --save 存为该供应商的默认模型。`);
     }
-    else if (!profile.models.list.includes(model)) {
-        profile.models.list.push(model);
-        saveProfile(tool, profile);
-        profile = requireProfile(tool, profile.name);
+    // 只有显式 --save 才把本次模型写回 profile；否则仅影响本次写入工具配置。
+    let saved = false;
+    if (options.save && profile.models.default !== model) {
+        const next = {
+            ...profile,
+            models: {
+                ...profile.models,
+                default: model,
+                list: profile.models.list.includes(model)
+                    ? profile.models.list
+                    : [...profile.models.list, model],
+            },
+        };
+        saveProfile(tool, next);
+        profile = requireProfile(tool, next.name);
+        saved = true;
     }
-    const result = await applyProfile(tool, profile);
+    // 传给 adapter 的是一份内存副本：本次用哪个模型就写哪个，但不落盘。
+    const effective = profile.models.default === model
+        ? profile
+        : {
+            ...profile,
+            models: {
+                ...profile.models,
+                default: model,
+                list: profile.models.list.includes(model)
+                    ? profile.models.list
+                    : [...profile.models.list, model],
+            },
+        };
+    const result = await applyProfile(tool, effective);
     const binary = resolveBinary(tool);
     const args = options.args ?? [];
     const plan = {
         tool,
-        profile,
+        profile: effective,
         model,
         binary,
         args,
         applied: true,
+        saved,
         configPath: result.configPath,
         restartHint: result.restartHint,
     };

package/dist/commands/prompts.js

@@ -1,6 +1,7 @@
 import * as p from "@clack/prompts";
 import { normalizeProxyValue } from "../types.js";
 import { isApiFormat } from "../types.js";
+import { supportsSmallModel } from "../types.js";
 import { formatLabel, supportedFormats } from "../formats/compatibility.js";
 import { getPreset, presetsForTool } from "../presets/index.js";
 import { detectApiFormat } from "../utils/detect-format.js";
@@ -12,6 +13,20 @@ import { maskSecret } from "../utils/fs.js";
 export function isCancel(value) {
     return p.isCancel(value);
 }
+/**
+ * Guard every interactive entry point.
+ *
+ * @clack/prompts silently waits forever when stdin is not a TTY (pipes, CI,
+ * `</dev/null`). The failure mode is "the command hangs", which is far worse
+ * than an error, so refuse up front and name the flags that make the command
+ * non-interactive.
+ */
+export function requireInteractive(what, hint) {
+    if (process.stdin.isTTY)
+        return;
+    throw new Error(`${what}需要交互式终端，但当前 stdin 不是 TTY。` +
+        (hint ? `${hint}` : "请在终端中直接运行，或改用带参数的非交互写法。"));
+}
 export function exitOnCancel(value) {
     if (p.isCancel(value)) {
         p.cancel("已取消");
@@ -213,6 +228,12 @@ export function formatProfileListLabel(profile, opts) {
     return parts.length ? `${display}（${parts.join(" · ")}）` : display;
 }
 export async function promptProfileDraft(tool, partial = {}) {
+    // 只有在还缺必填项时才需要 TTY；参数齐全的调用（provider add --base-url …）可非交互完成。
+    if (partial.baseUrl === undefined ||
+        partial.apiKey === undefined ||
+        partial.preset === undefined) {
+        requireInteractive("添加供应商", `请改用：llms ${tool} provider add --preset custom --base-url <url> --api-key <key> --model <id>。`);
+    }
     p.intro(`为 ${tool} 添加供应商配置`);
     const presets = presetsForTool(tool);
     if (presets.length === 0) {
@@ -345,6 +366,7 @@ export async function promptProfileDraft(tool, partial = {}) {
                 bridgeMode = undefined;
             }
             else {
+                requireInteractive("手动选择接口格式", `自动探测失败，请改用 --format <${supportedFormats(tool).join("|")}> 明确指定。`);
                 const upstream = await promptOpenAiCompatibleUpstream(tool, {
                     apiFormat: "openai-chat",
                     bridgeMode: "chat",
@@ -377,6 +399,8 @@ export async function promptProfileDraft(tool, partial = {}) {
         presetModels: preset.models,
         fixedDefault: partial.model,
         fixedList: partial.models,
+        supportsSmall: supportsSmallModel(tool),
+        fixedSmall: partial.smallModel,
     });
     const { defaultModel, modelList } = resolved;
     if (resolved.resolvedBaseUrl && resolved.resolvedBaseUrl !== baseUrl) {
@@ -391,6 +415,7 @@ export async function promptProfileDraft(tool, partial = {}) {
         apiKey: apiKey || "",
         models: {
             default: defaultModel,
+            smallModel: resolved.smallModel,
             list: Array.from(new Set(modelList)),
             meta: resolved.modelMeta,
         },
@@ -474,6 +499,8 @@ export async function promptEditProfile(tool, current) {
     p.log.success(`已更新「${current.name}」的连接信息`);
     return next;
 }
+const NO_SMALL_MODEL = "__none__";
+const MANUAL_MODEL = "__manual__";
 /**
  * Fetch models from the provider API (when possible), then let the user
  * pick a default + a saved list. Falls back to manual text entry.
@@ -487,31 +514,87 @@ export async function resolveModelsInteractive(input) {
         const list = [...input.fixedList];
         if (!list.includes(input.fixedDefault))
             list.unshift(input.fixedDefault);
-        return {
-            defaultModel: input.fixedDefault,
-            modelList: list,
-            modelMeta: collectModelMeta(await metaPromise, list),
-        };
+        return withSmallModel({ defaultModel: input.fixedDefault, modelList: list }, fixedSmallFor(input), await metaPromise);
     }
     if (input.fixedDefault && !input.fixedList) {
         const fetched = await tryFetchModels(input);
         const list = fetched?.models.length
             ? Array.from(new Set([input.fixedDefault, ...fetched.models]))
             : [input.fixedDefault];
-        return {
+        return withSmallModel({
             defaultModel: input.fixedDefault,
             modelList: list,
             resolvedBaseUrl: fetched?.resolvedBaseUrl,
-            modelMeta: collectModelMeta(await metaPromise, list),
-        };
+        }, fixedSmallFor(input), await metaPromise);
     }
     const catalog = await metaPromise;
     const fetched = await tryFetchModels(input);
-    if (fetched && fetched.models.length > 0) {
-        const selected = await selectModelsFromFetched(fetched.models, input, catalog);
-        return { ...selected, resolvedBaseUrl: fetched.resolvedBaseUrl };
-    }
-    return manualModelsEntry(input, catalog);
+    const selected = fetched && fetched.models.length > 0
+        ? await selectModelsFromFetched(fetched.models, input, catalog)
+        : await manualModelsEntry(input, catalog);
+    const smallModel = input.supportsSmall && input.fixedSmall === undefined
+        ? await promptSmallModel(input, selected, catalog)
+        : fixedSmallFor(input);
+    return withSmallModel({ ...selected, resolvedBaseUrl: fetched?.resolvedBaseUrl }, smallModel, catalog);
+}
+/** Honor an explicit --small flag; ignored for tools without the capability. */
+function fixedSmallFor(input) {
+    if (!input.supportsSmall)
+        return undefined;
+    return input.fixedSmall?.trim() || undefined;
+}
+/**
+ * Fold the lightweight model into the result: it must be part of the saved
+ * model list so adapters can declare it (OpenCode needs every referenced model
+ * defined inside the provider block).
+ */
+function withSmallModel(base, smallModel, catalog) {
+    const modelList = smallModel && !base.modelList.includes(smallModel)
+        ? [...base.modelList, smallModel]
+        : base.modelList;
+    return {
+        ...base,
+        modelList,
+        smallModel,
+        modelMeta: collectModelMeta(catalog, modelList),
+    };
+}
+/**
+ * Optional step: pick a cheaper model for lightweight tasks (title generation,
+ * summaries). Only asked for tools that can act on it.
+ */
+async function promptSmallModel(input, selected, catalog) {
+    const candidates = selected.modelList.filter((id) => id !== selected.defaultModel);
+    const preferred = input.preferredSmall && candidates.includes(input.preferredSmall)
+        ? input.preferredSmall
+        : undefined;
+    const picked = await p.select({
+        message: "选择轻量小模型（用于标题生成等低成本任务）",
+        options: [
+            {
+                value: NO_SMALL_MODEL,
+                label: "不设置",
+                hint: `沿用默认模型 ${selected.defaultModel}`,
+            },
+            ...candidates.map((id) => ({
+                value: id,
+                label: id,
+                hint: joinHints(id === input.preferredSmall ? "当前" : undefined, metadataHint(id, catalog)),
+            })),
+            { value: MANUAL_MODEL, label: "手动输入模型 ID" },
+        ],
+        initialValue: preferred ?? NO_SMALL_MODEL,
+    });
+    exitOnCancel(picked);
+    if (picked === NO_SMALL_MODEL)
+        return undefined;
+    if (picked !== MANUAL_MODEL)
+        return picked;
+    const manual = await promptText({
+        message: "小模型 ID（留空表示不设置）",
+        initialValue: input.preferredSmall || "",
+    });
+    return manual.trim() || undefined;
 }
 /**
  * Best-effort metadata fetch from models.lonae.com.