min-agent 0.5.0 → 0.5.1

package/README.md

@@ -76,6 +76,7 @@ Type `/` to open a command menu. Use **↑ / ↓** to recall previous messages.
 | `/mcp` | Show connected MCP servers |
 | `/skills` | Manage skills |
 | `/tokens` | Usage and estimated cost |
+| `/ctx` | Choose local-model context window |
 | `/help` | Show all commands |
 | `/exit` | Exit |
 
@@ -117,6 +118,12 @@ In chat, `/memory on` or `/memory off` toggles it; `/memory` lists notes; `/memo
 
 Run `min-agent setup` for a guided setup — this is the easiest way to add or switch AI providers.
 
+```bash
+min-agent setup --type ollama
+min-agent setup --type openai-compatible --url https://api.example.com/v1 --api-key "$KEY" --name groq --default-model llama-3.1-70b
+min-agent setup --switch ollama
+```
+
 Settings live in `~/.min-agent/config.json` (global). A project can have its own `.min-agent/config.json` that only applies there.
 
 ## Extending It
@@ -194,6 +201,7 @@ min-agent --provider anthropic "你的消息"
 | `/mcp` | 查看已连接的 MCP 服务 |
 | `/skills` | 管理技能 |
 | `/tokens` | 查看用量与预估费用 |
+| `/ctx` | 选择本地模型上下文窗口 |
 | `/help` | 查看全部命令 |
 | `/exit` | 退出 |
 
@@ -235,6 +243,12 @@ min-agent memory add "prefer bun"
 
 运行 `min-agent setup` 即可通过引导式流程完成配置，这是添加或切换 AI 服务商最简单的方式。
 
+```bash
+min-agent setup --type ollama
+min-agent setup --type openai-compatible --url https://api.example.com/v1 --api-key "$KEY" --name groq --default-model llama-3.1-70b
+min-agent setup --switch ollama
+```
+
 配置保存在 `~/.min-agent/config.json`（全局生效）。也可以在某个项目下单独创建 `.min-agent/config.json`，仅对该项目生效。
 
 ## 扩展能力

package/dist/agent.js

@@ -21,6 +21,7 @@ import { XmlSearchSplitter } from "./xml-search.js";
 import { printHeader, printDivider, printToolCall, printToolResult, printDone } from "./output.js";
 import { createTodoTool, captureGoal, copyTaskState, emptyTaskState, formatTaskStatePrompt, } from "./tools/todo.js";
 import { getContextWindowInfo } from "./context-window.js";
+import { formatTokenCount } from "./token-display.js";
 import { log, logToolCall, logToolResult, startRunLog, nextRunPass, endRunLog } from "./logger.js";
 import { markSyntheticMessage, isSyntheticMessage } from "./synthetic.js";
 import { runWithInstructionTracker, resetActiveInstructionTracker } from "./instructions.js";
@@ -269,14 +270,34 @@ function sessionStateMessage(volatile) {
         return null;
     return { role: "system", content: [SESSION_STATE_HEADER, ...volatile].join("\n\n") };
 }
+export function parseContextOverflow(msg) {
+    if (!isContextOverflowError(msg))
+        return null;
+    const prompt = msg.match(/n_prompt_tokens["\s:=]+(\d+)/i)?.[1] ?? msg.match(/request\s*\((\d+)\s*tokens?\)/i)?.[1];
+    const ctx = msg.match(/n_ctx["\s:=]+(\d+)/i)?.[1] ?? msg.match(/context size\s*\((\d+)\s*tokens?\)/i)?.[1];
+    return {
+        ...(prompt ? { promptTokens: Number(prompt) } : {}),
+        ...(ctx ? { ctxTokens: Number(ctx) } : {}),
+    };
+}
+function formatContextOverflowMessage(msg) {
+    const info = parseContextOverflow(msg);
+    const prompt = info?.promptTokens != null ? formatTokenCount(info.promptTokens) : null;
+    const ctx = info?.ctxTokens != null ? formatTokenCount(info.ctxTokens) : null;
+    if (prompt && ctx)
+        return `请求内容约 ${prompt} token，超过当前上下文窗口 ${ctx}。请把窗口调大后再试。`;
+    return "请求内容超过当前上下文窗口。请把窗口调大后再试。";
+}
 function formatErrorMessage(msg) {
+    if (isContextOverflowError(msg))
+        return formatContextOverflowMessage(msg);
     if (msg.includes("API key") || msg.includes("Unauthorized") || msg.includes("Forbidden")) {
         return "Authentication error: Check your API key.";
     }
     if (msg.includes("429") || msg.includes("rate limit") || msg.includes("Rate limit")) {
         return "Rate limited after retries. Please wait and try again.";
     }
-    if (msg.includes("timeout") || msg.includes("ETIMEDOUT") || msg.includes("ECONNRESET")) {
+    if (msg.includes("timeout") || msg.includes("ETIMEDOUT")) {
         return `Network error (retries exhausted): ${msg}`;
     }
     return msg;
@@ -292,7 +313,7 @@ function safeText(value) {
     }
 }
 function isContextOverflowError(msg) {
-    return /context[\s_-]*(length|window|size)|context_length_exceeded|maximum context|too many tokens|prompt (is )?too long|reduce the (prompt )?length|token limit exceeded/i.test(msg);
+    return /exceed_context_size_error|context[\s_-]*(length|window|size)|context_length_exceeded|maximum context|too many tokens|prompt (is )?too long|reduce the (prompt )?length|token limit exceeded/i.test(msg);
 }
 function invokeCallback(fn, ...args) {
     if (!fn)
@@ -606,7 +627,7 @@ async function runOnceCoreLoop(messages, systemPrompt, modelId, abortSignal, cal
             log("error", msg);
             hasError = true;
             if (cbs.onStreamError)
-                invokeCallback(cbs.onStreamError, msg);
+                invokeCallback(cbs.onStreamError, formatErrorMessage(msg));
             else
                 console.error(`\x1b[31m${formatErrorMessage(msg)}\x1b[0m`);
             return finish({ aborted: Boolean(abortSignal?.aborted), maxStepsReached: false });
@@ -630,6 +651,25 @@ async function runOnceCoreLoop(messages, systemPrompt, modelId, abortSignal, cal
             applyToolPrune(messages, pruneBudget());
             continue;
         }
+        // Prompt (system + tools + messages) does not fit the loaded window.
+        // Retrying the same request cannot help; compaction only helps if history is long.
+        if (inner.contextPressure && inner.stepCount === 0 && !inner.lastStepHadTools) {
+            const compacted = await applyCompaction(messages, model, tracker, cbs, callbacks, { ...compactCfg, force: true }, pruneBudget());
+            if (compacted) {
+                continues++;
+                if (continues > maxContinues) {
+                    return finish({ aborted: false, maxStepsReached: true, incomplete: true });
+                }
+                continue;
+            }
+            hasError = true;
+            const display = formatErrorMessage(inner.overflowError ?? "");
+            if (cbs.onStreamError)
+                invokeCallback(cbs.onStreamError, display);
+            else
+                console.error(`\x1b[31m${display}\x1b[0m`);
+            return finish({ aborted: false, maxStepsReached: false });
+        }
         // The provider produced nothing at all (no text, no reasoning-backed reply,
         // no tool call): a transport / gateway hiccup rather than model intent.
         // Re-send the same request with backoff instead of nudging the model.
@@ -794,6 +834,7 @@ class StreamRenderer {
     thinkingSplit = new ThinkingBodySplitter();
     xmlSplit = new XmlSearchSplitter();
     rawText = "";
+    hadThinking = false;
     thinkingOpen = false;
     constructor(cbs, interactive) {
         this.cbs = cbs;
@@ -802,6 +843,7 @@ class StreamRenderer {
     emitThinking(t) {
         if (!t)
             return;
+        this.hadThinking = true;
         if (this.cbs.onThinkingDelta) {
             invokeCallback(this.cbs.onThinkingDelta, t);
             return;
@@ -926,6 +968,7 @@ class InnerStreamMachine {
     stepFinishSeen = false;
     stepUsage;
     totalUsage;
+    overflowError;
     constructor(params) {
         this.params = params;
         this.assembler = new TurnAssembler(params.messages, (info) => {
@@ -1200,6 +1243,7 @@ class InnerStreamMachine {
                 }
                 if (isContextOverflowError(errorMsg)) {
                     this.stop.context = true;
+                    this.overflowError = errorMsg;
                     log("warn", `context overflow: ${errorMsg}`);
                     await this.flushOutputAndStep();
                     this.innerController.abort();
@@ -1208,7 +1252,7 @@ class InnerStreamMachine {
                 this.hasError = true;
                 log("error", `stream error: ${errorMsg}`);
                 if (cbs.onStreamError)
-                    invokeCallback(cbs.onStreamError, errorMsg);
+                    invokeCallback(cbs.onStreamError, formatErrorMessage(errorMsg));
                 else
                     console.error(`\x1b[31m${formatErrorMessage(errorMsg)}\x1b[0m`);
                 return false;
@@ -1230,7 +1274,8 @@ class InnerStreamMachine {
             wrapUp: this.stop.wrapUp,
             lastStepHadTools: this.assembler.lastStepHadTools,
             xmlToolFollowUp: this.xmlSearchRecovered && !this.answerAfterXml && !this.stop.doom,
-            emptyCompletion: !this.assembler.hadAssistantText && !this.assembler.hadTools && !this.xmlSearchRecovered,
+            emptyCompletion: !this.stop.context && !this.assembler.hadAssistantText && !this.assembler.hadTools && !this.xmlSearchRecovered,
+            overflowError: this.overflowError,
             providerStall: this.stop.stall,
             stepCount: this.assembler.innerSteps,
             usage,
@@ -1255,7 +1300,7 @@ class InnerStreamMachine {
             // The provider went quiet and we cut the request. Nothing was produced →
             // let the empty-reply retry path re-send it; otherwise keep the partial
             // turn and continue like any other tool-only step.
-            const produced = this.assembler.hadAssistantText || this.assembler.hadTools;
+            const produced = this.assembler.hadAssistantText || this.assembler.hadTools || this.renderer.hadThinking;
             log("warn", `provider stall: ${describeError(err)}`);
             this.stop.stall = true;
             return this.snapshot(usage, { hasError: false, userAborted: false, emptyCompletion: !produced });
@@ -1267,12 +1312,13 @@ class InnerStreamMachine {
         log("error", msg);
         if (isContextOverflowError(msg)) {
             this.stop.context = true;
+            this.overflowError = msg;
             return this.snapshot(usage, { hasError: false, contextPressure: true, userAborted: false });
         }
         this.hasError = true;
         const display = formatErrorMessage(msg);
         if (this.params.cbs.onStreamError)
-            invokeCallback(this.params.cbs.onStreamError, msg);
+            invokeCallback(this.params.cbs.onStreamError, display);
         else if (display !== msg)
             console.error(`\x1b[31m${display}\x1b[0m`);
         else

package/dist/cli/commands/ctx.js

@@ -0,0 +1,7 @@
+import { runCtxCli } from "../../ctx-cli.js";
+export async function runCtxCommand(args) {
+    const result = runCtxCli({ positionals: args });
+    console.log(result.lines.join("\n"));
+    if (!result.ok)
+        process.exitCode = 1;
+}

package/dist/cli/commands/index.js

@@ -1,6 +1,6 @@
 import { Option } from "commander";
 import { resolveScope, parsePositiveIntArg } from "../option-helpers.js";
-import { runSetupCommand } from "./setup.js";
+import { registerSetupCommand } from "./setup.js";
 import { runModelsCommand } from "./models.js";
 import { runChat } from "./chat.js";
 import { runExec } from "./exec.js";
@@ -8,6 +8,7 @@ import { runServeCommand } from "./serve.js";
 import { runSandboxCommand } from "./sandbox.js";
 import { runPermissionCommand } from "./permission.js";
 import { runThinkCommand } from "./think.js";
+import { runCtxCommand } from "./ctx.js";
 import { runInitCommand } from "./init.js";
 import { runRulesShow, runRulesEdit } from "./rules.js";
 import { runUpdateCommand } from "./update.js";
@@ -45,7 +46,7 @@ export function registerCommands(program) {
         await runExec(message, rootOpts());
     });
     // --- Setup & config ----------------------------------------------------
-    program.command("setup").description("Configure providers (interactively)").action(runSetupCommand);
+    registerSetupCommand(program, rootOpts);
     program.command("init").description("Initialize .min-agent/ in current directory").action(runInitCommand);
     program
         .command("models")
@@ -125,6 +126,13 @@ export function registerCommands(program) {
         const opts = rootOpts();
         await runThinkCommand(level ? [level] : [], opts, opts);
     });
+    program
+        .command("ctx")
+        .description("Show or set the Ollama context window level")
+        .argument("[level]", "2k, 4k, 8k, 12k, 16k, 32k, 64k, 128k, 256k, or auto")
+        .action(async (level) => {
+        await runCtxCommand(level ? [level] : []);
+    });
     // --- Integrations --------------------------------------------------------
     const mcp = program.command("mcp").description("Manage MCP servers");
     mcp

package/dist/cli/commands/setup.js

@@ -1,4 +1,56 @@
-import { runSetup } from "../../config.js";
-export async function runSetupCommand() {
-    await runSetup();
+import path from "path";
+import { Option } from "commander";
+import { fetchModelsLive, getConfigDir, loadConfig, saveConfig } from "../../config.js";
+import { parsePositiveIntArg } from "../option-helpers.js";
+import { parseProviderType } from "../setup/flags.js";
+import { runSetup } from "../setup/flow.js";
+export function registerSetupCommand(program, rootOpts) {
+    program
+        .command("setup")
+        .description("Configure providers (interactively, or with flags)")
+        .addOption(new Option("--type <type>", "openai-compatible, openai, or ollama").argParser(parseProviderType))
+        .option("--url <url>", "API base URL")
+        .option("--api-key <key>", "API key")
+        .option("--name <name>", "Provider name")
+        .option("--default-model <id>", "Default model to save")
+        .addOption(new Option("--context-window <n>", "Context window in tokens").argParser(parsePositiveIntArg("--context-window")))
+        .option("--switch <name>", "Set the active provider")
+        .option("--remove <name>", "Remove a provider")
+        .option("-y, --yes", "Skip overwrite and delete confirmation")
+        .action(async (opts) => {
+        await runSetupCommand(opts, { yes: Boolean(opts.yes || rootOpts().yes) });
+    });
+}
+function createSetupDeps() {
+    return {
+        isTty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        load: loadConfig,
+        save: saveConfig,
+        fetchLive: fetchModelsLive,
+        log: (message) => {
+            console.log(message);
+        },
+        configPath: () => path.join(getConfigDir(), "config.json"),
+        runWizard: async (wizardMode) => {
+            const { renderSetupWizard } = await import("../setup/ui.js");
+            return renderSetupWizard(wizardMode);
+        },
+    };
+}
+export async function offerInteractiveSetup(mode) {
+    await runSetup({}, { ...createSetupDeps(), isTty: true }, mode);
+}
+export async function runSetupCommand(opts, session) {
+    const flags = {
+        type: opts.type,
+        url: opts.url,
+        apiKey: opts.apiKey,
+        name: opts.name,
+        defaultModel: opts.defaultModel,
+        contextWindow: opts.contextWindow,
+        switch: opts.switch,
+        remove: opts.remove,
+        yes: Boolean(session.yes || opts.yes),
+    };
+    await runSetup(flags, createSetupDeps());
 }

package/dist/cli/commands/shared.js

@@ -1,8 +1,17 @@
 import { isConfigured } from "../../config.js";
 import { CliError } from "../errors.js";
+import { shouldOfferSetupWizard } from "../setup/flow.js";
 export async function startTuiSession(input) {
     if (!isConfigured()) {
-        throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+        const tty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        if (!shouldOfferSetupWizard(false, tty)) {
+            throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+        }
+        const { offerInteractiveSetup } = await import("./setup.js");
+        await offerInteractiveSetup("session-gate");
+        if (!isConfigured()) {
+            throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
+        }
     }
     const { runTui } = await import("../../tui-chat.js");
     const prompt = input.positionals.join(" ").trim();

package/dist/cli/program.js

@@ -47,7 +47,7 @@ Session:
   min-agent exec --resume <id> <msg> Continue a saved exec session
 
 Setup & config:
-  min-agent setup                    Configure providers (interactively)
+  min-agent setup [--type T]         Configure providers (interactively, or with flags)
   min-agent init                     Initialize .min-agent/ in current directory
   min-agent models                   List available models
   min-agent rules [edit]             Show or edit instruction rules
@@ -57,6 +57,7 @@ Setup & config:
   min-agent sandbox network <allow|deny>      Show or set network policy
   min-agent permission [ask|accept-edits|allow-all]  Show or set confirmation mode
   min-agent think [off|low|medium|high|max]          Show or set thinking intensity
+  min-agent ctx [2k|4k|8k|12k|16k|32k|64k|128k|256k|auto]  Show or set Ollama context window
 
 Integrations:
   min-agent mcp <list|add|remove|info|check|enable|disable>   Manage MCP servers
@@ -79,6 +80,10 @@ Thinking intensity (default: medium):
   high       Strong reasoning
   max        Highest reasoning
 
+Ollama context window:
+  2k … 256k  Loaded window size
+  auto       Use the model's default
+
 Memory (default: off):
   off        Do not inject memories or expose memory tools
   on         Remember facts across sessions
@@ -96,6 +101,7 @@ Rules (loaded as system instructions):
 
 Examples:
   min-agent setup
+  min-agent setup --type ollama
   min-agent
   min-agent "hello"
   min-agent exec "hello"

package/dist/cli/setup/detect.js

@@ -0,0 +1,17 @@
+import { normalizeOllamaBaseURL } from "../../config.js";
+const DEFAULT_TAGS_URL = "http://localhost:11434/api/tags";
+const DEFAULT_TIMEOUT_MS = 800;
+const DEFAULT_BASE = "http://localhost:11434/v1";
+export async function detectLocalOllama(opts) {
+    const fetchImpl = opts?.fetchImpl ?? fetch;
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    try {
+        const response = await fetchImpl(DEFAULT_TAGS_URL, { signal: AbortSignal.timeout(timeoutMs) });
+        if (!response.ok)
+            return { found: false };
+        return { found: true, baseURL: normalizeOllamaBaseURL(DEFAULT_BASE) };
+    }
+    catch {
+        return { found: false };
+    }
+}

package/dist/cli/setup/flags.js

@@ -0,0 +1,12 @@
+import { userError } from "../errors.js";
+export function parseProviderType(value) {
+    if (value === "openai-compatible" || value === "openai" || value === "ollama")
+        return value;
+    throw userError(`Invalid --type value: "${value}"`, "use one of: openai-compatible, openai, ollama");
+}
+export function isNonInteractive(flags) {
+    return Boolean(flags.type || flags.switch || flags.remove);
+}
+export function exclusiveActionCount(flags) {
+    return [flags.type, flags.switch, flags.remove].filter(Boolean).length;
+}

package/dist/cli/setup/flow.js

@@ -0,0 +1,108 @@
+import { getActiveProvider, normalizeOllamaBaseURL } from "../../config.js";
+import { CliError, runtimeError } from "../errors.js";
+import { applyAddProvider, applyRemoveProvider, applySwitchProvider, suggestName, } from "./provider-form.js";
+import { exclusiveActionCount } from "./flags.js";
+const OPENAI_URL = "https://api.openai.com/v1";
+const OLLAMA_URL = "http://localhost:11434/v1";
+const NON_INTERACTIVE_HINT = "使用 --type、--switch 或 --remove。例如: min-agent setup --type ollama";
+export function shouldOfferSetupWizard(configured, isTty) {
+    return !configured && isTty;
+}
+export async function runSetup(flags, deps, wizardMode) {
+    if (exclusiveActionCount(flags) > 1) {
+        throw new CliError("一次只能执行一种操作。");
+    }
+    if (flags.remove) {
+        await runRemove(flags.remove, flags.yes === true, deps);
+        return;
+    }
+    if (flags.switch) {
+        persist(applySwitchProvider(deps.load(), flags.switch), deps);
+        return;
+    }
+    if (flags.type) {
+        await runAdd(flags, deps);
+        return;
+    }
+    if (!deps.isTty) {
+        throw new CliError("无法在非交互环境完成配置。", { hint: NON_INTERACTIVE_HINT });
+    }
+    const config = deps.load();
+    const mode = wizardMode ?? (hasUsableProvider(config) ? "hub" : "first-run");
+    await deps.runWizard(mode);
+}
+function hasUsableProvider(config) {
+    const provider = getActiveProvider(config);
+    return Boolean(provider?.baseURL && provider?.apiKey);
+}
+async function runRemove(name, yes, deps) {
+    if (!yes) {
+        throw new CliError("删除需要确认。", { hint: "加上 --yes" });
+    }
+    persist(applyRemoveProvider(deps.load(), name), deps);
+}
+async function runAdd(flags, deps) {
+    const type = flags.type;
+    const baseURL = resolveBaseURL(type, flags.url);
+    const apiKey = resolveApiKey(type, flags.apiKey);
+    const defaultModel = await resolveDefaultModel(type, baseURL, apiKey, flags.defaultModel, deps.fetchLive);
+    const config = deps.load();
+    const existing = (config.providers ?? []).map((p) => p.name).filter((name) => Boolean(name));
+    const name = (flags.name?.trim() || suggestName(type, baseURL, existing)).trim();
+    const draft = {
+        name,
+        type,
+        baseURL,
+        apiKey,
+        defaultModel,
+        ...(flags.contextWindow != null ? { contextWindow: flags.contextWindow } : {}),
+    };
+    const overwrite = flags.yes === true;
+    const result = applyAddProvider(config, draft, { overwrite });
+    if (isApplyError(result) && result.error.startsWith("已存在同名服务商") && !overwrite) {
+        throw new CliError(result.error, { hint: "加上 --yes 以覆盖" });
+    }
+    persist(result, deps);
+}
+function resolveBaseURL(type, url) {
+    if (type === "openai")
+        return OPENAI_URL;
+    if (type === "ollama")
+        return normalizeOllamaBaseURL(url?.trim() || OLLAMA_URL);
+    const trimmed = url?.trim() ?? "";
+    if (!trimmed)
+        throw new CliError("API 地址不能为空。");
+    return trimmed.replace(/\/$/, "");
+}
+function resolveApiKey(type, apiKey) {
+    if (type === "ollama")
+        return apiKey?.trim() || "ollama";
+    const trimmed = apiKey?.trim() ?? "";
+    if (!trimmed)
+        throw new CliError("API 密钥不能为空。");
+    return trimmed;
+}
+async function resolveDefaultModel(type, baseURL, apiKey, explicit, fetchLive) {
+    const given = explicit?.trim() ?? "";
+    if (given)
+        return given;
+    const live = await fetchLive(baseURL, apiKey);
+    if (live.models[0])
+        return live.models[0];
+    if (type === "ollama")
+        return "llama3";
+    if (!live.ok && live.status == null) {
+        throw runtimeError("无法连接到该服务商。");
+    }
+    throw new CliError("默认模型不能为空。");
+}
+function persist(result, deps) {
+    if (isApplyError(result))
+        throw new CliError(result.error);
+    deps.save(result);
+    deps.log(`已保存到 ${deps.configPath()}`);
+}
+function isApplyError(result) {
+    return Object.keys(result).length === 1 && "error" in result;
+}
+export { isNonInteractive } from "./flags.js";

package/dist/cli/setup/provider-form.js

@@ -0,0 +1,102 @@
+export function suggestName(type, baseURL, existing) {
+    const base = type === "openai" ? "openai" : type === "ollama" ? "ollama" : (hostSlug(baseURL) ?? "provider");
+    return uniqueName(base, existing);
+}
+export function validateProviderName(name) {
+    const trimmed = name.trim();
+    if (!trimmed || trimmed.includes("/") || trimmed.includes(":")) {
+        return "名称不能为空，且不能包含 / 或 :。";
+    }
+    return null;
+}
+export function maskApiKey(key) {
+    if (key.length < 4)
+        return "****";
+    return `…${key.slice(-4)}`;
+}
+export function filterChoices(query, items) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return [...items];
+    return items.filter((item) => item.toLowerCase().includes(q));
+}
+export function applyAddProvider(config, draft, opts) {
+    const nameError = validateProviderName(draft.name);
+    if (nameError)
+        return { error: nameError };
+    const name = draft.name.trim();
+    const providers = [...(config.providers ?? [])];
+    const idx = providers.findIndex((p) => p.name === name);
+    if (idx >= 0 && !opts.overwrite)
+        return { error: `已存在同名服务商 "${name}"。` };
+    const entry = toProvider(draft, name);
+    if (idx >= 0)
+        providers[idx] = entry;
+    else
+        providers.push(entry);
+    return { ...config, providers, activeProvider: name };
+}
+export function applySwitchProvider(config, name) {
+    const target = (config.providers ?? []).find((p) => p.name === name);
+    if (!target)
+        return { error: `找不到服务商 "${name}"。` };
+    return { ...config, activeProvider: name };
+}
+export function applyUpdateProvider(config, oldName, draft) {
+    const nameError = validateProviderName(draft.name);
+    if (nameError)
+        return { error: nameError };
+    const name = draft.name.trim();
+    const providers = [...(config.providers ?? [])];
+    const idx = providers.findIndex((p) => p.name === oldName);
+    if (idx < 0)
+        return { error: `找不到服务商 "${oldName}"。` };
+    if (name !== oldName && providers.some((p) => p.name === name)) {
+        return { error: `已存在同名服务商 "${name}"。` };
+    }
+    providers[idx] = toProvider(draft, name);
+    const activeProvider = config.activeProvider === oldName ? name : config.activeProvider;
+    return { ...config, providers, activeProvider };
+}
+export function applyRemoveProvider(config, name) {
+    const providers = config.providers ?? [];
+    if (!providers.some((p) => p.name === name))
+        return { error: `找不到服务商 "${name}"。` };
+    const remaining = providers.filter((p) => p.name !== name);
+    if (remaining.length === 0) {
+        const { activeProvider: _dropped, ...rest } = config;
+        return { ...rest, providers: [] };
+    }
+    const activeProvider = config.activeProvider === name ? remaining[0]?.name : config.activeProvider;
+    return { ...config, providers: remaining, activeProvider };
+}
+function toProvider(draft, name) {
+    return {
+        name,
+        type: draft.type,
+        baseURL: draft.baseURL,
+        apiKey: draft.apiKey,
+        defaultModel: draft.defaultModel,
+        ...(draft.contextWindow != null ? { contextWindow: draft.contextWindow } : {}),
+    };
+}
+function hostSlug(baseURL) {
+    try {
+        const host = new URL(baseURL).hostname.toLowerCase();
+        const trimmed = host.startsWith("www.") ? host.slice(4) : host;
+        if (!trimmed)
+            return undefined;
+        return trimmed.replace(/\./g, "-");
+    }
+    catch {
+        return undefined;
+    }
+}
+function uniqueName(base, existing) {
+    if (!existing.includes(base))
+        return base;
+    let n = 2;
+    while (existing.includes(`${base}-${n}`))
+        n += 1;
+    return `${base}-${n}`;
+}