mocode-ai 1.6.4 → 1.6.6

package/dist/llm/reasoning.js

@@ -0,0 +1,141 @@
+/**
+ * Reasoning Effort 适配层(#token-efficiency P3)。
+ *
+ * 用户只面对归一化五档 `off | low | medium | high | auto`,本模块按 provider +
+ * 模型名模式匹配,翻译成各家方言字段:
+ * - Anthropic 4.6+:`output_config.effort` + `thinking:{type:'adaptive'}`(新)
+ * - Anthropic 旧版:`thinking:{type:'enabled', budget_tokens:N}`(budget 严格小于 max_tokens)
+ * - OpenAI o 系 / gpt-5:`reasoning_effort`
+ * - Qwen3(vLLM/OpenAI 兼容):`enable_thinking` + `thinking_budget`
+ * - GLM-4.5/4.6/5:`thinking:{type:'enabled'|'disabled'}`
+ *
+ * 白名单驱动:未匹配到已知族的模型一律返回 {} —— 第三方中转可能因严格 schema
+ * 校验对未知字段直接 400,不下发是唯一在所有后端都安全的策略。
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { paramsFromCatalog } from '../models/reasoning-cap.js';
+/**
+ * Skill 激活期 effort scope(P3 §4.8):嵌套异步树(含子 agent)自动继承。
+ * 取值优先级:显式 per-request overrides 参数 > 本 scope > 会话级 getActiveEffort()。
+ * 刻意低于显式参数 —— compact/reflect 显式传 low 不被 skill effort 改写。
+ */
+const effortScope = new AsyncLocalStorage();
+export function getScopedEffort() {
+    return effortScope.getStore();
+}
+/** 在 skill effort scope 内执行 fn;effort=auto 等同于不包。 */
+export function runWithEffortScope(effort, fn) {
+    if (effort === 'auto')
+        return fn();
+    return effortScope.run(effort, fn);
+}
+const EFFORTS = ['off', 'low', 'medium', 'high', 'auto'];
+/** 解析外部输入(env / 命令行);非法值返回 undefined(调用方决定回落策略)。 */
+export function parseReasoningEffort(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    let v = value.trim();
+    if (v.length >= 2 && (v[0] === '"' || v[0] === "'") && v[v.length - 1] === v[0])
+        v = v.slice(1, -1);
+    v = v.trim().toLowerCase();
+    return EFFORTS.includes(v) ? v : undefined;
+}
+/** 各档对应的思考预算(token):Anthropic budget_tokens / Qwen thinking_budget。 */
+const THINK_BUDGET = {
+    low: 1024,
+    medium: 4096,
+    high: 10240,
+};
+/** Anthropic:为正文预留的最小 token;budget = min(raw, maxTokens - RESERVED)。 */
+const ANTHROPIC_OUTPUT_RESERVED = 1024;
+const ANTHROPIC_DEFAULT_MAX = 8192;
+/**
+ * 目标模型是否识别 reasoning 参数(白名单命中)。
+ * 供 /model show 给出「参数不会下发」提示,避免用户设了 high 却静默无效。
+ */
+export function recognizesReasoning(target) {
+    // 目录来源显式声明了思考能力 → 直接采纳(含声明 false 时不识别)。
+    if (target.catalogProviderId && typeof target.catalogReasoning === 'boolean') {
+        return target.catalogReasoning;
+    }
+    if (target.provider === 'anthropic')
+        return true;
+    const m = target.model.toLowerCase();
+    return (/\bo[134]\b/.test(m) ||
+        /gpt-?5/.test(m) ||
+        /qwen[-_]?3/.test(m) ||
+        /deepseek[-_]?r1/.test(m) ||
+        /glm[-_]?4[.-]?[56]/.test(m) ||
+        /glm[-_]?5/.test(m) ||
+        /doubao[-_]?seed/.test(m));
+}
+/**
+ * 归一化 effort + 目标 → 要 merge 进请求体的字段(空对象 = 不下发)。纯函数。
+ */
+export function resolveReasoningParams(effort, target) {
+    if (effort === 'auto')
+        return {};
+    // 目录优先:带 catalogProviderId 时按目录能力+厂商方言产出。
+    // 注意 anthropic 路径的思考在 anthropic provider 内仍走它自己的 target.provider,
+    // 目录只对 OpenAI 兼容路径有意义;Anthropic 官方协议继续走下方既有分支。
+    if (target.catalogProviderId && target.provider !== 'anthropic') {
+        const fromCatalog = paramsFromCatalog({
+            effort,
+            catalogProviderId: target.catalogProviderId,
+            reasoningOptions: target.catalogReasoningOptions,
+            maxTokens: target.maxTokens,
+        });
+        // 目录能产出非空字段就用;方言未知/返 {} 则落到正则兜底(而不是直接放弃)。
+        if (Object.keys(fromCatalog).length > 0)
+            return fromCatalog;
+    }
+    if (target.provider === 'anthropic') {
+        const m = target.model.toLowerCase();
+        // 仅认显式分隔的版本号 4-6/4.6/4_6/4-10…;宽松写法会误匹配名字里的日期(…20241022 中的 410)。
+        const is46Plus = /4[.\-_](?:[6-9]|[1-9]\d)(?!\d)/.test(m);
+        if (is46Plus) {
+            if (effort === 'off')
+                return { thinking: { type: 'disabled' } };
+            return { output_config: { effort }, thinking: { type: 'adaptive' } };
+        }
+        if (effort === 'off')
+            return {};
+        // 旧版:budget 必须严格小于 max_tokens,clamp 后非正 → 无法启用,不下发。
+        const maxTokens = target.maxTokens ?? ANTHROPIC_DEFAULT_MAX;
+        const budget = Math.min(THINK_BUDGET[effort], maxTokens - ANTHROPIC_OUTPUT_RESERVED);
+        if (budget <= 0)
+            return {};
+        return { thinking: { type: 'enabled', budget_tokens: budget } };
+    }
+    // ── OpenAI 兼容路径 ──
+    const m = target.model.toLowerCase();
+    // Qwen3(先于通用规则:名字里不含冲突模式,但显式更清晰)。
+    if (/qwen[-_]?3/.test(m)) {
+        if (effort === 'off')
+            return { enable_thinking: false };
+        return { enable_thinking: true, thinking_budget: THINK_BUDGET[effort] };
+    }
+    // GLM-4.5/4.6/5。
+    if (/glm[-_]?4[.-]?[56]/.test(m) || /glm[-_]?5/.test(m)) {
+        if (effort === 'off')
+            return { thinking: { type: 'disabled' } };
+        return { thinking: { type: 'enabled' } };
+    }
+    // 豆包 Seed(火山 Ark):思考是开关式,无 low/medium/high 预算档——非 off 即启用。
+    if (/doubao[-_]?seed/.test(m)) {
+        if (effort === 'off')
+            return { thinking: { type: 'disabled' } };
+        return { thinking: { type: 'enabled' } };
+    }
+    // DeepSeek-R1:无开关参数,任何档位都不下发。
+    if (/deepseek[-_]?r1/.test(m))
+        return {};
+    // OpenAI o1/o3/o4 + gpt-5:off 无法真关,官方最低档 low。
+    if (/\bo[134]\b/.test(m) || /gpt-?5/.test(m)) {
+        if (effort === 'off')
+            return { reasoning_effort: 'low' };
+        return { reasoning_effort: effort };
+    }
+    // 未知模型/第三方网关:白名单策略,不下发。
+    return {};
+}

package/dist/memory/reflect.js

@@ -147,7 +147,7 @@ export async function runReflection(transcript, signal) {
     };
     let content = null;
     try {
-        const r = await chat([sys, user], {}, signal ?? AbortSignal.timeout(60000));
+        const r = await chat([sys, user], {}, signal ?? AbortSignal.timeout(60000), undefined, { reasoningEffort: 'low' });
         // 推理模型偶发只返 reasoning_content(content null)或幻觉 tool_calls → 视为无产出
         if (!r.toolCalls.length && r.content)
             content = r.content;

package/dist/memory/store.js

@@ -12,6 +12,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from '
 import os from 'node:os';
 import path from 'node:path';
 import { MAX_ACTIVE, MAX_INDEX_ENTRIES, MAX_MEMORY_ENTRY, DECAY_DAYS, GC_DAYS } from '../tools/constants.js';
+import { TextSearchIndex } from '../context/text-search.js';
 // ── 路径 ──────────────────────────────────────────────────────────────────
 function globalPath() {
     return path.join(os.homedir(), '.mocode', 'memory.jsonl');
@@ -139,57 +140,59 @@ export function saveEntry(input) {
     writeAtomic(p, fileEntries);
     return { ok: true, id };
 }
-function scoreEntry(e, terms) {
-    if (terms.length === 0)
-        return 1; // 无关键词:全命中(取前 limit)
-    const id = e.id.toLowerCase();
-    const name = e.name.toLowerCase();
-    const summary = e.summary.toLowerCase();
-    const body = e.body.toLowerCase();
-    let s = 0;
-    for (const t of terms) {
-        if (id.includes(t))
-            s += 8; // 含 id 匹配:模型常按索引里的 id 取详情(slug 带连字符,名字带空格,不单独匹配 id 会漏)
-        if (name.includes(t))
-            s += 10;
-        if (summary.includes(t))
-            s += 5;
-        if (body.includes(t))
-            s += 1;
-    }
-    return s;
-}
-/** 关键词搜索:多词子串匹配(name 权重最高)。命中即 bump recallCount/lastRecalledAt 写回(遗忘衰减依据)。 */
+/**
+ * 关键词搜索:CJK 感知 BM25(共享 context/text-search),字段权重 name 10 > id 8 >
+ * summary 5 > body 1。命中即 bump recallCount/lastRecalledAt 写回(遗忘衰减依据)。
+ * 空查询:按旧行为返回前 limit 条(全命中)。
+ */
 export function searchEntries(query, opts = {}) {
     const all = loadAll();
     const status = opts.status ?? 'active';
     const pool = all
         .filter((e) => (status === 'any' ? true : e.status === status))
         .filter((e) => (opts.type ? e.type === opts.type : true));
-    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
-    const scored = pool.map((e) => ({ e, s: scoreEntry(e, terms) })).filter((x) => x.s > 0);
-    scored.sort((a, b) => b.s - a.s);
     const limit = Math.max(1, Math.min(opts.limit ?? 5, 20));
-    const top = scored.slice(0, limit);
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const top = [];
+    if (terms.length === 0) {
+        top.push(...pool.slice(0, limit));
+    }
+    else {
+        const index = new TextSearchIndex(pool.map((e) => ({
+            id: e.id,
+            fields: [
+                { text: e.name, weight: 10 },
+                { text: e.id, weight: 8 },
+                { text: e.summary, weight: 5 },
+                { text: e.body, weight: 1 },
+            ],
+        })));
+        const byId = new Map(pool.map((e) => [e.id, e]));
+        for (const hit of index.search(query, limit)) {
+            const e = byId.get(hit.id);
+            if (e)
+                top.push(e);
+        }
+    }
     if (top.length === 0)
         return [];
     // bump recall:只写有命中的 scope 文件
     const now = nowIso();
-    const hitIds = new Set(top.map((x) => x.e.id));
+    const hitIds = new Set(top.map((x) => x.id));
     for (const e of all) {
         if (hitIds.has(e.id)) {
             e.recallCount++;
             e.lastRecalledAt = now;
         }
     }
-    const hitScopes = new Set(top.map((x) => x.e.scope));
+    const hitScopes = new Set(top.map((x) => x.scope));
     for (const scope of hitScopes) {
         const p = pathForScope(scope);
         const entries = all.filter((e) => e.scope === scope);
         ensureDir(p);
         writeAtomic(p, entries);
     }
-    return top.map((x) => x.e);
+    return top;
 }
 /** 索引(无 body、不 bump recall)。 */
 export function listEntries(opts = {}) {

package/dist/models/budgets.js

@@ -0,0 +1,11 @@
+/**
+ * 各档思考预算（#model-catalog M3）。
+ *
+ * 独立小模块：reasoning.ts 与 reasoning-cap.ts 都要用，放在 models 下可避免
+ * reasoning-cap → reasoning 的反向依赖（reasoning 会 import reasoning-cap）。
+ */
+export const THINK_BUDGET_BY_EFFORT = {
+    low: 1024,
+    medium: 4096,
+    high: 10240,
+};

package/dist/models/catalog.js

@@ -0,0 +1,130 @@
+/**
+ * models.dev 目录的拉取 / ETag 协商 / 快照落盘 / 离线回退（#model-catalog M1）。
+ *
+ * 仅在用户显式命令时调用，不随启动或每轮联网。fetch 与快照路径均可注入，便于单测
+ * （不打真实 models.dev）。
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const CATALOG_URL = 'https://models.dev/api.json';
+export const CATALOG_SNAPSHOT_PATH = path.join(os.homedir(), '.mocode', 'catalog.json');
+/** 默认快照新鲜期（小时）；MOCODE_CATALOG_TTL_HOURS 可覆盖。 */
+export const DEFAULT_TTL_HOURS = 24;
+/** 拉取超时（毫秒）。 */
+export const FETCH_TIMEOUT_MS = 10_000;
+function ttlHours() {
+    const v = Number(process.env.MOCODE_CATALOG_TTL_HOURS);
+    return Number.isFinite(v) && v > 0 ? v : DEFAULT_TTL_HOURS;
+}
+/** 读本地快照；不存在/损坏返回 null。路径可注入（测试用临时 HOME）。 */
+export function readSnapshot(snapshotPath = CATALOG_SNAPSHOT_PATH) {
+    try {
+        const obj = JSON.parse(fs.readFileSync(snapshotPath, 'utf8'));
+        if (!obj.providers || typeof obj.providers !== 'object')
+            return null;
+        return obj;
+    }
+    catch {
+        return null;
+    }
+}
+/** 写快照（原子：tmp + rename）。 */
+export function writeSnapshot(snapshot, snapshotPath = CATALOG_SNAPSHOT_PATH) {
+    fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+    const tmp = `${snapshotPath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, JSON.stringify(snapshot), 'utf8');
+    fs.renameSync(tmp, snapshotPath);
+}
+/** 快照是否仍在 TTL 内。 */
+export function isFresh(snapshot, now = new Date()) {
+    const fetched = Date.parse(snapshot.fetchedAt);
+    if (!Number.isFinite(fetched))
+        return false;
+    return now.getTime() - fetched < ttlHours() * 3600 * 1000;
+}
+function fetchWithTimeout(fetchImpl, init) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS);
+    return fetchImpl(CATALOG_URL, { ...init, signal: ac.signal }).finally(() => clearTimeout(timer));
+}
+function emptyCatalog(source, snapshot) {
+    return {
+        providers: snapshot?.providers ?? {},
+        source,
+        fetchedAt: snapshot?.fetchedAt,
+        etag: snapshot?.etag,
+    };
+}
+/**
+ * 强制拉取最新目录。
+ * - 200：解析 + 落盘，source='live'
+ * - 304：复用本地快照（仅刷新 fetchedAt/etag 不强制），source='cache'
+ * - 网络/解析失败：有快照回退快照(source='cache')，否则 source='empty'
+ */
+export async function refreshCatalog(opts = {}) {
+    const fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    const snapshotPath = opts.snapshotPath ?? CATALOG_SNAPSHOT_PATH;
+    const cached = readSnapshot(snapshotPath);
+    let res;
+    try {
+        const headers = { Accept: 'application/json' };
+        if (cached?.etag)
+            headers['If-None-Match'] = cached.etag;
+        res = await fetchWithTimeout(fetchImpl, { headers });
+    }
+    catch {
+        return cached ? emptyCatalog('cache', cached) : emptyCatalog('empty');
+    }
+    if (res.status === 304 && cached) {
+        // 内容未变：更新 fetchedAt 表示「刚确认仍最新」，保留原 providers。
+        const renewed = { ...cached, fetchedAt: new Date().toISOString() };
+        writeSnapshot(renewed, snapshotPath);
+        return {
+            providers: renewed.providers,
+            source: 'cache',
+            fetchedAt: renewed.fetchedAt,
+            etag: renewed.etag,
+        };
+    }
+    if (res.status >= 200 && res.status < 300) {
+        let body;
+        try {
+            body = await res.json();
+        }
+        catch {
+            return cached ? emptyCatalog('cache', cached) : emptyCatalog('empty');
+        }
+        const providers = body.providers;
+        // models.dev 直接以 provider id 为顶层键（无外层 providers 包裹）；兼容两种形态。
+        const record = providers && typeof providers === 'object' ? providers : body;
+        if (!record || typeof record !== 'object') {
+            return cached ? emptyCatalog('cache', cached) : emptyCatalog('empty');
+        }
+        const etag = res.headers.get('etag') ?? cached?.etag ?? undefined;
+        const snapshot = {
+            fetchedAt: new Date().toISOString(),
+            ...(etag ? { etag } : {}),
+            providers: record,
+        };
+        writeSnapshot(snapshot, snapshotPath);
+        return {
+            providers: record,
+            source: 'live',
+            fetchedAt: snapshot.fetchedAt,
+            ...(etag ? { etag } : {}),
+        };
+    }
+    return cached ? emptyCatalog('cache', cached) : emptyCatalog('empty');
+}
+/**
+ * 命令入口：快照新鲜直接用快照（不联网）；过期或 force 才拉取。
+ */
+export async function loadCatalog(opts = {}) {
+    const snapshotPath = opts.snapshotPath ?? CATALOG_SNAPSHOT_PATH;
+    const cached = readSnapshot(snapshotPath);
+    if (!opts.force && cached && isFresh(cached, opts.now)) {
+        return { providers: cached.providers, source: 'cache', fetchedAt: cached.fetchedAt, etag: cached.etag };
+    }
+    return refreshCatalog({ fetch: opts.fetch, snapshotPath });
+}

package/dist/models/map-preset.js

@@ -0,0 +1,50 @@
+import { classifyProvider, resolveBaseURL, toPresetProvider } from './protocol.js';
+/** 上下文窗口缺失/为 0 时的保守默认（宁可小，避免超长发出去被拒）。 */
+export const FALLBACK_CONTEXT_WINDOW = 128000;
+/**
+ * 按 provider.env 声明的变量名顺序找一个已设置的 key；都没有返回 null。
+ * 读 process.env 是本模块唯一触碰环境的地方，调用方可传 env 覆盖以便测试。
+ */
+export function resolveApiKey(provider, env = process.env) {
+    for (const keyName of provider.env ?? []) {
+        const v = env[keyName];
+        if (typeof v === 'string' && v.trim())
+            return v.trim();
+    }
+    return null;
+}
+/** 把目录来源拼成合法预设名：`<provider>-<model>` 去非法字符。 */
+export function defaultPresetName(providerId, modelId) {
+    const raw = `${providerId}-${modelId}`;
+    const sanitized = raw
+        .replace(/[^a-zA-Z0-9_-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 32) || 'preset';
+    return sanitized;
+}
+/**
+ * 产出可直接 savePreset 的对象。provider 不被现有 fetch 支持时返回 null
+ * （命令层据此置灰/拒绝，避免存一个必错的预设）。
+ */
+export function buildPreset(input) {
+    const { provider, model } = input;
+    const proto = classifyProvider(provider);
+    const presetProvider = toPresetProvider(proto);
+    if (!presetProvider)
+        return null;
+    const baseURL = resolveBaseURL(provider);
+    if (!baseURL)
+        return null;
+    const contextWindow = typeof model.limit?.context === 'number' && model.limit.context > 0
+        ? Math.floor(model.limit.context)
+        : FALLBACK_CONTEXT_WINDOW;
+    return {
+        name: input.name ?? defaultPresetName(provider.id, model.id),
+        provider: presetProvider,
+        baseURL,
+        apiKey: input.apiKey,
+        model: input.modelOverride ?? model.id,
+        contextWindow,
+        anthropicPromptCache: presetProvider === 'anthropic',
+    };
+}

package/dist/models/model-panel.js

@@ -0,0 +1,227 @@
+import { classifyProvider, resolveBaseURL } from './protocol.js';
+function fmtK(n) {
+    if (!n || n <= 0)
+        return '-';
+    return n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+}
+/** 该预设是否与当前生效配置一致（用于标 ★）。 */
+export function isPresetCurrent(p, cur) {
+    return (p.provider === cur.provider &&
+        p.baseURL === cur.baseURL &&
+        p.model === cur.model &&
+        p.contextWindow === cur.contextWindowTokens);
+}
+/** 组装统一面板的全部行（顺序：当前预设 → 其他预设 → 目录模型 → 操作行）。 */
+export function buildPanelEntries(input) {
+    const rows = [];
+    // 已存预设：当前的排最前。
+    const withCurrent = input.presets.map((p) => ({
+        p,
+        cur: isPresetCurrent(p, input.current),
+    }));
+    withCurrent.sort((a, b) => Number(b.cur) - Number(a.cur) || a.p.name.localeCompare(b.p.name));
+    for (const { p, cur } of withCurrent) {
+        rows.push({
+            choice: { kind: 'preset', preset: p },
+            searchText: `${p.name} ${p.model} ${p.baseURL} ${p.provider}`,
+            label: `${cur ? '★ ' : ''}${p.name}`,
+            detail: `${p.model} · ${p.provider}`,
+        });
+    }
+    // 目录模型：跳过不支持的、以及与某预设重复的。
+    const presetKeys = new Set(input.presets.map((p) => `${p.baseURL}|${p.model}`));
+    for (const e of input.catalog) {
+        if (!e.supported)
+            continue;
+        const provider = input.providers[e.providerId];
+        if (!provider)
+            continue;
+        if (classifyProvider(provider) === 'unsupported')
+            continue;
+        if (presetKeys.has(`${provider.api ?? ''}|${e.modelId}`))
+            continue;
+        const c = e.model.cost;
+        const caps = [e.model.reasoning ? '思考' : '', e.model.tool_call ? '工具' : '', e.model.attachment ? '多模态' : '']
+            .filter(Boolean)
+            .join('·');
+        rows.push({
+            choice: { kind: 'catalog', entry: e },
+            searchText: `${e.model.name ?? ''} ${e.modelId}`,
+            label: e.model.name || e.modelId,
+            detail: [
+                e.providerName,
+                `${fmtK(e.model.limit?.context)} ctx`,
+                c ? `$${c.input ?? 0}/$${c.output ?? 0}` : '',
+                caps,
+            ]
+                .filter(Boolean)
+                .join(' · '),
+        });
+    }
+    // 操作行。
+    rows.push({
+        choice: { kind: 'action', action: 'custom' },
+        searchText: '自定义 手动填写 custom baseURL model key',
+        label: '＋ 自定义模型（手动填写）',
+        detail: '',
+    });
+    rows.push({
+        choice: { kind: 'action', action: 'refresh' },
+        searchText: '刷新模型目录 refresh catalog 更新',
+        label: '⟳ 刷新模型目录',
+        detail: '',
+    });
+    return rows;
+}
+/** 归一化端点为归并键：小写 host + 去尾斜杠的 path，使预设 baseURL 与目录 api 对齐。 */
+function endpointKey(raw) {
+    const v = raw.trim();
+    try {
+        const u = new URL(v);
+        return `${u.host.toLowerCase()}${u.pathname.replace(/\/+$/, '')}`;
+    }
+    catch {
+        return v.replace(/\/+$/, '').toLowerCase();
+    }
+}
+/** 从 URL 取 host 作合成组名；失败回退整串。 */
+function hostOf(raw) {
+    try {
+        return new URL(raw.trim()).host;
+    }
+    catch {
+        return raw.trim();
+    }
+}
+function presetLeaf(p, cur) {
+    return {
+        choice: { kind: 'preset', preset: p },
+        searchText: `${p.model}`,
+        label: `${cur ? '★ ' : ''}${p.name}`,
+        detail: `${p.model} · ${p.provider}`,
+    };
+}
+function catalogLeaf(e) {
+    const c = e.model.cost;
+    const caps = [e.model.reasoning ? '思考' : '', e.model.tool_call ? '工具' : '', e.model.attachment ? '多模态' : '']
+        .filter(Boolean)
+        .join('·');
+    return {
+        choice: { kind: 'catalog', entry: e },
+        searchText: `${e.model.name ?? ''} ${e.modelId}`,
+        label: e.model.name || e.modelId,
+        detail: [e.providerName, `${fmtK(e.model.limit?.context)} ctx`, c ? `$${c.input ?? 0}/$${c.output ?? 0}` : '', caps]
+            .filter(Boolean)
+            .join(' · '),
+    };
+}
+function actionLeaf(action) {
+    if (action === 'custom') {
+        return {
+            choice: { kind: 'action', action },
+            searchText: '自定义 手动填写 custom baseURL model key',
+            label: '＋ 自定义模型（手动填写）',
+            detail: '',
+        };
+    }
+    return {
+        choice: { kind: 'action', action },
+        searchText: '刷新模型目录 refresh catalog 更新',
+        label: '⟳ 刷新模型目录',
+        detail: '',
+    };
+}
+/**
+ * 组装两级模型树：root = 厂商组 + 操作行；每个厂商组内 = 当前预设★ → 其他预设 → 目录模型。
+ *
+ * 归并规则：预设按 baseURL 归并到「端点相同」的目录厂商；目录里没有的端点按 URL host
+ * 合成一个组。目录模型与预设同 model 名时不重复列（预设优先）。无 I/O。
+ */
+export function buildModelTree(input) {
+    const groups = [];
+    const byKey = new Map();
+    // 1) 目录厂商：仅可直发且有模型的。
+    for (const [providerId, provider] of Object.entries(input.providers)) {
+        if (classifyProvider(provider) === 'unsupported')
+            continue;
+        const endpoint = resolveBaseURL(provider);
+        if (!endpoint)
+            continue;
+        if (Object.keys(provider.models ?? {}).length === 0)
+            continue;
+        const label = provider.name || providerId;
+        const g = {
+            label,
+            key: endpointKey(endpoint),
+            providerId,
+            presetLeaves: [],
+            catalogLeaves: [],
+            seenModels: new Set(),
+            searchText: `${label} ${providerId}`,
+        };
+        groups.push(g);
+        if (!byKey.has(g.key))
+            byKey.set(g.key, g);
+        for (const e of input.catalog) {
+            if (!e.supported || e.providerId !== providerId)
+                continue;
+            if (g.seenModels.has(e.modelId))
+                continue;
+            g.seenModels.add(e.modelId);
+            g.catalogLeaves.push(catalogLeaf(e));
+        }
+    }
+    // 2) 预设归并：端点命中目录厂商 → 进该组；否则进/建合成组。
+    for (const p of input.presets) {
+        const cur = isPresetCurrent(p, input.current);
+        const key = endpointKey(p.baseURL);
+        let g = byKey.get(key);
+        if (!g) {
+            g = {
+                label: hostOf(p.baseURL) || p.baseURL,
+                key,
+                providerId: null,
+                presetLeaves: [],
+                catalogLeaves: [],
+                seenModels: new Set(),
+                searchText: `${hostOf(p.baseURL)}`,
+            };
+            groups.push(g);
+            byKey.set(key, g);
+        }
+        g.presetLeaves.push({ node: presetLeaf(p, cur), model: p.model, cur });
+    }
+    // 3) 组内：当前预设 → 其他预设 → 目录模型（跳过与预设同名的）；空组不列。
+    const roots = [];
+    for (const g of groups) {
+        const presetModelNames = new Set(g.presetLeaves.map((x) => x.model));
+        g.presetLeaves.sort((a, b) => Number(b.cur) - Number(a.cur));
+        const children = [
+            ...g.presetLeaves.map((x) => x.node),
+            ...g.catalogLeaves.filter((leaf) => {
+                const e = leaf.choice;
+                return !(e?.kind === 'catalog' && presetModelNames.has(e.entry.modelId));
+            }),
+        ];
+        if (children.length === 0)
+            continue;
+        roots.push({
+            searchText: g.searchText,
+            label: g.label,
+            detail: `${children.length} 个模型`,
+            children,
+        });
+    }
+    // 目录厂商在前，合成组在后；各自按名排序。
+    roots.sort((a, b) => {
+        const ga = groups.find((g) => g.label === a.label && g.searchText === a.searchText);
+        const gb = groups.find((g) => g.label === b.label && g.searchText === b.searchText);
+        const sa = ga?.providerId ? 0 : 1;
+        const sb = gb?.providerId ? 0 : 1;
+        return sa - sb || a.label.localeCompare(b.label);
+    });
+    // 4) 操作行固定在 root 末尾。
+    roots.push(actionLeaf('custom'));
+    roots.push(actionLeaf('refresh'));
+    return roots;
+}