mocode-ai 1.6.3 → 1.6.5

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;
+}

package/dist/models/protocol.js

@@ -0,0 +1,44 @@
+/** OpenAI 官方端点（官方 provider 记录通常不带 api 字段）。 */
+export const OPENAI_DEFAULT_BASE_URL = 'https://api.openai.com/v1';
+/**
+ * Anthropic 官方端点：provider 记录同样不带 api（端点内置 SDK）。
+ * 不带 /v1——anthropic.ts 的 endpoint() 会在后面拼 `/v1/messages`。
+ */
+export const ANTHROPIC_DEFAULT_BASE_URL = 'https://api.anthropic.com';
+/**
+ * 判定该 provider 能否用 mocode 现有 fetch 直发。
+ * - 官方 anthropic 包 → Anthropic Messages 路径
+ * - openai-compatible 且带端点 → OpenAI Chat 路径
+ * - 官方 openai 包 → OpenAI Chat 路径（端点缺省补官方 /v1）
+ * - 其余（google/bedrock/azure/vertex/各 gateway…）→ 二期，UI 置灰
+ */
+export function classifyProvider(provider) {
+    switch (provider.npm) {
+        case '@ai-sdk/anthropic':
+            return 'anthropic-messages';
+        case '@ai-sdk/openai-compatible':
+            return provider.api && provider.api.trim() ? 'openai-chat' : 'unsupported';
+        case '@ai-sdk/openai':
+            return 'openai-chat';
+        default:
+            return 'unsupported';
+    }
+}
+/** provider 实际要用的 baseURL：官方 openai/anthropic 缺 api 时补默认，其余原样返回。 */
+export function resolveBaseURL(provider) {
+    if (provider.api && provider.api.trim())
+        return provider.api.trim();
+    if (provider.npm === '@ai-sdk/openai')
+        return OPENAI_DEFAULT_BASE_URL;
+    if (provider.npm === '@ai-sdk/anthropic')
+        return ANTHROPIC_DEFAULT_BASE_URL;
+    return '';
+}
+/** 映射到 ModelPreset.provider（presets.ts 的两值）。 */
+export function toPresetProvider(proto) {
+    if (proto === 'openai-chat')
+        return 'openai';
+    if (proto === 'anthropic-messages')
+        return 'anthropic';
+    return null;
+}

package/dist/models/reasoning-cap.js

@@ -0,0 +1,88 @@
+import { THINK_BUDGET_BY_EFFORT } from './budgets.js';
+/**
+ * catalogProviderId → 方言。一家厂商一种方言（alibaba 全系 Qwen）。
+ * 未列出的 provider 返回 undefined → 保守不下发。
+ */
+const PROVIDER_DIALECT = {
+    openai: 'openai-effort',
+    openrouter: 'openai-effort',
+    xai: 'openai-effort',
+    alibaba: 'qwen',
+    zhipuai: 'thinking-toggle',
+    volcengine: 'thinking-toggle',
+    deepseek: 'thinking-toggle',
+    moonshotai: 'thinking-toggle',
+};
+export function dialectForProvider(catalogProviderId) {
+    return catalogProviderId ? PROVIDER_DIALECT[catalogProviderId] : undefined;
+}
+/** 在 effort values 中按归一化档位挑一个合法值（按优先级，找不到回退到最低/最高档）。 */
+function pickEffortValue(effort, values, off) {
+    const v = values.map((s) => s.toLowerCase());
+    const priorities = off
+        ? { any: ['off', 'disabled', 'minimal', 'low'] }
+        : effort === 'low'
+            ? { any: ['low', 'minimal'] }
+            : effort === 'medium'
+                ? { any: ['medium', 'mid', 'low'] }
+                : { any: ['high', 'xhigh', 'max', 'medium'] };
+    for (const cand of priorities.any) {
+        const hit = v.find((x) => x === cand || x.includes(cand));
+        if (hit)
+            return values[v.indexOf(hit)];
+    }
+    // 回退：off/低档取最低，高档取最高。
+    return off || effort === 'low' ? values[0] : values[values.length - 1];
+}
+/**
+ * 目录能力 → 请求字段；无法安全下发时返回 {}。
+ * 依据第一个匹配的 reasoning_option 决定形态。
+ */
+export function paramsFromCatalog(input) {
+    const dialect = dialectForProvider(input.catalogProviderId);
+    if (!dialect)
+        return {};
+    const opts = input.reasoningOptions ?? [];
+    const toggle = opts.find((o) => o.type === 'toggle');
+    const effortOpt = opts.find((o) => o.type === 'effort');
+    const budgetOpt = opts.find((o) => o.type === 'budget_tokens');
+    const isOff = input.effort === 'off';
+    // ── qwen 方言：enable_thinking + thinking_budget（budget 选项优先给预算） ──
+    if (dialect === 'qwen') {
+        if (isOff)
+            return { enable_thinking: false };
+        const base = { enable_thinking: true };
+        if (budgetOpt) {
+            let budget = THINK_BUDGET_BY_EFFORT[input.effort];
+            if (typeof budgetOpt.min === 'number')
+                budget = Math.max(budgetOpt.min, budget);
+            base.thinking_budget = budget;
+        }
+        return base;
+    }
+    // ── openai effort 方言 ──
+    if (dialect === 'openai-effort') {
+        if (effortOpt?.values && effortOpt.values.length > 0) {
+            // OpenAI 官方无法真关：off 落到最低档。
+            return { reasoning_effort: pickEffortValue(input.effort, effortOpt.values, isOff) };
+        }
+        if (toggle) {
+            return isOff ? { reasoning_effort: 'low' } : { reasoning_effort: input.effort };
+        }
+        // 无 effort/toggle 元数据但已知是 OpenAI 方言：直接下发归一化档位（off→low）。
+        return { reasoning_effort: isOff ? 'low' : input.effort };
+    }
+    // ── thinking-toggle 方言 ──
+    if (dialect === 'thinking-toggle') {
+        if (effortOpt?.values && effortOpt.values.length > 0 && !isOff) {
+            // 个别厂商用 thinking 但分档（如 deepseek low/high/max）：仍只开关，标 enabled。
+            return { thinking: { type: 'enabled' } };
+        }
+        return { thinking: { type: isOff ? 'disabled' : 'enabled' } };
+    }
+    return {};
+}
+/** 目录是否声明该模型支持思考（供 recognizesReasoning）。 */
+export function recognizesFromCatalog(reasoning) {
+    return reasoning === true;
+}

package/dist/models/search.js

@@ -0,0 +1,58 @@
+import { classifyProvider } from './protocol.js';
+/** 把目录拍平成条目列表。 */
+export function flattenCatalog(providers) {
+    const out = [];
+    for (const [providerId, provider] of Object.entries(providers)) {
+        const supported = classifyProvider(provider) !== 'unsupported';
+        const providerName = provider.name || providerId;
+        for (const [modelId, model] of Object.entries(provider.models ?? {})) {
+            out.push({ providerId, providerName, modelId, model, supported });
+        }
+    }
+    return out;
+}
+/** 关键字过滤 + 能力过滤。 */
+export function searchModels(providers, filters = {}) {
+    const q = filters.query?.trim().toLowerCase();
+    return flattenCatalog(providers)
+        .filter((e) => {
+        if (!filters.includeUnsupported && !e.supported)
+            return false;
+        if (filters.reasoning && !e.model.reasoning)
+            return false;
+        if (filters.toolCall && !e.model.tool_call)
+            return false;
+        if (filters.attachment && !e.model.attachment)
+            return false;
+        if (q) {
+            const hay = [e.providerName, e.providerId, e.modelId, e.model.name ?? '', e.model.family ?? '']
+                .join(' ')
+                .toLowerCase();
+            // 支持多关键字（空格分隔），全部命中才算。
+            if (!q.split(/\s+/).every((tok) => hay.includes(tok)))
+                return false;
+        }
+        return true;
+    })
+        .sort((a, b) => {
+        // 可直发优先；其次厂商名；再模型名（按发布时间倒序更适合挑新模型，但纯函数保持确定性）。
+        if (a.supported !== b.supported)
+            return a.supported ? -1 : 1;
+        const p = a.providerName.localeCompare(b.providerName);
+        if (p !== 0)
+            return p;
+        return (b.model.release_date ?? '').localeCompare(a.model.release_date ?? '');
+    });
+}
+/** 按 provider 分组（保持组内顺序），供 UI 分区渲染。 */
+export function groupByProvider(entries) {
+    const map = new Map();
+    for (const e of entries) {
+        const arr = map.get(e.providerId);
+        if (arr)
+            arr.push(e);
+        else
+            map.set(e.providerId, [e]);
+    }
+    return map;
+}

package/dist/models/types.js

@@ -0,0 +1,8 @@
+/**
+ * models.dev 目录的最小类型（#model-catalog）。
+ *
+ * 只声明 mocode 实际消费的字段——上游 api.json 一个 provider 下还有很多我们用不到的
+ * 字段，刻意不照搬，保持类型面小、上游增字段不影响编译。所有字段按「可能缺失」处理，
+ * 消费方走默认值，不假设上游永远规整。
+ */
+export {};