mocode-ai 1.6.4 → 1.6.6

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/notify/index.js

@@ -0,0 +1,144 @@
+// 任务结束通知：POST 到用户自配的 webhook，按 URL 自动识别格式：
+// - ntfy：https://ntfy.sh/<topic>（POST 正文，Title header）
+// - Bark：https://api.day.app/<key>（POST JSON {title, body}）
+// - Telegram：https://api.telegram.org/bot<token>/sendMessage[?chat_id=...]
+// - 其他：generic JSON webhook
+//
+// 刻意 best-effort：通知失败永不影响任务结果、不重试（webhook 是副作用通道，
+// 不该因为通知服务挂了让 job 变 failed）。
+//
+// 回环地址（localhost/127.0.0.1）走 node:http 直连：Node 24 的 fetch 默认使用
+// HTTP_PROXY 环境代理，而 NO_PROXY 对 localhost 的绕过不可靠，带代理的机器上
+// 本地 webhook 会被转发失败。公网地址仍走 fetch（保留代理穿透）。
+function firstLine(prompt) {
+    const line = prompt.split('\n')[0] ?? '';
+    return line.length > 80 ? `${line.slice(0, 80)}…` : line;
+}
+function buildTitle(ev) {
+    if (ev.status === 'succeeded')
+        return 'mocode OK';
+    if (ev.status === 'failed')
+        return 'mocode FAILED';
+    return 'mocode APPROVAL NEEDED';
+}
+function buildBody(ev) {
+    if (ev.status === 'waiting') {
+        return (`Tool: ${ev.tool ?? '?'}\n\n${firstLine(ev.prompt)}\n\nsession: ${ev.sessionId}\nmodel: ${ev.model}` +
+            `\n\nApprove: mocode approve ${ev.sessionId}\nDeny:    mocode deny ${ev.sessionId}`);
+    }
+    const secs = (ev.elapsedMs / 1000).toFixed(1);
+    return `${firstLine(ev.prompt)}\n\nsession: ${ev.sessionId}\nmodel: ${ev.model}\ntime: ${secs}s`;
+}
+/**
+ * 按 URL 构造请求（纯函数）。
+ * 返回 null 表示 URL 无法识别（调用方静默跳过）。
+ */
+export function buildNotifyRequest(webhookUrl, ev) {
+    let url;
+    try {
+        url = new URL(webhookUrl);
+    }
+    catch {
+        return null;
+    }
+    const title = buildTitle(ev);
+    const body = buildBody(ev);
+    // Telegram：query 中的 chat_id 合并进 JSON body。
+    if (url.hostname === 'api.telegram.org' && url.pathname.includes('/sendMessage')) {
+        const chatId = url.searchParams.get('chat_id') ?? process.env.MOCODE_NOTIFY_CHAT_ID;
+        if (!chatId)
+            return null;
+        url.search = '';
+        return {
+            init: {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ chat_id: chatId, text: `${title}\n${body}` }),
+            },
+        };
+    }
+    // Bark：{title, body}。
+    if (url.hostname === 'api.day.app' || url.hostname.endsWith('.day.app')) {
+        return {
+            init: {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ title, body }),
+            },
+        };
+    }
+    // ntfy 风格（含自建实例）：裸文本正文 + Title/Priority header。
+    if (url.hostname === 'ntfy.sh' || url.pathname.split('/').filter(Boolean).length === 1) {
+        return {
+            init: {
+                method: 'POST',
+                headers: { Title: title, Priority: ev.status === 'failed' ? 'high' : 'default' },
+                body,
+            },
+        };
+    }
+    // Generic JSON webhook。
+    return {
+        init: {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ ...ev, title, body }),
+        },
+    };
+}
+/** 是否回环地址（localhost/127.0.0.1/[::1]）。 */
+function isLoopback(hostname) {
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]' || hostname === '::1';
+}
+/**
+ * 回环地址直连 POST（node:http）。
+ */
+function postLoopback(url, init) {
+    return new Promise((resolvePromise) => {
+        void (async () => {
+            const mod = url.protocol === 'https:' ? await import('node:https') : await import('node:http');
+            const headers = {};
+            const headersInit = init.headers;
+            if (headersInit) {
+                for (const [k, v] of Object.entries(headersInit))
+                    headers[k] = v;
+            }
+            const body = typeof init.body === 'string' ? init.body : '';
+            headers['Content-Length'] = String(Buffer.byteLength(body));
+            const req = mod.request(url, { method: init.method, headers, timeout: 10000 }, (res) => {
+                res.resume();
+                resolvePromise((res.statusCode ?? 500) < 400);
+            });
+            req.on('error', () => resolvePromise(false));
+            req.on('timeout', () => {
+                req.destroy();
+                resolvePromise(false);
+            });
+            req.end(body);
+        })();
+    });
+}
+/** 发送通知。best-effort：成功返回 true，任何失败静默 false。 */
+export async function sendNotification(webhookUrl, ev) {
+    if (!webhookUrl)
+        return false;
+    const spec = buildNotifyRequest(webhookUrl, ev);
+    if (!spec)
+        return false;
+    let url;
+    try {
+        url = new URL(webhookUrl);
+    }
+    catch {
+        return false;
+    }
+    try {
+        if (isLoopback(url.hostname))
+            return await postLoopback(url, spec.init);
+        const res = await fetch(url, { ...spec.init, signal: AbortSignal.timeout(10000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/repl/commands/bots.js

@@ -0,0 +1,32 @@
+/**
+ * 具名 Bot 命令:/bots
+ * 只读列出 bots；增删改/查看详情走 CLI `mocode bots …`，按名运行用 --bot <name>。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { listBots } from '../../bots/store.js';
+import { unhandled, next } from './types.js';
+function oneLine(text) {
+    const line = text.split('\n')[0] ?? '';
+    return line.length > 50 ? `${line.slice(0, 50)}…` : line;
+}
+export const botsCommands = [
+    (ctx) => {
+        if (ctx.line !== '/bots')
+            return unhandled();
+        const all = listBots();
+        if (all.length === 0) {
+            layout.contentWrite(`${ui.dim}(no bots; mocode bots add --name <n> --prompt "…")${ui.reset}\n`);
+            return next();
+        }
+        for (const b of all) {
+            const scopeTag = b.scope === 'global' ? `${ui.dim}g${ui.reset}` : `${ui.cyan}p${ui.reset}`;
+            layout.contentWrite(`  ${scopeTag} ${ui.bold}${b.name}${ui.reset}` +
+                `${b.tools && b.tools.length ? ` ${ui.dim}tools:${b.tools.length}${ui.reset}` : ''}` +
+                `  ${ui.dim}${b.description}${ui.reset}\n` +
+                `      ${ui.dim}${oneLine(b.systemPrompt)}${ui.reset}\n`);
+        }
+        layout.contentWrite(`${ui.dim}  run: mocode run --bot ${all[0]?.name ?? '<name>'} "task" · details: mocode bots show <name>${ui.reset}\n`);
+        return next();
+    },
+];

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

package/dist/repl/commands/jobs.js

@@ -0,0 +1,109 @@
+/**
+ * 后台任务命令组:/jobs · /jobs log [id前缀] · /jobs kill [id前缀]
+ *
+ * 不依赖 REPL 闭包状态（job 真相在 .mocode/jobs/），所以是这批命令里最独立的一组。
+ * id 可只给时间戳前缀（如 /jobs kill 20260926-1730），唯一定位即可。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { listJobs, readJobLog } from '../../jobs/store.js';
+import { killBackgroundJob } from '../../jobs/launch.js';
+import { unhandled, next } from './types.js';
+const STATUS_COLOR = {
+    paused: ui.cyan,
+    running: ui.yellow,
+    succeeded: ui.green,
+    failed: ui.red,
+    killed: ui.dim,
+};
+function findJob(idPrefix) {
+    const jobs = listJobs();
+    if (!idPrefix)
+        return jobs[0];
+    const matches = jobs.filter((j) => j.id.startsWith(idPrefix));
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function oneLinePrompt(prompt) {
+    const line = prompt.split('\n')[0] ?? '';
+    return line.length > 50 ? `${line.slice(0, 50)}…` : line;
+}
+function renderList() {
+    const jobs = listJobs().slice(0, 10);
+    if (jobs.length === 0) {
+        layout.contentWrite(`${ui.dim}(没有后台任务。用 mocode run --bg "任务" 启动)${ui.reset}\n`);
+        return;
+    }
+    for (const job of jobs) {
+        const color = STATUS_COLOR[job.status];
+        layout.contentWrite(`  ${color}●${ui.reset} ${ui.bold}${job.id}${ui.reset}  ${color}${job.status}${ui.reset}\n` +
+            `      ${ui.dim}${oneLinePrompt(job.prompt)}${ui.reset}\n`);
+    }
+    layout.contentWrite(`${ui.dim}  /jobs log [id前缀] 看尾日志 · /jobs kill [id前缀] 杀任务${ui.reset}\n`);
+}
+export const jobsCommands = [
+    // /jobs approve|deny [id前缀]
+    async (ctx) => {
+        if (ctx.cmd !== '/jobs')
+            return unhandled();
+        const parts = ctx.line.split(/\s+/);
+        if (parts[1] !== 'approve' && parts[1] !== 'deny')
+            return unhandled();
+        const job = findJob(parts[2]);
+        if (!job) {
+            layout.contentWrite(`${ui.yellow}(没找到唯一匹配的任务)${ui.reset}\n`);
+            return next();
+        }
+        if (job.status !== 'paused') {
+            layout.contentWrite(`${ui.dim}任务 ${job.id} 状态 ${job.status}，无需审批${ui.reset}\n`);
+            return next();
+        }
+        const { runApproveCli } = await import('../../jobs/approve-cli.js');
+        runApproveCli([job.id], parts[1] === 'approve' ? 'approved' : 'denied');
+        return next();
+    },
+    // /jobs kill [id前缀]
+    (ctx) => {
+        if (ctx.cmd !== '/jobs')
+            return unhandled();
+        const parts = ctx.line.split(/\s+/);
+        if (parts[1] !== 'kill')
+            return unhandled();
+        const job = findJob(parts[2]);
+        if (!job) {
+            layout.contentWrite(`${ui.yellow}(没找到唯一匹配的任务)${ui.reset}\n`);
+            return next();
+        }
+        if (job.status !== 'running' && job.status !== 'paused') {
+            layout.contentWrite(`${ui.dim}任务 ${job.id} 已是 ${job.status}，无需 kill${ui.reset}\n`);
+            return next();
+        }
+        const ok = killBackgroundJob(job);
+        layout.contentWrite(ok
+            ? `${ui.yellow}已 kill 任务 ${job.id}${ui.reset}\n`
+            : `${ui.red}kill 失败（进程可能已退出；PID=${job.pid ?? '?'})${ui.reset}\n`);
+        return next();
+    },
+    // /jobs log [id前缀]
+    (ctx) => {
+        if (ctx.cmd !== '/jobs')
+            return unhandled();
+        const parts = ctx.line.split(/\s+/);
+        if (parts[1] !== 'log')
+            return unhandled();
+        const job = findJob(parts[2]);
+        if (!job) {
+            layout.contentWrite(`${ui.yellow}(没找到唯一匹配的任务)${ui.reset}\n`);
+            return next();
+        }
+        layout.contentWrite(`${ui.bold}── log ${job.id} ──${ui.reset}\n`);
+        layout.contentWrite(`${readJobLog(job.id)}\n`);
+        return next();
+    },
+    // /jobs（列表）
+    (ctx) => {
+        if (ctx.line !== '/jobs')
+            return unhandled();
+        renderList();
+        return next();
+    },
+];