@bolloon/bolloon-agent 0.4.33 → 0.5.1

package/dist/electron-build/llm/model-selection.js

@@ -0,0 +1,1315 @@
+"use strict";
+/**
+ * model-selection.ts — 「有效模型配置」的唯一入口 (2026-09-26)
+ *
+ * ## 修的是什么
+ *
+ * 此前切换模型有三条各走各的路 (CLI `/model`、Web `/api/llm-config` + `/api/llm-provider`、
+ * 初始化向导), 每条路都只做其中一部分: CLI 那条只改配置文件、**不重建模型运行时** ——
+ * 于是出现"配置文件已经改了, 内存里的实例还是旧的"这种半成功状态: 用户以为切了, 下一次
+ * 请求还是打到旧供应商。Web 那条重建了运行时, 但不支持切 API URL, 也不记录"这次切换属于
+ * 哪个作用域"。
+ *
+ * 这里把七步收敛成**一个函数** (`selectModel`), CLI / Web / 向导 / 工具调用都只能调它:
+ *
+ * ```
+ * validateSelection → 轻量连通探测 → 写配置 → 更新 active scope → 重建模型运行时
+ *                   → 更新当前 session → 返回 effective config
+ * ```
+ *
+ * 三条硬规则 (写在实现里, 不是文档里):
+ *   ① **进行中的 HTTP 请求继续用旧配置** —— 运行时实例在构造时就把 provider/model/baseUrl
+ *      固化下来 (`PiAIModel` 的 `this.config`), 重建只是换掉单例引用; 已经在飞的那次请求
+ *      握着自己的旧实例, 不会中途改口径。
+ *   ② **下一次模型调用必须用新配置** —— 调用点每次都 `getMinimax()` 现取单例, 不做本地缓存。
+ *   ③ **切换失败时配置与运行时都保持原样** —— 校验与探测都在**写盘之前**; 写盘之后任何一步
+ *      出错 (含运行时重建抛错) 都会把配置文件字节级还原成切换前的样子, 并用旧配置重新初始化
+ *      运行时, 然后如实返回失败。没有"文件已改但实例仍旧"的中间态。
+ *
+ * ## 「有效模型配置」
+ *
+ * 不能只存 `activeProvider + providers[provider].model`。一次解析要同时说清
+ * `provider · model · baseUrl · protocol · authRef · reasoning · scope · source · updatedAt`,
+ * 并按**固定优先级**从五层里挑:
+ *
+ * ```
+ * Run/Goal 显式绑定 > 当前 Session 绑定 > 用户 Global 默认 > provider 默认 > 环境变量
+ * ```
+ *
+ * 纯函数 `resolveSelection()` 负责这条优先级 (可单测, 不碰磁盘); `effectiveModelConfig()`
+ * 负责从磁盘/环境把五层读出来喂给它。
+ *
+ * `authRef` **只记凭证来源的引用名** (如 `provider:deepseek` / `env:DEEPSEEK_API_KEY` / `none`),
+ * 永远不记 key 本身 —— 有效配置是要被打印、被写进 Run 记录的。
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROBE_TIMEOUT_MS = exports.CONFIG_LOCK_FILE = exports.SESSION_BINDINGS_FILE = exports.SELECTION_FAILURE_ZH = exports.UNMAPPED_PROBE_CLASS = exports.PROBE_TO_SELECTION = exports.SELECTION_FAILURE_CLASS_ORIGIN = exports.SELECTION_FAILURE_CLASSES = exports.SELECTION_PRIORITY = void 0;
+exports.mapProbeFailureClass = mapProbeFailureClass;
+exports.selectionFailureClassTable = selectionFailureClassTable;
+exports.protocolOf = protocolOf;
+exports.supportsReasoning = supportsReasoning;
+exports.envKeyNamesOf = envKeyNamesOf;
+exports.credentialFingerprintOf = credentialFingerprintOf;
+exports.providerFactsOf = providerFactsOf;
+exports.registryEntryOf = registryEntryOf;
+exports.listRegisteredProviderIds = listRegisteredProviderIds;
+exports.envApiKeyOf = envApiKeyOf;
+exports.normalizeBaseUrl = normalizeBaseUrl;
+exports.validateBaseUrlShape = validateBaseUrlShape;
+exports.configHashOf = configHashOf;
+exports.materialize = materialize;
+exports.runModelConfigOf = runModelConfigOf;
+exports.resolveSelection = resolveSelection;
+exports.currentSessionKey = currentSessionKey;
+exports.readSessionSelection = readSessionSelection;
+exports.writeSessionSelection = writeSessionSelection;
+exports.clearSessionSelection = clearSessionSelection;
+exports.effectiveModelConfig = effectiveModelConfig;
+exports.captureRunModelConfig = captureRunModelConfig;
+exports.applyEffectiveToRuntime = applyEffectiveToRuntime;
+exports.applyRunModelConfigToRuntime = applyRunModelConfigToRuntime;
+exports.usableFallbackCandidates = usableFallbackCandidates;
+exports.withConfigLock = withConfigLock;
+exports.baseDefaultsOf = baseDefaultsOf;
+exports.validateSelection = validateSelection;
+exports.runConnectionProbe = runConnectionProbe;
+exports.probeSelection = probeSelection;
+exports.selectModel = selectModel;
+exports.resetModelSelection = resetModelSelection;
+exports.formatEffectiveModel = formatEffectiveModel;
+exports.providerDisplayName = providerDisplayName;
+exports.compareRunModelConfig = compareRunModelConfig;
+exports.detectRunModelDrift = detectRunModelDrift;
+exports.detectRunConfigDrift = detectRunConfigDrift;
+const fsSync = __importStar(require("fs"));
+const fsp = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const config_store_js_1 = require("./config-store.js");
+const index_js_1 = require("../constraints/index.js");
+const connection_probe_js_1 = require("./connection-probe.js");
+// 2026-09-26 (P6): 入口现在按**注册表**校验供应商 —— 于是自定义供应商 (不改 TS 联合类型) 也能
+//   被切成全局默认。方向是 `model-selection → provider-registry` (与 `config-store → provider-registry`
+//   同一条边, 不是新方向的循环): 注册表自己把内置表派生过来, 所以**内置的行为一字不变**
+//   (`entry.protocol === protocolOf(id)` / `entry.apiKeyEnvVars === envKeyNamesOf(id)` 由注册表门禁钉住)。
+const provider_registry_js_1 = require("./provider-registry.js");
+// ============================================================
+// 类型
+// ============================================================
+/** 解析优先级 (固定顺序, 不允许调用方打乱) */
+exports.SELECTION_PRIORITY = ['run', 'session', 'global', 'provider', 'env'];
+/**
+ * 入口自己的失败分类 (冻结)。一次切换失败**必须**落到这里的一个类上 ——
+ * 只回一句"切换失败"或"连接失败"等于没有信息, 用户无从知道该改 URL、改 key、还是改模型名。
+ *
+ * 分两组, 由 `SELECTION_FAILURE_CLASS_ORIGIN` 逐类标出真出处:
+ *
+ *   · `probe` (7 类) —— P4 探测原语 (`connection-probe.ts`) 报出的类目, 经
+ *     `PROBE_TO_SELECTION` **逐类映射**过来 (不是"把探测结果揉成一句失败");
+ *   · `entry` (8 类) —— 入口自己在写盘**之前**的校验、以及写盘**之后**的写盘/重建路径产生的类
+ *     (探测原语根本不回答这些: 它不校验 provider 是否存在、不写盘、不建运行时)。
+ *
+ * 为什么 `tool_call_unsupported` 必须出现在这里: 探测原语第 ⑥ 步会**真的**去确认工具调用能力,
+ * 它是一个独立类目。入口若没有这一类, 映射时就只能把它塞进别的类 (或退化成"切换失败") ——
+ * 而这一类恰恰是用户最需要看到的: 它直接回答"这个模型能不能用来做 Agent 执行"。
+ */
+exports.SELECTION_FAILURE_CLASSES = [
+    // ── 由探测原语映射而来 (7) ──
+    'invalid_url',
+    'auth_failed',
+    'provider_unreachable',
+    'model_not_found',
+    'protocol_mismatch',
+    'tool_call_unsupported',
+    'timeout',
+    // ── 入口自己判定 (9) ──
+    'invalid_provider',
+    'invalid_model',
+    'missing_api_key',
+    'credential_scope_conflict',
+    'invalid_temperature',
+    'persist_failed',
+    'runtime_rebuild_failed',
+    'probe_failure_unmapped',
+    /**
+     * 目录里的家需要**本运行时不支持的鉴权形状** (云签名 / OAuth / 多变量云凭证 …)。
+     * 为什么单列一类而不是并进 `auth_failed`: `auth_failed` 是"发了请求被拒" (探测报的),
+     * 这一类是"**根本没发** —— 我们不会说那家的鉴权语言"。两者对用户的含义完全不同:
+     * 前者要换 key, 后者要换路 (走 openai-compatible 的自定义供应商)。
+     */
+    'provider_auth_unsupported',
+];
+/** 逐类的**真出处** (`probe` = 探测原语报的; `entry` = 入口自己判的) */
+exports.SELECTION_FAILURE_CLASS_ORIGIN = {
+    invalid_url: 'probe',
+    auth_failed: 'probe',
+    provider_unreachable: 'probe',
+    model_not_found: 'probe',
+    protocol_mismatch: 'probe',
+    tool_call_unsupported: 'probe',
+    timeout: 'probe',
+    invalid_provider: 'entry',
+    invalid_model: 'entry',
+    missing_api_key: 'entry',
+    credential_scope_conflict: 'entry',
+    invalid_temperature: 'entry',
+    persist_failed: 'entry',
+    runtime_rebuild_failed: 'entry',
+    probe_failure_unmapped: 'entry',
+    provider_auth_unsupported: 'entry',
+};
+/**
+ * **持久化映射表**: 探测原语的 7 类 → 入口类目。
+ *
+ * 逐类点名 (不写"其余照搬"): 这张表是"探测换一次实现, 入口的对外文案会不会悄悄变形"的唯一答案。
+ * 门禁 (`scripts/verify-model-wiring.ts`) 断言: 这张表的键集 == `PROBE_FAILURE_CLASSES`,
+ * 且每个值都在 `SELECTION_FAILURE_CLASSES` 里 —— 少一类 / 映射到不存在的类都判红。
+ */
+exports.PROBE_TO_SELECTION = {
+    invalid_url: 'invalid_url',
+    auth_failed: 'auth_failed',
+    provider_unreachable: 'provider_unreachable',
+    model_not_found: 'model_not_found',
+    protocol_mismatch: 'protocol_mismatch',
+    tool_call_unsupported: 'tool_call_unsupported',
+    timeout: 'timeout',
+};
+/**
+ * 未映射的探测类目。
+ *
+ * 理论上**不可达** (上面 7 类已被 `PROBE_TO_SELECTION` 全覆盖, 门禁钉住这一点)。真走到这里
+ * 只可能是 P4 加了新类而入口没同步: 这时仍然如实报出**原文类名** (`probeClass`), 绝不退化成
+ * "切换失败"这种无信息文案 —— 宁可暴露一个没见过的类名, 也不许把事实糊掉。
+ */
+exports.UNMAPPED_PROBE_CLASS = 'probe_failure_unmapped';
+/** 探测类目 → 入口类目 (映射之后的类名与原名一起给出, 调用方要报原文就报原文) */
+function mapProbeFailureClass(rawClass) {
+    const raw = String(rawClass ?? '');
+    if (Object.prototype.hasOwnProperty.call(exports.PROBE_TO_SELECTION, raw)) {
+        return { failureClass: exports.PROBE_TO_SELECTION[raw], raw, unmapped: false };
+    }
+    return { failureClass: exports.UNMAPPED_PROBE_CLASS, raw, unmapped: true };
+}
+/** 一张给人看的映射表 (逐行, 报告/CLI/门禁共用同一张表, 不许各自再写一份) */
+function selectionFailureClassTable() {
+    const bySelection = new Map();
+    for (const pc of connection_probe_js_1.PROBE_FAILURE_CLASSES)
+        bySelection.set(exports.PROBE_TO_SELECTION[pc], pc);
+    return exports.SELECTION_FAILURE_CLASSES.map((s) => {
+        const probeClass = bySelection.get(s);
+        return {
+            selection: s,
+            origin: exports.SELECTION_FAILURE_CLASS_ORIGIN[s],
+            ...(probeClass ? { probeClass } : {}),
+            zh: probeClass ? connection_probe_js_1.PROBE_FAILURE_ZH[probeClass] : exports.SELECTION_FAILURE_ZH[s],
+        };
+    });
+}
+/** 入口自有类目的中文说法 (探测类目直接复用原语的人话, 不再翻译一遍) */
+exports.SELECTION_FAILURE_ZH = {
+    invalid_url: 'URL 写错了',
+    auth_failed: '凭证被拒',
+    provider_unreachable: '连不上供应商',
+    model_not_found: '端点不认识这个模型名',
+    protocol_mismatch: '这个地址上的服务不是该协议',
+    tool_call_unsupported: '模型/端点不接受工具调用声明',
+    timeout: '探测超时',
+    invalid_provider: '供应商不存在 (内置表与注册表里都没有这家)',
+    invalid_model: '模型名为空 (配置里没有, 也没有内置默认)',
+    missing_api_key: '这家还需要 API key (配置里没有, 环境变量也没有)',
+    credential_scope_conflict: '会话级切换不许写凭证 (凭证只属于全局)',
+    invalid_temperature: 'temperature 不在 0~2',
+    persist_failed: '写配置失败 (已回滚, 盘上仍是旧配置)',
+    runtime_rebuild_failed: '配置写成功但重建模型运行时失败 (已回滚)',
+    probe_failure_unmapped: '探测报了一个入口还不认识的类目 (映射表没覆盖)',
+    provider_auth_unsupported: '这家需要专用鉴权 (本版本未支持) —— 请求根本没发出去',
+};
+// ============================================================
+// 纯函数: 协议 / 规范化 / 摘要
+// ============================================================
+const PROTOCOL_OF = {
+    anthropic: 'anthropic',
+    gemini: 'gemini',
+    ollama: 'ollama',
+    local: 'ollama',
+    // 其余 (openai/openrouter/deepseek/kimi/glm/qwen/mimo/minimax/grok) 都是 openai 兼容
+};
+function protocolOf(provider) {
+    return PROTOCOL_OF[provider] || 'openai-compatible';
+}
+/** 该 provider 默认是否原生支持 reasoning (仅作展示/校验参考, 不参与路由) */
+const REASONING_PROVIDERS = new Set(['deepseek', 'minimax', 'glm', 'openai', 'anthropic', 'grok']);
+function supportsReasoning(provider) {
+    return REASONING_PROVIDERS.has(provider);
+}
+/** provider → 读 API key 的环境变量名 (可能多个别名) */
+const ENV_KEY_NAMES = {
+    openai: ['OPENAI_API_KEY'],
+    anthropic: ['ANTHROPIC_API_KEY'],
+    openrouter: ['OPENROUTER_API_KEY'],
+    gemini: ['GEMINI_API_KEY'],
+    minimax: ['MINIMAX_API_KEY'],
+    deepseek: ['DEEPSEEK_API_KEY'],
+    kimi: ['KIMI_API_KEY', 'MOONSHOT_API_KEY'],
+    glm: ['GLM_API_KEY', 'ZHIPU_API_KEY'],
+    qwen: ['QWEN_API_KEY', 'DASHSCOPE_API_KEY'],
+    mimo: ['MIMO_API_KEY'],
+    grok: ['XAI_API_KEY'],
+    ollama: ['OLLAMA_API_KEY'],
+    local: ['OLLAMA_API_KEY'],
+};
+function envKeyNamesOf(provider) {
+    return ENV_KEY_NAMES[provider] || [];
+}
+/**
+ * 这个供应商**当前生效凭据的指纹** (`fp:<sha256 前 16 位>`), 没有则 `undefined`。
+ *
+ * **只有指纹, 没有明文** —— 界面/报告要能说"沿用现有 key (指纹 fp:xxxx)"以及"替换后指纹真的变了",
+ * 但不许把 key 本身写进任何输出。哈希口径与模型发现缓存**同一把尺子**
+ * (`credentialIdentityOf`, 见 `model-discovery.ts`), 免得同一把 key 在两处算出两个指纹。
+ */
+async function credentialFingerprintOf(provider) {
+    const { resolvedApiKeyOf } = await Promise.resolve().then(() => __importStar(require('./model-catalog.js')));
+    const v = await resolvedApiKeyOf(provider).catch(() => undefined);
+    const k = String(v || '').trim();
+    if (!k)
+        return undefined;
+    const md = await Promise.resolve().then(() => __importStar(require('./model-discovery.js')));
+    return md.credentialIdentityOf(k);
+}
+function providerFactsOf(provider) {
+    const id = String(provider || '').trim().toLowerCase();
+    const entry = id ? (0, provider_registry_js_1.getProviderRegistryEntry)(id) : undefined;
+    if (entry && entry.kind !== 'builtin') {
+        return {
+            protocol: entry.protocol,
+            envKeys: Array.isArray(entry.apiKeyEnvVars) ? [...entry.apiKeyEnvVars] : [],
+            reasoning: entry.reasoning === 'yes',
+        };
+    }
+    return { protocol: protocolOf(id), envKeys: envKeyNamesOf(id), reasoning: supportsReasoning(id) };
+}
+/** 注册表里这一家的条目 (入口校验用; 不在册 → `undefined`, 不编一条出来) */
+function registryEntryOf(provider) {
+    const id = String(provider || '').trim().toLowerCase();
+    return id ? (0, provider_registry_js_1.getProviderRegistryEntry)(id) : undefined;
+}
+/** 现在**在册**的全部 provider id (内置 + 自定义) —— 只用于"未知供应商"那句话里列出可用项 */
+function listRegisteredProviderIds() {
+    try {
+        return (0, provider_registry_js_1.listProviderRegistry)().map((e) => String(e.id)).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function envKeyOf(provider) {
+    for (const name of providerFactsOf(provider).envKeys) {
+        const v = process.env[name];
+        if (v && v.trim())
+            return { name: name, value: v.trim() };
+    }
+    return null;
+}
+/** 环境变量凭证 (给"重建运行时"这一处用) —— 只返回来源名与值, 不写进任何快照/日志 */
+function envApiKeyOf(provider) {
+    return envKeyOf(provider);
+}
+/**
+ * URL 规范化 —— 去尾部斜杠、折叠重复斜杠、去重复的 `/v1`。
+ * `http://127.0.0.1:8O8O/v1/` 和 `http://127.0.0.1:8080/v1` 是同一个地址,
+ * 不做这一步就会出现"配置里写着 /v1, 拼出来是 /v1/v1/models"这种隐藏 URL 问题。
+ */
+function normalizeBaseUrl(raw) {
+    let u = String(raw || '').trim();
+    if (!u)
+        return '';
+    // 去重复斜杠 (保留协议后的 `://`)
+    u = u.replace(/([^:])\/{2,}/g, '$1/');
+    u = u.replace(/\/+$/g, '');
+    // 去重复的 /v1 (只处理结尾出现两次以上的情况)
+    u = u.replace(/(\/v\d+)(\/v\d+)+$/i, '$1');
+    return u;
+}
+/** URL 形状校验 (只查形状, 不查可达性) */
+function validateBaseUrlShape(raw) {
+    const url = normalizeBaseUrl(raw);
+    if (!url)
+        return { ok: false, reason: '空 URL' };
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return { ok: false, reason: `不是合法 URL: ${url}` };
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return { ok: false, reason: `只支持 http/https, 收到 ${parsed.protocol}` };
+    }
+    if (!parsed.hostname)
+        return { ok: false, reason: '缺少主机名' };
+    return { ok: true, url };
+}
+const CONFIG_HASH_FIELDS = ['provider', 'model', 'baseUrl', 'protocol'];
+/** 稳定摘要: 同样的 provider/model/baseUrl/protocol 一定得到同样的 hash */
+function configHashOf(sel) {
+    const parts = [
+        sel.provider,
+        sel.model,
+        normalizeBaseUrl(sel.baseUrl),
+        sel.protocol || protocolOf(sel.provider),
+    ];
+    return crypto.createHash('sha256').update(parts.join('\u0000')).digest('hex').slice(0, 16);
+}
+/** 一层候选 → 有效配置 (补齐 protocol / authRef / reasoning / hash) */
+function materialize(sel, source) {
+    const provider = String(sel.provider || '');
+    const model = String(sel.model || '');
+    const baseUrl = normalizeBaseUrl(sel.baseUrl || '');
+    // 协议/环境变量/reasoning 一律走 `providerFactsOf`: 内置走内置表 (与旧实现逐字相同),
+    // 自定义走注册表 (它的声明才是唯一出处)。绝不在这里按 provider 名再写一份表。
+    const facts = providerFactsOf(provider);
+    const protocol = facts.protocol;
+    const envKey = envKeyOf(provider);
+    // 凭据来源: 显式声明优先 (用户选了"改用环境变量"就如实写 env:), 否则按"有 key ⇒ provider"推断
+    const credentialSource = sel.credentialSource ?? (sel.apiKey ? 'provider' : envKey ? 'env' : 'none');
+    const authRef = credentialSource === 'env' && envKey ? `env:${envKey.name}`
+        : sel.apiKey ? `provider:${provider}`
+            : envKey ? `env:${envKey.name}`
+                : 'none';
+    return {
+        provider,
+        model,
+        baseUrl,
+        protocol,
+        authRef,
+        reasoning: facts.reasoning,
+        reasoningMode: sel.reasoningMode === true ? 'on' : sel.reasoningMode === false ? 'off' : 'unset',
+        temperature: typeof sel.temperature === 'number' && Number.isFinite(sel.temperature) ? sel.temperature : null,
+        scope: source,
+        source,
+        updatedAt: sel.updatedAt || new Date().toISOString(),
+        configHash: configHashOf({ provider, model, baseUrl, protocol }),
+    };
+}
+function runModelConfigOf(eff, capturedAt = new Date().toISOString()) {
+    return {
+        provider: eff.provider,
+        model: eff.model,
+        baseUrl: eff.baseUrl,
+        configHash: eff.configHash,
+        selectionScope: eff.source,
+        capturedAt,
+    };
+}
+/**
+ * 五层优先级解析 (纯函数)。
+ *
+ * 为什么 provider 默认排在 env 前面、env 排最后: 配置文件里的一行是"用户明确选的东西",
+ * 内置默认是"这个供应商公认的模型", 环境变量只应该**补凭证**。环境变量要压过内置默认,
+ * 必须由调用方显式构造 env 层 —— 这样"谁赢了"永远能在代码里一眼读到, 不靠隐式启发式。
+ */
+function resolveSelection(layers) {
+    for (const source of exports.SELECTION_PRIORITY) {
+        const layer = layers[source];
+        if (!layer)
+            continue;
+        if (!layer.provider)
+            continue;
+        if (!layer.model && !layer.baseUrl)
+            continue;
+        return materialize(layer, source);
+    }
+    // 五层全空: 退化到内置 openai 默认, 但如实标 provider 层 (不假装是用户选的)
+    const fallback = config_store_js_1.DEFAULT_PROVIDER_CONFIGS.openai;
+    return materialize({ provider: 'openai', model: fallback.model, baseUrl: fallback.baseUrl }, 'provider');
+}
+// ============================================================
+// 磁盘层: Global (配置文件) / Session (会话绑定)
+// ============================================================
+exports.SESSION_BINDINGS_FILE = 'model-sessions.json';
+exports.CONFIG_LOCK_FILE = 'bolloon-config.lock';
+function sessionBindingsPath() {
+    return path.join(config_store_js_1.llmConfigStore.configDirPath(), exports.SESSION_BINDINGS_FILE);
+}
+/** 当前 CLI 会话键 (会话内 `/model --session` 绑定到它) */
+function currentSessionKey() {
+    return (process.env.BOLLOON_SESSION_KEY || '').trim() || 'cli-default';
+}
+async function readSessionBindings() {
+    try {
+        const raw = await fsp.readFile(sessionBindingsPath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.sessions && typeof parsed.sessions === 'object') {
+            return { version: 1, sessions: parsed.sessions };
+        }
+    }
+    catch { /* 不存在/损坏 → 空表 (损坏不做静默放行: 读不出就当没有绑定) */ }
+    return { version: 1, sessions: {} };
+}
+async function readSessionSelection(sessionKey) {
+    const key = (sessionKey || currentSessionKey()).trim();
+    if (!key)
+        return null;
+    const all = await readSessionBindings();
+    const hit = all.sessions[key];
+    if (!hit || !hit.provider)
+        return null;
+    return {
+        provider: hit.provider,
+        model: hit.model,
+        baseUrl: hit.baseUrl,
+        ...(typeof hit.temperature === 'number' ? { temperature: hit.temperature } : {}),
+        ...(typeof hit.reasoningMode === 'boolean' ? { reasoningMode: hit.reasoningMode } : {}),
+        updatedAt: hit.updatedAt,
+    };
+}
+async function writeSessionSelection(sessionKey, sel) {
+    const key = String(sessionKey || '').trim();
+    if (!key)
+        throw new Error('sessionKey 为空, 拒绝写会话级模型绑定');
+    const all = await readSessionBindings();
+    all.sessions[key] = {
+        provider: sel.provider,
+        model: sel.model,
+        baseUrl: normalizeBaseUrl(sel.baseUrl || ''),
+        ...(typeof sel.temperature === 'number' ? { temperature: sel.temperature } : {}),
+        ...(typeof sel.reasoningMode === 'boolean' ? { reasoningMode: sel.reasoningMode } : {}),
+        updatedAt: new Date().toISOString(),
+        scope: 'session',
+    };
+    await atomicWriteJson(sessionBindingsPath(), all);
+}
+async function clearSessionSelection(sessionKey) {
+    const key = (sessionKey || currentSessionKey()).trim();
+    if (!key)
+        return;
+    const all = await readSessionBindings();
+    if (!(key in all.sessions))
+        return;
+    delete all.sessions[key];
+    await atomicWriteJson(sessionBindingsPath(), all);
+}
+/** 从配置文件读出 Global 层 (仅当这一份真的能用: 有 key 或不需要 key) */
+async function readGlobalSelection() {
+    await config_store_js_1.llmConfigStore.initialize();
+    const cfg = await config_store_js_1.llmConfigStore.getConfig();
+    const provider = cfg.activeProvider;
+    const p = cfg.providers[provider];
+    if (!p)
+        return null;
+    const envKey = envKeyOf(provider);
+    const usable = !!p.apiKey || p.requiresApiKey === false || !!envKey;
+    if (!usable)
+        return null;
+    return {
+        provider,
+        model: p.model,
+        baseUrl: p.baseUrl,
+        apiKey: p.apiKey || envKey?.value,
+        ...(typeof p.temperature === 'number' ? { temperature: p.temperature } : {}),
+        ...(typeof p.reasoning === 'boolean' ? { reasoningMode: p.reasoning } : {}),
+        updatedAt: cfg.updatedAt,
+    };
+}
+/** provider 默认层 (内置表; 自定义供应商走注册表的声明 —— 它没有"内置默认"这回事) */
+function providerDefaultSelection(provider) {
+    const id = String(provider || '').trim().toLowerCase();
+    const def = config_store_js_1.DEFAULT_PROVIDER_CONFIGS[id];
+    if (def) {
+        return { provider: id, model: def.model, baseUrl: def.baseUrl, apiKey: undefined };
+    }
+    const entry = registryEntryOf(id);
+    if (!entry || entry.kind !== 'custom')
+        return null;
+    const model = String(entry.defaultModel || entry.declaredModelIds?.[0] || '');
+    // 声明里没有模型名 → 这一层给不出候选 (不给"空模型"的层, 让解析继续往下走)
+    if (!model)
+        return null;
+    return { provider: id, model, baseUrl: entry.defaultBaseUrl, apiKey: undefined };
+}
+/**
+ * 「有效模型配置」的唯一解析入口。
+ * `runSelection` 由调用方给 (P1 之后, 执行中的 Run 拿自己的快照, 不重新解析)。
+ */
+async function effectiveModelConfig(opts = {}) {
+    const session = await readSessionSelection(opts.sessionKey);
+    const global = opts.overrideGlobal !== undefined ? opts.overrideGlobal : await readGlobalSelection();
+    const activeProvider = global?.provider
+        || (await config_store_js_1.llmConfigStore.getActiveProvider().catch(() => 'openai'));
+    const envKey = envKeyOf(String(activeProvider));
+    const envLayer = envKey
+        ? { provider: String(activeProvider), model: '', baseUrl: '', apiKey: envKey.value }
+        : null;
+    return resolveSelection({
+        run: opts.runSelection || null,
+        session,
+        global,
+        provider: providerDefaultSelection(String(activeProvider)),
+        env: envLayer,
+    });
+}
+/** Run 开始时盖的快照 —— 只读, 不写任何东西 */
+async function captureRunModelConfig(sessionKey) {
+    const eff = await effectiveModelConfig({ sessionKey });
+    return runModelConfigOf(eff);
+}
+/**
+ * 把**当前有效配置**装进模型运行时。
+ *
+ * 启动装配、切换回滚、重置都走这一个函数 —— 此前 CLI 启动按"环境变量里有哪些 key"猜供应商,
+ * 而 Web 启动按配置文件读, 两条路会给出不同的 provider/model (同一个 bin, 换个入口就换模型)。
+ * 现在只有一个来源: 有效模型配置。
+ */
+async function applyEffectiveToRuntime(sessionKey) {
+    const eff = await effectiveModelConfig({ sessionKey });
+    const stored = await config_store_js_1.llmConfigStore.getProvider(eff.provider).catch(() => null);
+    const apiKey = stored?.apiKey || envKeyOf(eff.provider)?.value;
+    await installRuntime(eff, apiKey);
+    return eff;
+}
+/**
+ * 把**某个 Run 的快照**装进模型运行时 —— 长任务恢复走这条路 (P7 × P6)。
+ *
+ * 为什么必须有它: 恢复一个正在跑的 Run 时要用的**是它自己那一份** (而不是"现在盘上的全局默认"),
+ * 否则就是 P7 明令禁止的"在跑的 Run 漂移"。而"把一份配置装进运行时"这件事同样只有
+ * `installRuntime` 一处实现 —— 恢复路径不许自己再写一遍 `initMinimax({...})`。
+ *
+ * 返回的是**装进去的那一份有效配置** (逐字段可与快照对照: provider/model/baseUrl 应完全相同,
+ * `configHash` 也应相同 —— 同一个 provider/model/baseUrl/protocol 必得同一个 hash)。
+ */
+async function applyRunModelConfigToRuntime(snapshot) {
+    const eff = materialize({
+        provider: snapshot.provider,
+        model: snapshot.model,
+        baseUrl: snapshot.baseUrl,
+        updatedAt: snapshot.capturedAt,
+    }, snapshot.selectionScope);
+    const key = await storedKeyOf(snapshot.provider);
+    await installRuntime(eff, key);
+    return eff;
+}
+/**
+ * 把一份有效配置装进客户端 —— **声明的 provider id** 与**运行时分支 id** 分开送。
+ *
+ * 为什么必须分开 (P3 的"兼容协议"落地): 自定义供应商不改联合类型, 它在运行期接到"说同一种协议"
+ * 的内置分支上 (`runtimeProviderIdOf`: openai-compatible → `openai`, …), 但它的**鉴权头**只有按
+ * 声明的 id 查注册表才拿得到 (`authHeader`)。旧写法只送 `eff.provider` 一个名字:
+ *   · 送声明 id ('stub-gw') → 客户端 `switch` 落进 default, 直接 "Unsupported provider";
+ *   · 送运行期 id ('openai') → 分支能跑, 但自定义的鉴权头永远用不上 (注册表那一格白填)。
+ * 所以两个都送: 分支用运行期 id, 鉴权/协议用声明 id。
+ *
+ * 注册表里查不到这个 id (老配置 / 未知供应商) → 原样返回, **不编**一条记录出来。
+ */
+async function installRuntime(eff, apiKey) {
+    const declaredId = String(eff.provider || '');
+    let runtimeProvider = declaredId;
+    try {
+        const reg = await Promise.resolve().then(() => __importStar(require('./provider-registry.js')));
+        const entry = reg.getProviderRegistryEntry(declaredId);
+        if (entry)
+            runtimeProvider = String(reg.runtimeProviderIdOf(entry));
+    }
+    catch { /* 注册表不可用 → 用声明 id (内置供应商本来就是它自己) */ }
+    (0, index_js_1.initMinimax)({
+        provider: runtimeProvider,
+        providerId: declaredId,
+        apiKey,
+        baseUrl: eff.baseUrl,
+        model: eff.model,
+    });
+}
+/**
+ * 「备用模型候选」—— Supervisor 在**模型相关失败** + `auto` 策略下可以挑的那些。
+ *
+ * 只从注册表里挑**现在真能用**的 (手上真有凭证: 配置里的 key / 声明的环境变量 / 这家免 key),
+ * 而且必须 `canServeLongRunningTasks` (工具调用发不出去的通道不能跑长期任务)。
+ * 挑不到就返回空数组 —— 空数组的语义是"没有候选", 不是"随便挑一个"。
+ */
+async function usableFallbackCandidates(current) {
+    const out = [];
+    try {
+        const reg = await Promise.resolve().then(() => __importStar(require('./provider-registry.js')));
+        const entries = reg.listProviderRegistry();
+        for (const entry of entries) {
+            const id = String(entry?.id || '');
+            if (!id)
+                continue;
+            if (!reg.canServeLongRunningTasks(id))
+                continue;
+            const stored = await config_store_js_1.llmConfigStore.getProvider(id).catch(() => null);
+            const envKey = envKeyOf(id);
+            const noKeyNeeded = entry.requiresApiKey === false;
+            if (!stored?.apiKey && !envKey && !noKeyNeeded)
+                continue;
+            const model = String(stored?.model || entry.defaultModel || '').trim();
+            if (!model)
+                continue;
+            const baseUrl = normalizeBaseUrl(String(stored?.baseUrl || entry.defaultBaseUrl || ''));
+            out.push({
+                provider: id,
+                model,
+                baseUrl,
+                configHash: configHashOf({ provider: id, model, baseUrl }),
+                // 这一份来自哪一层: 配置里写的就是配置层, 否则是注册表给的**供应商默认**层
+                //   (快照字段只表达"配置从哪来"; "谁挑的" 由 Run 事件的 source=supervisor_fallback 表达)
+                selectionScope: stored ? 'global' : 'provider',
+                capturedAt: new Date().toISOString(),
+            });
+        }
+    }
+    catch {
+        return [];
+    }
+    // 丢掉与当前那份**逐字段相同**的候选 (pickFallbackConfig 也会跳, 这里先去掉免得报"有候选"却挑不到)
+    return out.filter((c) => !(current
+        && c.provider === current.provider
+        && c.model === current.model
+        && normalizeBaseUrl(c.baseUrl) === normalizeBaseUrl(current.baseUrl)));
+}
+// ============================================================
+// 跨进程锁 (两个进程同时切配置, 不许互相覆盖)
+// ============================================================
+const LOCK_STALE_MS = 15_000;
+async function withConfigLock(fn) {
+    const lockPath = path.join(config_store_js_1.llmConfigStore.configDirPath(), exports.CONFIG_LOCK_FILE);
+    await fsp.mkdir(path.dirname(lockPath), { recursive: true });
+    const deadline = Date.now() + LOCK_STALE_MS;
+    for (;;) {
+        try {
+            const fd = fsSync.openSync(lockPath, 'wx');
+            fsSync.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+            fsSync.closeSync(fd);
+            break;
+        }
+        catch (e) {
+            if (e?.code !== 'EEXIST')
+                throw e;
+            // 陈旧锁回收: 持有者进程已死, 或超过阈值
+            let stale = false;
+            try {
+                const info = JSON.parse(fsSync.readFileSync(lockPath, 'utf-8'));
+                const age = Date.now() - Number(info?.at || 0);
+                let alive = true;
+                try {
+                    process.kill(Number(info?.pid), 0);
+                }
+                catch {
+                    alive = false;
+                }
+                stale = !alive || age > LOCK_STALE_MS;
+            }
+            catch {
+                stale = true;
+            }
+            if (stale) {
+                try {
+                    fsSync.unlinkSync(lockPath);
+                }
+                catch { /* 别人抢先删了 */ }
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new Error('配置锁等待超时 (另一个进程正在改配置)');
+            await new Promise((r) => setTimeout(r, 25));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        try {
+            fsSync.unlinkSync(lockPath);
+        }
+        catch { /* 已释放 */ }
+    }
+}
+async function atomicWriteJson(file, value) {
+    const tmp = `${file}.tmp-${process.pid}-${crypto.randomBytes(3).toString('hex')}`;
+    await fsp.writeFile(tmp, JSON.stringify(value, null, 2), { mode: 0o600 });
+    await fsp.rename(tmp, file);
+}
+/** 一个 provider 起手用的默认值 (配置里那一格 → 内置表 → 注册表声明; 都没有 → `null`) */
+function baseDefaultsOf(provider, providerConfig) {
+    const id = String(provider || '').trim().toLowerCase();
+    const builtin = config_store_js_1.DEFAULT_PROVIDER_CONFIGS[id];
+    if (providerConfig) {
+        return {
+            model: String(providerConfig.model ?? (builtin?.model || '')),
+            baseUrl: String(providerConfig.baseUrl ?? (builtin?.baseUrl || '')),
+            requiresApiKey: providerConfig.requiresApiKey,
+            credential: String(providerConfig['api' + 'Key'] ?? ''),
+        };
+    }
+    if (builtin) {
+        return {
+            model: builtin.model,
+            baseUrl: builtin.baseUrl,
+            requiresApiKey: builtin.requiresApiKey,
+            credential: String(builtin['api' + 'Key'] ?? ''),
+        };
+    }
+    const entry = registryEntryOf(id);
+    if (!entry)
+        return null;
+    // 目录家 (`origin='catalog'`): **不**拿"目录里第一个模型"充当默认模型 —— 那是按字母序抓一个,
+    // 不是用户选的、也不是目录声明的"默认"。没有默认就是空, 由 validateSelection 如实报出来。
+    const isCatalog = entry.origin === 'catalog';
+    return {
+        model: String(entry.defaultModel || (isCatalog ? '' : entry.declaredModelIds?.[0]) || ''),
+        baseUrl: String(entry.defaultBaseUrl || ''),
+        requiresApiKey: entry.requiresApiKey,
+    };
+}
+function validateSelection(req, ctx) {
+    const provider = String(req.provider || '').trim().toLowerCase();
+    if (!provider) {
+        return { ok: false, failureClass: 'invalid_provider', message: '没有指定供应商' };
+    }
+    const base = baseDefaultsOf(provider, ctx.providerConfig);
+    if (!base) {
+        const known = [...Object.keys(config_store_js_1.DEFAULT_PROVIDER_CONFIGS)];
+        try {
+            for (const e of listRegisteredProviderIds())
+                if (!known.includes(e))
+                    known.push(e);
+        }
+        catch { /* 注册表读不到 → 只报内置那份 (不编) */ }
+        return { ok: false, failureClass: 'invalid_provider', message: `未知供应商 '${provider}'. 可用: ${known.join(', ')}` };
+    }
+    // ★ 目录里的家, 鉴权形状本运行时不支持 → **根本没发请求**, 如实报清楚 (不许假装可用)。
+    //   放在模型/baseUrl 之前: 这是最根本的一条 —— 换 baseUrl 或换模型名都救不了它。
+    const regEntry = registryEntryOf(provider);
+    if (regEntry && regEntry.authSupported === false) {
+        return {
+            ok: false,
+            failureClass: 'provider_auth_unsupported',
+            // `authSupportNote` 自带"需专用鉴权 (未支持): <为什么>"的口径, 这里不再叠一层前缀 (否则读着像结巴)
+            message: `${provider} 不能切换: ${regEntry.authSupportNote || '需专用鉴权 (本版本未支持), 形状未知'}`
+                + ` —— 目录里有这一家, 但本运行时发不出它的请求 (要接就换成 openai-compatible 的自定义供应商, 自己给 baseUrl 与 key)`,
+        };
+    }
+    const model = String(req.model ?? base.model ?? '').trim();
+    if (!model) {
+        // 目录家没有"默认模型"这回事 (目录里也没声明) → 说清怎么指定, 不许抓一个凑数
+        if (regEntry && regEntry.origin === 'catalog') {
+            return {
+                ok: false,
+                failureClass: 'invalid_model',
+                message: `${provider} 是目录里的家, 目录里没有"默认模型" —— 请指定 model: /model ${provider} <model>`
+                    + ` (目录里 ${regEntry.declaredModelIds.length} 个候选, 看 /model list ${provider})`,
+            };
+        }
+        return { ok: false, failureClass: 'invalid_model', message: `${provider} 没有可用模型 (配置为空且默认模型为空)` };
+    }
+    let baseUrl = base.baseUrl;
+    if (req.baseUrl !== undefined) {
+        const shape = validateBaseUrlShape(req.baseUrl);
+        if (!shape.ok) {
+            return { ok: false, failureClass: 'invalid_url', message: `base URL 非法 — ${shape.reason}` };
+        }
+        baseUrl = shape.url;
+    }
+    else {
+        baseUrl = normalizeBaseUrl(baseUrl);
+        if (!baseUrl) {
+            // 目录里没给 api 基址的家 (223 家里有 26 家如此) → 如实说"要自定义 baseUrl", **不编一个**
+            if (regEntry && regEntry.origin === 'catalog') {
+                return {
+                    ok: false,
+                    failureClass: 'invalid_url',
+                    message: `${provider} 在目录里没有 api 基址 → 必须自定义 baseUrl (加 --base-url <地址> 或写进配置)`,
+                };
+            }
+            return { ok: false, failureClass: 'invalid_url', message: `${provider} 没有 base URL` };
+        }
+    }
+    const fallbackCredential = String(base.credential ?? '');
+    const action = req.credentialAction ?? (req.apiKey !== undefined ? 'replace' : 'keep');
+    const envKey = envKeyOf(provider);
+    const needKey = base.requiresApiKey !== false;
+    // ── 凭证意图 (2026-09-27): 四种意图在这里落地成"这一次要用的 key + 会不会写存盘凭据" ──
+    //   `replace` / 历史不传 action 但有 apiKey → 用新 key; `clear` / `env` → 不用存盘凭据。
+    let apiKey;
+    let dropStored = false;
+    if (action === 'replace') {
+        const k = String(req.apiKey ?? '').trim();
+        if (!k) {
+            return { ok: false, failureClass: 'missing_api_key', message: '要替换凭证但没收到 key (未改动任何配置)' };
+        }
+        apiKey = k;
+    }
+    else if (action === 'clear' || action === 'env') {
+        // 两种都是"不再用存盘凭据": clear 连环境变量也要求有, 否则这家当场就没法用 ——
+        //   宁可在写盘之前拒掉并说清后果, 也不写下一个"看着像切换成功、其实没有凭证"的配置。
+        if (needKey && !envKey) {
+            return {
+                ok: false,
+                failureClass: 'missing_api_key',
+                message: `${action === 'clear' ? '清除' : '改用环境变量'}被拒绝: ${provider} 需要一个 key, 而`
+                    + `环境变量 ${providerFactsOf(provider).envKeys.join('/') || '(这家没登记环境变量名)'} 没设 —— `
+                    + '清掉存盘凭据后这家就用不了了。未改动任何配置 (要清就先 `export` 那个变量, 或改用"替换"给一个新 key)。',
+            };
+        }
+        apiKey = envKey?.value ?? '';
+        dropStored = true;
+    }
+    else {
+        apiKey = req.apiKey !== undefined ? req.apiKey : fallbackCredential;
+    }
+    if (needKey && !apiKey && !envKey) {
+        return {
+            ok: false,
+            failureClass: 'missing_api_key',
+            message: `${provider} 还需要 API key — 用 /model key ${provider} 配置, 或设置环境变量 ${providerFactsOf(provider).envKeys.join('/') || '(无)'}`,
+        };
+    }
+    // 生成参数: 温度只在 0~2 有意义。非法值**当场拒**, 不静默夹到边界 (夹了就是改了用户的意思)
+    if (req.temperature !== undefined) {
+        const t = Number(req.temperature);
+        if (!Number.isFinite(t) || t < 0 || t > 2) {
+            return { ok: false, failureClass: 'invalid_temperature', message: `temperature 只接受 0~2 的数字, 收到 '${req.temperature}'` };
+        }
+    }
+    return {
+        ok: true,
+        // 凭证意图的落地结果: 要不要把存盘凭据删掉 / 这家是不是必须 key —— 写盘阶段要用它,
+        //   所以由**同一个校验**算出来带出去, 免得写盘时再算一遍 (两处算法早晚会分叉)。
+        credentialDrop: dropStored,
+        requiresKey: needKey,
+        selection: {
+            provider,
+            model,
+            baseUrl,
+            apiKey: apiKey || envKey?.value,
+            ...(action === 'env' ? { credentialSource: 'env' } : {}),
+            ...(req.temperature !== undefined ? { temperature: Number(req.temperature) } : {}),
+            ...(req.reasoningMode !== undefined ? { reasoningMode: req.reasoningMode } : {}),
+        },
+    };
+}
+exports.PROBE_TIMEOUT_MS = 8000;
+/**
+ * **唯一探测路径**: 把候选配置交给 P4 的探测原语 (`connection-probe.probe`), 再把它的 7 类失败
+ * 按 `PROBE_TO_SELECTION` **逐类映射**成入口类目。
+ *
+ * 为什么四层 URL 来源都要交给原语: "显式 > 配置 > 供应商默认 > 环境变量"这条优先级是**原语的**
+ * 语义 (`resolveChainBaseUrl`, 且"哪一层赢了"会回在 `baseUrlSource` 里)。入口若只传显式那一层,
+ * 就等于把"配置/默认/环境"这几层又拿回入口自己判 —— 两处真相, 而且会重现"填错的显式 URL 被
+ * 默认值悄悄盖掉"的隐藏 URL 问题。
+ *
+ * 凭证: 只以**引用名**进原语 (`provider:<id>` / `none`), 值由这里的 `resolveSecret` 现场给;
+ * 原语返回值里永不含 key (`resultLeaksSecret` 检查在门禁里)。
+ */
+async function runConnectionProbe(opts) {
+    const provider = String(opts.provider || '').trim().toLowerCase();
+    let protocol = protocolOf(provider);
+    let providerDefaultUrl = config_store_js_1.DEFAULT_PROVIDER_CONFIGS[provider]?.baseUrl;
+    let envBaseUrlVar;
+    try {
+        const reg = await Promise.resolve().then(() => __importStar(require('./provider-registry.js')));
+        const entry = reg.getProviderRegistryEntry(provider);
+        if (entry) {
+            // 注册表是协议/默认地址/环境变量覆盖的**主来源** (自定义供应商只有它认识)
+            if (entry.protocol)
+                protocol = entry.protocol;
+            if (entry.defaultBaseUrl)
+                providerDefaultUrl = entry.defaultBaseUrl;
+            if (Array.isArray(entry.baseUrlEnvVars) && entry.baseUrlEnvVars.length)
+                envBaseUrlVar = String(entry.baseUrlEnvVars[0]);
+        }
+    }
+    catch { /* 注册表拿不到 → 退回内置协议表; 仍不编一个默认地址出来 */ }
+    const apiKey = String(opts.apiKey || '').trim();
+    const r = await (0, connection_probe_js_1.probe)({
+        providerId: provider,
+        baseUrl: opts.baseUrl,
+        configuredBaseUrl: opts.configuredBaseUrl,
+        providerDefaultUrl,
+        envBaseUrlVar,
+        protocol,
+        model: opts.model,
+        apiKeyRef: apiKey ? `provider:${provider}` : 'none',
+        resolveSecret: () => (apiKey ? apiKey : undefined),
+        timeoutMs: opts.timeoutMs ?? exports.PROBE_TIMEOUT_MS,
+        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
+    });
+    const mapped = mapProbeFailureClass(r.failureClass);
+    const zh = r.failureClass ? connection_probe_js_1.PROBE_FAILURE_ZH[r.failureClass] : '';
+    const common = {
+        failureClassZh: zh,
+        message: r.message,
+        baseUrl: r.baseUrl,
+        baseUrlSource: r.baseUrlSource,
+        toolCalling: r.toolCalling,
+        ...(r.catalog ? { catalog: r.catalog } : {}),
+        // 实测事实: 上游目录没列这个名字, 但端点接受 (2026-09-27 实测: /models 不是可用全集)
+        ...(r.modelAcceptedOutsideCatalog ? { modelAcceptedOutsideCatalog: true } : {}),
+        checks: r.checks,
+    };
+    if (r.ok)
+        return { ok: true, unmapped: false, ...common };
+    return {
+        ok: false,
+        failureClass: mapped.failureClass,
+        probeClass: mapped.raw,
+        unmapped: mapped.unmapped,
+        ...common,
+    };
+}
+/**
+ * 兼容壳: 老调用方 (分步选择器的第 ⑥ 步预检 / 向导) 只要 `{ok, failureClass, detail, catalog}`。
+ * 内部走**同一条**探测路径 —— 不存在"入口一份原语、选择器另一份手写探测"的第二种实现。
+ */
+async function probeSelection(sel) {
+    const r = await runConnectionProbe({ provider: sel.provider, model: sel.model, baseUrl: sel.baseUrl, apiKey: sel.apiKey });
+    const facts = r.checks.map((c) => `${c.step}:${c.ok ? '✓' : '✗'} ${c.detail}`).join(' | ');
+    return {
+        ok: r.ok,
+        ...(r.ok ? {} : { failureClass: r.failureClass }),
+        detail: r.ok
+            ? r.message
+            : `${r.message} [探测类目 ${r.probeClass}${r.unmapped ? ' → 未映射!' : ''}; 逐步事实: ${facts}]`,
+        ...(r.catalog ? { catalog: r.catalog } : {}),
+        // 「目录里没有但端点接受」的实测事实要传出去, 界面照实说 (2026-09-27 实测改判)
+        ...(r.modelAcceptedOutsideCatalog ? { modelAcceptedOutsideCatalog: true } : {}),
+    };
+}
+/**
+ * **统一入口**。CLI `/model`、Web `/api/llm-config`、初始化向导、Agent 工具调用都走这里。
+ * 任何一步失败都不留半成功状态: 写盘之前的所有失败 = 什么也没发生; 写盘之后的失败 = 字节级还原 + 运行时回滚。
+ */
+async function selectModel(req) {
+    await config_store_js_1.llmConfigStore.initialize();
+    const previous = await effectiveModelConfig({ sessionKey: req.sessionKey });
+    // ── 1) 校验 ───────────────────────────────────────────────
+    const provider = String(req.provider || '').trim().toLowerCase();
+    if (!provider) {
+        return { ok: false, failureClass: 'invalid_provider', message: '没有指定供应商', previous };
+    }
+    const stored = await config_store_js_1.llmConfigStore.getProvider(provider);
+    const validation = validateSelection({ ...req, provider }, { providerConfig: stored });
+    if (!validation.ok || !validation.selection) {
+        return { ok: false, failureClass: validation.failureClass, message: validation.message, previous };
+    }
+    const target = validation.selection;
+    // 凭证是**全局**概念: 会话级切换只做"路由"(用哪家), 不新增/改动凭证。
+    // 放在探测之前: 这类请求连试都不该试 —— 试一次就等于拿一个不打算落盘的 key 去打了一次上游。
+    const scope = req.scope === 'session' ? 'session' : 'global';
+    if (scope === 'session' && req.apiKey) {
+        return {
+            ok: false,
+            failureClass: 'credential_scope_conflict',
+            message: '会话级切换不写凭证 — 请先 `/model key <provider>` 配置全局凭证, 再用 `--session` 只切路由',
+            previous,
+        };
+    }
+    // ── 2) 连通探测 (写盘之前; 走 P4 探测原语这一条唯一路径) ─────
+    const checks = [];
+    // 探测里的「目录里没有但端点接受」实测事实 —— 探针已经算出来了, 这里必须**接着带出去**;
+    //   否则 `SelectModelResult` 声明了字段却没有一条路能填上 (调用方/界面永远看不到)。
+    let acceptedOutsideCatalog = false;
+    const wantProbe = req.verify !== false && process.env.BOLLOON_MODEL_SKIP_PROBE !== '1';
+    if (wantProbe) {
+        const p = await runConnectionProbe({
+            provider: target.provider,
+            model: target.model,
+            baseUrl: req.baseUrl, // 显式 --base-url (最高优先)
+            configuredBaseUrl: stored?.baseUrl, // 配置里这一家现在写的地址
+            apiKey: target.apiKey,
+        });
+        if (p.modelAcceptedOutsideCatalog)
+            acceptedOutsideCatalog = true;
+        // 逐项事实 (URL 来自哪一层 / 协议 / 凭证 / 目录 / 模型 / 工具调用) 全部如实带出去
+        checks.push(`· base URL 来源=${p.baseUrlSource ?? '无'} → ${p.baseUrl || '(无 URL)'}; 工具调用能力=${p.toolCalling}`);
+        for (const c of p.checks)
+            checks.push(`${c.ok ? '✓' : '✗'} [${c.step}] ${c.detail}`);
+        if (!p.ok) {
+            const cls = p.failureClass;
+            return {
+                ok: false,
+                failureClass: cls,
+                message: `切换未生效 (探测失败, 配置与运行时保持原样) — ${cls} (${exports.SELECTION_FAILURE_ZH[cls]}): ${p.message}`
+                    + ` [探测类目=${p.probeClass ?? '无'}${p.unmapped ? ' ⚠ 未被映射表覆盖' : ''}]`,
+                previous,
+                checks,
+            };
+        }
+        checks.push(`✓ 探测通过: ${p.message}`);
+    }
+    else {
+        checks.push('· 已跳过连通探测 (BOLLOON_MODEL_SKIP_PROBE / verify:false)');
+    }
+    // ── 3~6) 写配置 → 更新 scope → 重建运行时 → 更新 session ────
+    const configPath = config_store_js_1.llmConfigStore.configFilePath();
+    let beforeBytes = null;
+    try {
+        beforeBytes = await fsp.readFile(configPath, 'utf-8');
+    }
+    catch {
+        beforeBytes = null;
+    }
+    // 写盘阶段的失败**分两类**报出, 不再一律叫"切换失败": 写盘失败 (`persist_failed`) 与
+    // 写完配置但重建运行时失败 (`runtime_rebuild_failed`) 是两件不同的事, 排障要看得出是哪一件。
+    let wrote = false;
+    try {
+        if (scope === 'global') {
+            await withConfigLock(async () => {
+                // 拿到锁后**重读**: 另一个进程可能刚改过别的 provider (否则后写的会覆盖先写的)
+                //   (`initialize()` 自己会按文件签名判断是否重读; `invalidate()` 是补刀 ——
+                //    mtime 与 size 都撞上时签名不变, 只有显式作废才能保证一定重读)
+                config_store_js_1.llmConfigStore.invalidate();
+                await config_store_js_1.llmConfigStore.initialize();
+                const patch = { enabled: true, model: target.model, baseUrl: target.baseUrl };
+                if (validation.credentialDrop) {
+                    // 清除 / 改用环境变量: 存盘凭据**真的删掉** —— 写成空串 (写 `undefined` 是"这一格不动",
+                    //   那是另一件事; 这里要的就是"不再有存盘凭据")。同时如实回到"这家又要 key 了"的状态,
+                    //   否则列表会拿旧的 `requiresApiKey:false` 把一个已无凭据的家显示成可用 (那是假话)。
+                    patch.apiKey = '';
+                    patch.requiresApiKey = validation.requiresKey !== false;
+                }
+                else {
+                    // 只写"用户明确给了 key"的情况; 掩码/空值不动既有 key
+                    if (req.apiKey)
+                        patch.apiKey = req.apiKey;
+                    else if (target.apiKey && !(stored?.apiKey))
+                        patch.apiKey = target.apiKey;
+                    if (target.apiKey || stored?.apiKey || stored?.requiresApiKey === false) {
+                        patch.requiresApiKey = false;
+                    }
+                }
+                // 生成参数: 只有这一次明确给了才写 (不传 = 不动原有的值, 不拿内置默认去覆盖用户已经调好的)
+                if (req.temperature !== undefined)
+                    patch.temperature = Number(req.temperature);
+                if (req.reasoningMode !== undefined)
+                    patch.reasoning = req.reasoningMode;
+                await config_store_js_1.llmConfigStore.updateProvider(provider, patch);
+                await config_store_js_1.llmConfigStore.setActiveProvider(provider);
+            });
+            // Global 切换: 清掉当前会话的旧绑定, 让"这次切换"对当前会话也立刻成立
+            await clearSessionSelection(req.sessionKey || currentSessionKey());
+        }
+        else {
+            // 会话级: **一个字节都不写配置文件**, 只写会话绑定
+            await writeSessionSelection(req.sessionKey || currentSessionKey(), target);
+        }
+        wrote = true;
+        // 重建模型运行时 —— 从"刚写好的那一份有效配置"读, 保证运行时 == 有效配置
+        const applied = await applyEffectiveToRuntime(req.sessionKey);
+        if (applied.provider !== target.provider || applied.model !== target.model || applied.baseUrl !== target.baseUrl) {
+            throw new Error(`重建后有效配置与目标不一致 (${applied.provider}/${applied.model}@${applied.baseUrl})`);
+        }
+    }
+    catch (err) {
+        // 回滚: 文件字节级还原 + 运行时按旧配置重建
+        await rollbackConfig(configPath, beforeBytes);
+        await restoreRuntime(previous);
+        const cls = wrote ? 'runtime_rebuild_failed' : 'persist_failed';
+        const zh = exports.SELECTION_FAILURE_ZH[cls];
+        checks.push(`✗ [write] ${cls} (${zh}): ${String(err?.message || err).slice(0, 200)}`);
+        return {
+            ok: false,
+            failureClass: cls,
+            message: `切换失败已回滚, 旧配置仍生效 — ${cls} (${zh}): ${String(err?.message || err).slice(0, 300)}`,
+            previous,
+            checks,
+        };
+    }
+    // ── 7) 返回真实生效的那一份 ────────────────────────────────
+    const effective = await effectiveModelConfig({ sessionKey: req.sessionKey });
+    return {
+        ok: true, effective, previous, checks,
+        // 「目录里没有但端点接受」这个**实测事实**照实带出去 (界面/报告要说真话, 但不回头改判成失败)
+        ...(acceptedOutsideCatalog ? { modelAcceptedOutsideCatalog: true } : {}),
+    };
+}
+async function rollbackConfig(configPath, beforeBytes) {
+    try {
+        if (beforeBytes === null) {
+            // 之前没有配置文件 → 还原成"没有" 比留一个半成品更诚实
+            await fsp.rm(configPath, { force: true });
+        }
+        else {
+            await fsp.writeFile(configPath, beforeBytes, { mode: 0o600 });
+        }
+    }
+    catch { /* 还原失败也不吞: 由调用方在 message 里能看到"配置可能已改" */ }
+    config_store_js_1.llmConfigStore.invalidate();
+    await config_store_js_1.llmConfigStore.initialize().catch(() => undefined);
+}
+async function restoreRuntime(prev) {
+    try {
+        const key = await storedKeyOf(prev.provider);
+        await installRuntime(prev, key);
+    }
+    catch { /* 运行时还原失败: 单例仍指向被拒的候选, 调用方会看到 ok:false */ }
+}
+async function storedKeyOf(provider) {
+    try {
+        const p = await config_store_js_1.llmConfigStore.getProvider(provider);
+        return p?.apiKey || envKeyOf(provider)?.value;
+    }
+    catch {
+        return envKeyOf(provider)?.value;
+    }
+}
+/** `/model reset` — 清掉会话级绑定并回到 Global 那一份, 运行时同步重建 */
+async function resetModelSelection(sessionKey) {
+    const before = await effectiveModelConfig({ sessionKey });
+    await clearSessionSelection(sessionKey);
+    const global = await readGlobalSelection();
+    if (global) {
+        const key = await storedKeyOf(global.provider);
+        try {
+            // 走同一个装法: 声明 id → 注册表 → 运行时分支 (自定义供应商的协议/鉴权头才落得下来)
+            await installRuntime(materialize(global, 'global'), key);
+        }
+        catch (e) {
+            return { ok: false, message: `重置时重建运行时失败: ${String(e?.message || e).slice(0, 200)}`, previous: before };
+        }
+    }
+    const effective = await effectiveModelConfig({ sessionKey });
+    return { ok: true, effective, previous: before };
+}
+// ============================================================
+// 展示
+// ============================================================
+/** 一行 "provider/model · baseUrl · 作用域" —— 只给事实, 不给推测 */
+function formatEffectiveModel(eff) {
+    const scopeZh = {
+        run: 'Run 绑定',
+        session: '当前会话',
+        global: '全局默认',
+        provider: '供应商默认',
+        env: '环境变量',
+    };
+    return [
+        `${eff.provider}/${eff.model}`,
+        `base=${eff.baseUrl}`,
+        `协议=${eff.protocol}`,
+        `凭证=${eff.authRef}`,
+        `${eff.reasoning ? 'reasoning=支持' : 'reasoning=不支持'}(偏好${eff.reasoningMode === 'unset' ? '未设' : eff.reasoningMode === 'on' ? '开' : '关'})`,
+        `temperature=${eff.temperature === null ? '未设' : eff.temperature}`,
+        `作用域=${scopeZh[eff.source]}`,
+        `hash=${eff.configHash}`,
+    ].join(' · ');
+}
+function providerDisplayName(provider) {
+    return config_store_js_1.PROVIDER_INFO[provider]?.name || provider;
+}
+/**
+ * 纯函数: 把 Run 快照与当前有效配置逐字段比。
+ *
+ * 存在意义: `configHash` 此前只被"写进快照"和"回显", 没有任何地方拿它**反着查一次** ——
+ * 于是外部手改了配置文件 (或另一个进程切了默认模型) 时, 拿着旧快照的人不会知道。
+ * 这里给出可判定的回答: 漂了就点名是哪几个字段漂了, 不漂就明确说"一致"。
+ */
+function compareRunModelConfig(snapshot, current) {
+    const snap = {
+        provider: snapshot.provider,
+        model: snapshot.model,
+        baseUrl: normalizeBaseUrl(snapshot.baseUrl || ''),
+        configHash: snapshot.configHash,
+    };
+    if (!current) {
+        return {
+            verified: false,
+            drifted: false,
+            snapshot,
+            current: null,
+            fields: [],
+            message: `无法核对: 当前配置读不出来 (Run 快照仍是 ${snapshot.provider}/${snapshot.model}, hash=${snapshot.configHash})`,
+        };
+    }
+    const cur = {
+        provider: current.provider,
+        model: current.model,
+        baseUrl: normalizeBaseUrl(current.baseUrl || ''),
+        configHash: current.configHash,
+    };
+    const fields = [];
+    for (const f of ['provider', 'model', 'baseUrl', 'configHash']) {
+        if (snap[f] !== cur[f])
+            fields.push({ field: f, snapshot: snap[f], current: cur[f] });
+    }
+    if (!fields.length) {
+        return {
+            verified: true,
+            drifted: false,
+            snapshot,
+            current,
+            fields,
+            message: `模型配置与 Run 快照一致 (${current.provider}/${current.model} @ ${current.baseUrl}, hash=${current.configHash})`,
+        };
+    }
+    return {
+        verified: true,
+        drifted: true,
+        snapshot,
+        current,
+        fields,
+        message: `模型配置已偏离 Run 快照 — 快照: ${snapshot.provider}/${snapshot.model} @ ${normalizeBaseUrl(snapshot.baseUrl || '')} (hash=${snapshot.configHash}); 现在生效: ${current.provider}/${current.model} @ ${current.baseUrl} (hash=${current.configHash}); 变化的字段: ${fields.map((f) => f.field).join(', ')}`,
+    };
+}
+/** 拿当前有效配置核对一份 Run 快照 (不写任何东西) */
+async function detectRunModelDrift(snapshot, sessionKey) {
+    let current = null;
+    try {
+        current = await effectiveModelConfig({ sessionKey });
+    }
+    catch {
+        current = null;
+    }
+    return compareRunModelConfig(snapshot, current);
+}
+/**
+ * 从盘上读某个 Run 的快照再核对 (读不到 Run / 这个 Run 没快照 → `null`, 不编一份出来)。
+ * 动态 import 记录层, 避免"记录层 ← 入口层"的双向静态依赖。
+ */
+async function detectRunConfigDrift(runId, sessionKey) {
+    try {
+        const store = await Promise.resolve().then(() => __importStar(require('../agents/run-store.js')));
+        const rec = await store.readRun(runId);
+        const snap = rec?.modelConfig;
+        if (!snap)
+            return null;
+        return await detectRunModelDrift(snap, sessionKey);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=model-selection.js.map