mocode-ai 1.6.4 → 1.6.5

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

package/dist/repl/commands/effort.js

@@ -0,0 +1,81 @@
+/**
+ * 思考强度命令组:/effort [off|low|medium|high|auto](#token-efficiency P3)
+ *
+ * 无参弹选择菜单(promptIntervention);带参直设;auto = 不下发任何 reasoning 参数。
+ * 生效链路:updateModelConfig 改内存/env + 会话 pin 同步 → writeConfigKeys 持久化 →
+ * refreshStatusBase 刷底栏。不需要 reconfigureClient(effort 在每次请求体现读)。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { config, updateModelConfig } from '../../config/index.js';
+import { writeConfigKeys } from '../../config/file.js';
+import { promptIntervention } from '../../ui/intervention.js';
+import { parseReasoningEffort, recognizesReasoning } from '../../llm/reasoning.js';
+import { unhandled, next } from './types.js';
+const LEVELS = ['off', 'low', 'medium', 'high', 'auto'];
+const LEVEL_LABELS = {
+    off: 'off(关闭思考)',
+    low: 'low(少思考·快·省)',
+    medium: 'medium(均衡)',
+    high: 'high(深度思考)',
+    auto: 'auto(不下发,后端默认)',
+};
+/** 当前目标模型是否在白名单内(未识别则给提示)。 */
+function currentModelRecognized() {
+    return recognizesReasoning({
+        provider: config.provider === 'anthropic' ? 'anthropic' : 'openai',
+        model: config.model,
+        maxTokens: config.maxTokens,
+    });
+}
+export const effortCommands = [
+    async (ctx) => {
+        const { line } = ctx;
+        if (line !== '/effort' && !line.startsWith('/effort '))
+            return unhandled();
+        const arg = line.startsWith('/effort ') ? line.slice('/effort '.length).trim() : '';
+        let effort;
+        if (arg === '') {
+            // 无参:弹菜单,预选项为当前档。
+            let res;
+            try {
+                res = await promptIntervention({
+                    type: 'choice',
+                    title: '选择思考强度(reasoning effort)',
+                    detail: '同档名在不同模型上语义不完全等价;未知模型/第三方网关不下发参数。' + `当前:${getActiveEffortLabel()}`,
+                    options: LEVELS.map((lv) => LEVEL_LABELS[lv]),
+                });
+            }
+            catch {
+                return next(); // Ctrl+C
+            }
+            if (res.action === 'cancelled')
+                return next();
+            if (!res.value)
+                return next();
+            const idx = LEVELS.map((lv) => LEVEL_LABELS[lv]).indexOf(res.value);
+            if (idx === -1)
+                return next();
+            effort = LEVELS[idx];
+        }
+        else {
+            effort = parseReasoningEffort(arg);
+            if (!effort) {
+                layout.contentWrite(`${ui.yellow}未知思考强度: ${arg};可选 off | low | medium | high | auto${ui.reset}\n`);
+                return next();
+            }
+        }
+        updateModelConfig({ reasoningEffort: effort });
+        writeConfigKeys({ REASONING_EFFORT: effort });
+        ctx.refreshStatusBase(ctx.history);
+        layout.contentWrite(`${ui.dim}思考强度已设为 ${LEVEL_LABELS[effort]}${ui.reset}\n`);
+        if (effort !== 'auto' && !currentModelRecognized()) {
+            layout.contentWrite(`${ui.yellow}(当前模型未识别为支持 reasoning 参数,设置不会下发;切换到 o/gpt-5/Qwen3/GLM-4.5+/Claude 等模型后生效)${ui.reset}\n`);
+        }
+        return next();
+    },
+];
+/** 读当前会话 effort 的展示标签(模块内辅助)。 */
+function getActiveEffortLabel() {
+    return LEVEL_LABELS[config.reasoningEffort];
+}