mocode-ai 1.6.4 → 1.6.6

package/dist/jobs/attach.js

@@ -0,0 +1,61 @@
+// C4 Reattach：`mocode attach [id前缀]`——从头回放 job 日志，并实时跟随新输出，
+// 直到 job 进入终态（succeeded/failed/killed）且日志排空后退出。
+//
+// 纯 stdout 流式（与 headless 同性质），故不嵌进全屏 TUI：TUI 内 /jobs attach
+// 只提示在另一终端运行。轮询而非持久句柄——跨平台、且 job 文件由别的进程写入。
+import fs from 'node:fs';
+import { getJob, listJobs } from './store.js';
+const TERMINAL = new Set(['succeeded', 'failed', 'killed']);
+const POLL_MS = 500;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function resolveJob(idPrefix) {
+    if (!idPrefix) {
+        const running = listJobs().filter((j) => !TERMINAL.has(j.status));
+        return running.length === 1 ? running[0] : (listJobs()[0] ?? null);
+    }
+    const matches = listJobs().filter((j) => j.id.startsWith(idPrefix));
+    return matches.length === 1 ? matches[0] : null;
+}
+export async function runAttachCli(rawArgs) {
+    const idPrefix = rawArgs[0];
+    const initial = resolveJob(idPrefix);
+    if (!initial) {
+        process.stderr.write('mocode: no unique matching job to attach\n');
+        return 1;
+    }
+    process.stdout.write(`── attach ${initial.id} ──\n`);
+    let offset = 0;
+    let stableRounds = 0;
+    for (;;) {
+        // 1) 排空当前新增日志。
+        try {
+            const stat = fs.statSync(initial.logPath);
+            if (stat.size > offset) {
+                const buf = Buffer.alloc(stat.size - offset);
+                const fd = fs.openSync(initial.logPath, 'r');
+                fs.readSync(fd, buf, 0, buf.length, offset);
+                fs.closeSync(fd);
+                offset = stat.size;
+                process.stdout.write(buf);
+                stableRounds = 0;
+            }
+        }
+        catch {
+            // 日志暂时不可读（尚未创建/被锁），下轮再试。
+        }
+        // 2) 查最新状态。
+        const job = getJob(initial.id) ?? initial;
+        if (TERMINAL.has(job.status)) {
+            // 终态后再多等两轮，确保末尾输出已落盘并排空，避免丢最后几行。
+            stableRounds += 1;
+            if (stableRounds >= 2) {
+                if (!process.stdout.isTTY)
+                    process.stdout.write(`\n[${job.status}]`);
+                else
+                    process.stdout.write(`\n${job.status}\n`);
+                return job.status === 'succeeded' ? 0 : 1;
+            }
+        }
+        await sleep(POLL_MS);
+    }
+}

package/dist/jobs/checkpoint.js

@@ -0,0 +1,33 @@
+// D3 checkpoint 存储：每个 bg job 在工具批次提交后把完整 history 快照
+// 原子写到 <id>.checkpoint.json。崩溃 / 机器重启后可用
+// `mocode resume-job <id>` 从最后一个 checkpoint 在新进程断点续跑。
+import fs from 'node:fs';
+import path from 'node:path';
+import { jobsRoot } from './store.js';
+function checkpointPath(jobId) {
+    return path.join(jobsRoot(), `${jobId}.checkpoint.json`);
+}
+export function writeCheckpoint(jobId, history) {
+    fs.mkdirSync(jobsRoot(), { recursive: true });
+    const target = checkpointPath(jobId);
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(history)}\n`, 'utf8');
+    fs.renameSync(tmp, target);
+}
+export function readCheckpoint(jobId) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(checkpointPath(jobId), 'utf8'));
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteCheckpoint(jobId) {
+    try {
+        fs.rmSync(checkpointPath(jobId));
+    }
+    catch {
+        // already gone
+    }
+}

package/dist/jobs/launch.js

@@ -0,0 +1,107 @@
+// 后台任务 launcher / kill：spawn 一个 detached 子进程，父进程退出不影响它
+//（detached + 独立进程组），stdio 重定向到日志文件。
+//
+// 形态自适应：编译产物 src/index.js 存在 → node 直跑；否则（开发态）用 node 加载
+// tsx loader 单进程跑 src/index.ts（不用 tsx CLI：它会 respawn 一个不 hide 的弹窗 node）。
+//
+// 通用件 buildEntryArgs / spawnDetached 也供 schedule 守护进程复用（src/schedule/daemon.ts）。
+import { spawn, spawnSync } from 'node:child_process';
+import { openSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { createJobId, saveJob, updateJob, logPathFor, getJob } from './store.js';
+const jobsDir = path.dirname(fileURLToPath(import.meta.url));
+const srcDir = path.resolve(jobsDir, '..');
+const projectRoot = path.resolve(srcDir, '..');
+const compiledEntry = path.join(srcDir, 'index.js');
+const sourceEntry = path.join(srcDir, 'index.ts');
+const tsxLoader = path.join(projectRoot, 'node_modules', 'tsx', 'dist', 'loader.mjs');
+const tsxPreflight = path.join(projectRoot, 'node_modules', 'tsx', 'dist', 'preflight.cjs');
+/**
+ * 构造「node …入口… internalArgs」的完整参数。
+ * 生产/开发形态自动选择，调用方只需给入口之后的内部参数（如 ['--job-runner', id]）。
+ */
+export function buildEntryArgs(internalArgs) {
+    if (existsSync(compiledEntry))
+        return [compiledEntry, ...internalArgs];
+    return ['--require', tsxPreflight, '--import', pathToFileURL(tsxLoader).href, sourceEntry, ...internalArgs];
+}
+/**
+ * detached spawn 一个 node 子进程。stdio 重定向到 logPath（stdout+stderr 同一 fd）。
+ * 调用方负责后续 saveJob 等状态回写。
+ */
+export function spawnDetached(internalArgs, logPath, cwd = process.cwd()) {
+    const outFd = openSync(logPath, 'a');
+    const child = spawn(process.execPath, buildEntryArgs(internalArgs), {
+        detached: true,
+        stdio: ['ignore', outFd, outFd],
+        cwd,
+        env: process.env,
+        windowsHide: true,
+    });
+    child.unref();
+    return child;
+}
+/** 创建记录并启动 detached job。spawn 失败时记录置 failed。 */
+export function launchBackgroundJob(prompt, opts = {}) {
+    const id = createJobId();
+    const logPath = logPathFor(id);
+    const record = {
+        id,
+        prompt,
+        status: 'running',
+        cwd: process.cwd(),
+        logPath,
+        startedAt: new Date().toISOString(),
+        ...(opts.sessionDir ? { sessionDir: opts.sessionDir } : {}),
+        ...(opts.worktree ? { worktree: true } : {}),
+        ...(opts.botName ? { botName: opts.botName } : {}),
+    };
+    saveJob(record);
+    const child = spawnDetached(['--job-runner', id], logPath);
+    if (child.pid)
+        saveJob({ ...record, pid: child.pid });
+    child.on('error', () => {
+        updateJob(id, { status: 'failed', finishedAt: new Date().toISOString() }, { force: true });
+    });
+    return { record: { ...record, pid: child.pid }, child };
+}
+/**
+ * 树杀进程并置 killed。
+ * Windows：taskkill /T /F 杀整棵进程树；POSIX：负 pid 杀整个进程组。
+ */
+export function killTree(pid) {
+    if (process.platform === 'win32') {
+        const r = spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+        return r.status === 0;
+    }
+    try {
+        process.kill(-pid, 'SIGTERM');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 树杀 job 并置 killed。 */
+export function killBackgroundJob(record) {
+    if (typeof record.pid !== 'number')
+        return false;
+    if (!killTree(record.pid))
+        return false;
+    updateJob(record.id, { status: 'killed', finishedAt: new Date().toISOString() }, { force: true });
+    return true;
+}
+/** D3: 从最后 checkpoint 在新 detached 进程中断点续跑同一 job。 */
+export function resumeBackgroundJob(id) {
+    const record = getJob(id);
+    if (!record)
+        return null;
+    updateJob(id, { status: 'running', finishedAt: undefined, exitCode: undefined }, { force: true });
+    const child = spawnDetached(['--job-runner', id, '--resume'], record.logPath);
+    // 续跑是新 detached 进程，必须回写新 PID，否则后续 /jobs kill 会指向已死的旧 PID。
+    if (child.pid)
+        updateJob(id, { pid: child.pid }, { force: true });
+    return getJob(id);
+}

package/dist/jobs/runner.js

@@ -0,0 +1,59 @@
+// Job runner：detached 子进程的内部入口（`mocode --job-runner <id>`）。
+// 复用 runHeadless 跑任务（输出已被 launcher 重定向到 <id>.log），
+// 结束后按退出码回写 job 终态，并 best-effort 发结束通知（MOCODE_NOTIFY_WEBHOOK）。
+import { getJob, updateJob } from './store.js';
+import { deleteCheckpoint } from './checkpoint.js';
+import { runHeadless } from '../headless.js';
+import { sendNotification } from '../notify/index.js';
+import { config } from '../config/index.js';
+export async function runJobRunner(jobId, resume = false) {
+    const record = getJob(jobId);
+    if (!record) {
+        process.stderr.write(`job runner: unknown job ${jobId}\n`);
+        return 1;
+    }
+    const startedAt = Date.now();
+    let exitCode;
+    try {
+        exitCode = await runHeadless({
+            prompt: record.prompt,
+            json: false,
+            verbose: false,
+            skipPermissions: false,
+            ...(record.sessionDir ? { sessionDir: record.sessionDir } : {}),
+            ...(record.worktree ? { worktree: true } : {}),
+            ...(record.botName ? { botName: record.botName } : {}),
+            jobId,
+            ...(resume ? { resumeFromCheckpoint: true } : {}),
+        });
+    }
+    catch (e) {
+        updateJob(jobId, { status: 'failed', finishedAt: new Date().toISOString(), exitCode: 1 }, { force: true });
+        process.stderr.write(`job runner crashed: ${e instanceof Error ? e.message : String(e)}\n`);
+        await sendNotification(config.notifyWebhook, {
+            status: 'failed',
+            prompt: record.prompt,
+            sessionId: jobId,
+            elapsedMs: Date.now() - startedAt,
+            model: config.model,
+        });
+        return 1;
+    }
+    const status = exitCode === 0 ? 'succeeded' : 'failed';
+    // force：被手动 kill 后进程仍可能在此回写，killed 状态由 killBackgroundJob 强制保留。
+    updateJob(jobId, { status, finishedAt: new Date().toISOString(), exitCode }, { force: false });
+    if (status === 'succeeded')
+        deleteCheckpoint(jobId);
+    // 被 kill 的 job（记录仍是 killed）不发常规成功/失败通知，避免与用户意图冲突。
+    const after = getJob(jobId);
+    if (after?.status !== 'killed') {
+        await sendNotification(config.notifyWebhook, {
+            status,
+            prompt: record.prompt,
+            sessionId: jobId,
+            elapsedMs: Date.now() - startedAt,
+            model: config.model,
+        });
+    }
+    return exitCode;
+}

package/dist/jobs/store.js

@@ -0,0 +1,101 @@
+// 后台任务存储：每个 job 一个 <id>.json 记录 + <id>.log 日志（detached 子进程的
+// stdout/stderr 直接重定向到该文件）。
+//
+// 根目录：<sandboxRoot>/.mocode/jobs/。sandboxRoot 与 headless / REPL 同源
+// （入口先 setSandboxRoot，store 动态读取，不缓存）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { getSandboxRoot } from '../sandbox/index.js';
+/** 与 session 同风格的时间戳 id：YYYYMMDD-HHMMSS-rand。 */
+export function createJobId(now = new Date()) {
+    const p = (n, l = 2) => String(n).padStart(l, '0');
+    const stamp = `${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}` +
+        `-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+    return `${stamp}-${randomBytes(2).toString('hex')}`;
+}
+export function jobsRoot() {
+    return path.join(getSandboxRoot() ?? process.cwd(), '.mocode', 'jobs');
+}
+function recordPath(id) {
+    return path.join(jobsRoot(), `${id}.json`);
+}
+export function logPathFor(id) {
+    return path.join(jobsRoot(), `${id}.log`);
+}
+export function saveJob(record) {
+    fs.mkdirSync(jobsRoot(), { recursive: true });
+    // per-file 原子写：先写 tmp 再 rename，避免读侧看到半截 JSON。
+    const target = recordPath(record.id);
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+    fs.renameSync(tmp, target);
+}
+export function getJob(id) {
+    try {
+        return JSON.parse(fs.readFileSync(recordPath(id), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 更新 job 状态。默认保护：记录已是终态 killed 时不被覆盖
+ * （runner 退出回写与手动 kill 存在竞态）。force 可绕过。
+ */
+export function updateJob(id, patch, opts = {}) {
+    const current = getJob(id);
+    if (!current)
+        return null;
+    if (!opts.force && current.status === 'killed' && patch.status !== 'killed')
+        return current;
+    const next = { ...current, ...patch };
+    saveJob(next);
+    return next;
+}
+/** 列出全部 job，新的在前。 */
+export function listJobs() {
+    let files;
+    try {
+        files = fs.readdirSync(jobsRoot());
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const file of files) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(jobsRoot(), file), 'utf8'));
+            // 只认完整 JobRecord，排除 <id>.approval.json / <id>.checkpoint.json 等附属文件。
+            if (typeof parsed.id === 'string' &&
+                typeof parsed.status === 'string' &&
+                typeof parsed.logPath === 'string' &&
+                typeof parsed.prompt === 'string') {
+                records.push(parsed);
+            }
+        }
+        catch {
+            // 跳过损坏记录
+        }
+    }
+    return records.sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+}
+/** 读日志尾部，默认最多 4KB。 */
+export function readJobLog(id, maxBytes = 4096) {
+    const logPath = logPathFor(id);
+    try {
+        const stat = fs.statSync(logPath);
+        const size = stat.size;
+        const start = Math.max(0, size - maxBytes);
+        const fd = fs.openSync(logPath, 'r');
+        const buf = Buffer.alloc(size - start);
+        fs.readSync(fd, buf, 0, buf.length, start);
+        fs.closeSync(fd);
+        return buf.toString('utf8');
+    }
+    catch {
+        return '(no logs yet)';
+    }
+}

package/dist/jobs/worktree.js

@@ -0,0 +1,63 @@
+// Git worktree 隔离：为一次性任务创建 detached worktree（独立工作树 + 独立
+// sandboxRoot），结束后销毁。任务写盘全部落在 worktree，主工作区零污染。
+//
+// 附带 node_modules 链接：新 worktree 没有依赖，跑不了构建/测试；junction(Win)/
+// symlink(POSIX) 指向原仓库 node_modules，删链接不影响目标。
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, rmdirSync, existsSync, symlinkSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { randomBytes } from 'node:crypto';
+function git(args, cwd) {
+    const r = spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true });
+    return { ok: r.status === 0, output: `${r.stdout ?? ''}${r.stderr ?? ''}`.trim() };
+}
+/** 当前 git 仓库根；不是 git 仓库时返回 null。 */
+export function gitTopLevel(cwd = process.cwd()) {
+    const r = git(['rev-parse', '--show-toplevel'], cwd);
+    return r.ok ? resolve(r.output.split('\n')[0] ?? '') : null;
+}
+/**
+ * 创建 detached worktree（基于 HEAD）。
+ * 失败（非 git 仓库 / 有未跟踪冲突）抛错，由调用方决定是否回退普通模式。
+ */
+export function createWorktree() {
+    const repoRoot = gitTopLevel();
+    if (!repoRoot)
+        throw new Error('not a git repository (worktree isolation requires git)');
+    const id = `${Date.now()}-${randomBytes(2).toString('hex')}`;
+    const wtPath = join(repoRoot, '.mocode', 'worktrees', `wt-${id}`);
+    mkdirSync(join(repoRoot, '.mocode', 'worktrees'), { recursive: true });
+    const added = git(['worktree', 'add', '--detach', wtPath, 'HEAD'], repoRoot);
+    if (!added.ok)
+        throw new Error(`git worktree add failed: ${added.output}`);
+    // 链接 node_modules（若主仓库有），否则 worktree 内无法构建。
+    const sourceModules = join(repoRoot, 'node_modules');
+    if (existsSync(sourceModules)) {
+        const link = join(wtPath, 'node_modules');
+        if (process.platform === 'win32') {
+            // directory junction：不需要管理员；rmdir 删链接不动目标。
+            spawnSync('cmd', ['/c', 'mklink', '/J', link, sourceModules], { windowsHide: true });
+        }
+        else {
+            symlinkSync(sourceModules, link, 'dir');
+        }
+    }
+    return { path: wtPath, repoRoot };
+}
+/** 先删 node_modules 链接（防误伤目标），再移除 worktree + prune。 */
+export function removeWorktree(wt) {
+    const link = join(wt.path, 'node_modules');
+    if (existsSync(link)) {
+        try {
+            if (process.platform === 'win32')
+                rmdirSync(link); // junction：仅删链接
+            else
+                rmdirSync(link);
+        }
+        catch {
+            // 链接删不掉仍尝试 worktree remove
+        }
+    }
+    git(['worktree', 'remove', '--force', wt.path], wt.repoRoot);
+    git(['worktree', 'prune'], wt.repoRoot);
+}

package/dist/llm/index.js

@@ -8,6 +8,9 @@ import { sanitizeToolSchemas } from './tool-schema.js';
 import { isMarkedStreamInterrupted } from './stream-interrupt.js';
 import { defaultAnthropicFetch, anthropicChatOnce } from './providers/anthropic.js';
 import { registerModelProvider, getModelProvider, listModelProviders } from './provider.js';
+import { effectiveReasoningEffort } from '../config/index.js';
+import { resolveReasoningParams } from './reasoning.js';
+import { getActivePresetName, readPreset } from '../config/presets.js';
 // 强制关闭第三方调试日志泄漏:openai SDK 在 process.env.DEBUG === 'true' 时用裸
 // console.log 把请求/响应直写 stdout,会污染 TUI 输入框(并泄露 headers/URL)。
 // 仅拦截 'true' 这一开关值——保留 namespace 形式的 DEBUG(如 DEBUG=express:*) 调试能力。
@@ -394,11 +397,11 @@ export function refreshChatTools() {
 // 新增 provider 只需 registerModelProvider,不必改 chat()。
 registerModelProvider({
     name: 'openai',
-    chatOnce: (messages, handlers, signal, tools, runtime) => chatOnce(messages, handlers, signal, tools, runtime),
+    chatOnce: (messages, handlers, signal, tools, runtime, overrides) => chatOnce(messages, handlers, signal, tools, runtime, overrides),
 });
 registerModelProvider({
     name: 'anthropic',
-    chatOnce: (messages, handlers, signal, tools, runtime) => anthropicChatOnce(messages, handlers, signal, tools ?? chatTools, runtime),
+    chatOnce: (messages, handlers, signal, tools, runtime, overrides) => anthropicChatOnce(messages, handlers, signal, tools ?? chatTools, runtime, overrides),
 });
 /**
  * 多 provider 兼容的 cache / reasoning 字段提取。
@@ -474,14 +477,14 @@ function retryErrorCode(error) {
 }
 /** Bind chat dispatch, retries and built-in providers to one explicit runtime. */
 export function createChatTransport(runtime) {
-    return (messages, handlers = {}, signal, toolsOverride) => chatWithRuntime(runtime, messages, handlers, signal, toolsOverride);
+    return (messages, handlers = {}, signal, toolsOverride, overrides) => chatWithRuntime(runtime, messages, handlers, signal, toolsOverride, overrides);
 }
 export function chat(messages, handlers = {}, signal, 
 /** 覆盖默认工具 schema;plan 模式传 planChatTools(只读子集),缺省=全量 chatTools。 */
-toolsOverride) {
-    return chatWithRuntime(defaultProviderRuntime, messages, handlers, signal, toolsOverride);
+toolsOverride, overrides) {
+    return chatWithRuntime(defaultProviderRuntime, messages, handlers, signal, toolsOverride, overrides);
 }
-async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverride) {
+async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverride, overrides) {
     let lastErr;
     // 本次尝试是否已向调用方产出过内容(可见文本 / 工具名)。用于判断「流中途故障可否安全重试」:
     // 重试会从请求头重放,已流出并显示在内容区的半截文本会再写一遍(history 因异常未落,倒是不脏)。
@@ -511,7 +514,7 @@ async function chatWithRuntime(runtime, messages, handlers, signal, toolsOverrid
                 // 未注册的 provider:给出可用名单,避免悄悄落到错误实现。
                 throw new Error(`未知的 LLM provider "${runtime.config.provider}";已注册:${listModelProviders().join(', ') || '(空)'}`);
             }
-            return await provider.chatOnce(messages, guardedHandlers, signal, toolsOverride, runtime);
+            return await provider.chatOnce(messages, guardedHandlers, signal, toolsOverride, runtime, overrides);
         }
         catch (err) {
             lastErr = err;
@@ -584,7 +587,7 @@ export function normalizeImageDetail(messages) {
     return changed ? next : messages;
 }
 /** 单次流式 LLM 请求(无重试);chat() 的内部实现,可被 __setChatCreateImpl 注入桩以做单测。 */
-async function chatOnce(messages, handlers, signal, toolsOverride, runtime = defaultProviderRuntime) {
+async function chatOnce(messages, handlers, signal, toolsOverride, runtime = defaultProviderRuntime, overrides) {
     // 防御:messages 必须至少含一条非空 user 消息,否则 OpenAI/Anthropic 都会 400。
     // compact force 分支曾把所有 user 丢进摘要 → 重建 history 无 user → 下一轮 400。
     // 在 transport 边界拦住所有类似回归(compact / 外部注入 / resume 损坏)。
@@ -611,6 +614,29 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
     // transport 边界消毒:剔除部分后端(kimi-k3@dashscope 实测)整请求 400 拒绝的
     // uniqueItems 关键字。无需改写时返回原引用,前缀缓存逐字节稳定不受影响。
     const activeTools = sanitizeToolSchemas(toolsOverride ?? chatTools);
+    const effort = effectiveReasoningEffort(overrides?.reasoningEffort);
+    // 实时读激活预设(#model-catalog M3):capabilities 只存在预设文件里,启动快照不反映切换。
+    const activePreset = (() => {
+        const n = getActivePresetName();
+        return n ? readPreset(n) : null;
+    })();
+    const reasoningParams = effort === 'auto'
+        ? {}
+        : resolveReasoningParams(effort, {
+            provider: runtimeConfig.provider === 'anthropic' ? 'anthropic' : 'openai',
+            model: runtime.getModel(),
+            maxTokens: runtimeConfig.maxTokens,
+            // 仅当激活预设来自目录且对应当前模型时携带,否则走正则兜底。
+            ...(activePreset && activePreset.catalogProvider && activePreset.model === runtime.getModel()
+                ? {
+                    catalogProviderId: activePreset.catalogProvider,
+                    catalogReasoning: activePreset.capabilities ? activePreset.capabilities.reasoning : undefined,
+                    catalogReasoningOptions: activePreset.capabilities
+                        ? activePreset.capabilities.reasoningOptions
+                        : undefined,
+                }
+                : {}),
+        });
     const stream = await create({
         model: runtime.getModel(),
         messages: normalizeImageDetail(messages),
@@ -626,6 +652,7 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
             : {}),
         ...(runtimeConfig.maxTokens ? { max_tokens: runtimeConfig.maxTokens } : {}),
         ...(runtimeConfig.includeUsage ? { stream_options: { include_usage: true } } : {}),
+        ...reasoningParams,
     }, signal ? { signal } : undefined);
     // content 内嵌 think 标签由独立增量状态机过滤。它只暂存“可能组成标签”的后缀，
     // 因而既能覆盖标签任意位置跨 chunk，也不会让普通正文固定延迟数个字符。

package/dist/llm/providers/anthropic.js

@@ -1,4 +1,5 @@
-import { config, getActiveModel } from '../../config/index.js';
+import { config, effectiveReasoningEffort, getActiveModel } from '../../config/index.js';
+import { resolveReasoningParams } from '../reasoning.js';
 import { markStreamInterrupted } from '../stream-interrupt.js';
 let fetchImplOverride = null;
 /** 仅供单测注入；生产路径使用 Node 18+ 全局 fetch。 */
@@ -179,10 +180,18 @@ function endpoint(baseURL) {
         return base;
     return `${base}/v1/messages`;
 }
-export function buildAnthropicRequest(messages, tools, runtime) {
+export function buildAnthropicRequest(messages, tools, runtime, overrides) {
     const runtimeConfig = runtime?.config ?? config;
     const encoded = encodeAnthropicMessages(messages, runtimeConfig.anthropicPromptCache);
     const anthropicTools = encodeAnthropicTools(tools, runtimeConfig.anthropicPromptCache);
+    const effort = effectiveReasoningEffort(overrides?.reasoningEffort);
+    const reasoningParams = effort === 'auto'
+        ? {}
+        : resolveReasoningParams(effort, {
+            provider: 'anthropic',
+            model: runtime?.getModel() ?? getActiveModel(),
+            maxTokens: runtimeConfig.maxTokens,
+        });
     return {
         model: runtime?.getModel() ?? getActiveModel(),
         max_tokens: runtimeConfig.maxTokens ?? 8192,
@@ -190,6 +199,7 @@ export function buildAnthropicRequest(messages, tools, runtime) {
         system: encoded.system,
         messages: encoded.messages,
         ...(anthropicTools.length > 0 ? { tools: anthropicTools } : {}),
+        ...reasoningParams,
     };
 }
 class AnthropicHttpError extends Error {
@@ -287,7 +297,7 @@ function addLiveCount(text, state) {
     }
 }
 /** Anthropic Messages API 单次请求；外层 chat() 继续统一负责重试。 */
-export async function anthropicChatOnce(messages, handlers, signal, tools, runtime) {
+export async function anthropicChatOnce(messages, handlers, signal, tools, runtime, overrides) {
     const runtimeConfig = runtime?.config ?? config;
     const fetchImpl = runtime?.clientState.anthropicFetchImpl ?? defaultAnthropicFetch;
     const response = await fetchImpl(endpoint(runtimeConfig.baseURL), {
@@ -298,7 +308,7 @@ export async function anthropicChatOnce(messages, handlers, signal, tools, runti
             'x-api-key': runtimeConfig.apiKey,
             'anthropic-version': process.env.ANTHROPIC_VERSION || '2023-06-01',
         },
-        body: JSON.stringify(buildAnthropicRequest(messages, tools, runtime)),
+        body: JSON.stringify(buildAnthropicRequest(messages, tools, runtime, overrides)),
         signal,
     });
     if (!response.ok)