mocode-ai 1.4.2 → 1.4.3

package/dist/agent/stages/tool-dispatcher.js

@@ -0,0 +1,341 @@
+import { ADD_TOOL_GROUPS_TOOL_NAME } from '../../config/profiles.js';
+import { t } from '../../i18n/index.js';
+import { checkPermission as defaultCheckPermission } from '../../permissions/index.js';
+import { jailResolve as defaultJailResolve } from '../../sandbox/index.js';
+import { summarizeToolArguments } from '../../session/index.js';
+import { getPlanDisabledTools } from '../../tools/constants.js';
+import { defaultToolRuntime } from '../../tools/registry.js';
+import { validateToolArguments } from '../../tools/validation.js';
+import { deniedOutcome, isParallelTool, isResourceLockedCall, parseArgs, readDiffContext } from '../tool-helpers.js';
+const DEFAULT_DEPENDENCIES = {
+    toolRuntime: defaultToolRuntime,
+    checkPermission: defaultCheckPermission,
+    jailResolve: defaultJailResolve,
+};
+class LegacyCompatibleToolDispatcher {
+    implementation;
+    dependencies;
+    constructor(implementation, dependencies = {}) {
+        this.implementation = implementation;
+        this.dependencies = { ...DEFAULT_DEPENDENCIES, ...dependencies };
+    }
+    async dispatch(request) {
+        const { toolRuntime, checkPermission, jailResolve } = this.dependencies;
+        const calls = request.calls;
+        const argumentSummaries = calls.map((call) => summarizeToolArguments(call.arguments));
+        const orderedResults = new Array(calls.length);
+        const modelAttachments = [];
+        const changedFiles = new Set();
+        const record = (index, outcome) => {
+            orderedResults[index] = { call: calls[index], outcome };
+            if (outcome.status === 'success' && outcome.modelAttachments?.length) {
+                modelAttachments.push(...outcome.modelAttachments);
+            }
+            for (const file of outcome.changedFiles ?? [])
+                changedFiles.add(file);
+        };
+        const traceEnd = (index, outcome) => request.onEvent({
+            type: 'trace_end',
+            call: calls[index],
+            callIndex: index,
+            argumentSummary: argumentSummaries[index],
+            outcome,
+        });
+        const execute = (call, hint, onLockAcquired) => toolRuntime.executeToolOutcome(call.name, call.arguments, request.signal, {
+            callId: call.id,
+            allowedToolNames: request.currentAllowedToolNames(),
+            delegation: request.delegation(),
+            ...(hint ? { argumentErrorHint: hint } : {}),
+            ...(onLockAcquired ? { onLockAcquired } : {}),
+        });
+        const executionEvents = (index, parsed, outcome) => {
+            request.onEvent({ type: 'usage', usage: outcome.usage });
+            request.onEvent({ type: 'host_outcome', call: calls[index], parsed: parsed ?? {}, outcome });
+            traceEnd(index, outcome);
+        };
+        const resultEvent = (index, outcome, parsed, diff = { preWriteOld: null, editStartLine: 1 }, includeContextState = true) => request.onEvent({
+            type: 'result',
+            call: calls[index],
+            outcome,
+            parsed,
+            diff,
+            succeeded: outcome.status === 'success',
+            includeContextState,
+        });
+        const invalidate = (outcome) => {
+            const files = [...new Set([...(outcome.changedFiles ?? []), ...(outcome.staleFiles ?? [])])];
+            if (files.length > 0)
+                request.onEvent({ type: 'invalidate', files });
+        };
+        for (let index = 0; index < calls.length; index++) {
+            request.onEvent({
+                type: 'call_start',
+                call: calls[index],
+                callIndex: index,
+                argumentSummary: argumentSummaries[index],
+            });
+        }
+        const hasRouteBarrier = calls.some((call) => call.name === ADD_TOOL_GROUPS_TOOL_NAME);
+        if (hasRouteBarrier) {
+            const mixedCall = calls.length !== 1;
+            for (let index = 0; index < calls.length; index++) {
+                const call = calls[index];
+                request.onEvent({ type: 'header', call });
+                const parsed = parseArgs(call.arguments);
+                let outcome;
+                if (mixedCall) {
+                    const isControl = call.name === ADD_TOOL_GROUPS_TOOL_NAME;
+                    outcome = {
+                        status: 'denied',
+                        code: isControl ? 'INVALID_ARGUMENTS' : 'TOOL_DISABLED',
+                        retryable: false,
+                        output: isControl
+                            ? '错误:add_tool_groups 必须在一个独立的 model step 中单独调用；本次没有扩容。'
+                            : `错误:同一响应包含 add_tool_groups，工具 ${call.name} 未执行。请等待扩容结果后在下一 step 重试。`,
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                }
+                else if (request.isDenied(call.name)) {
+                    outcome = {
+                        status: 'denied',
+                        code: 'TOOL_DISABLED',
+                        retryable: false,
+                        output: `错误:当前 tool policy snapshot 不允许调用 ${call.name}。`,
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                }
+                else if (!request.expandToolGroups) {
+                    outcome = {
+                        status: 'denied',
+                        code: 'TOOL_DISABLED',
+                        retryable: false,
+                        output: '错误:当前 Agent 未启用动态工具策略，无法调用 add_tool_groups。',
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                }
+                else if (!parsed ||
+                    !Array.isArray(parsed.groups) ||
+                    parsed.groups.length === 0 ||
+                    typeof parsed.reason !== 'string' ||
+                    !parsed.reason.trim()) {
+                    outcome = {
+                        status: 'error',
+                        code: 'INVALID_ARGUMENTS',
+                        retryable: false,
+                        output: '错误:add_tool_groups 需要非空 groups 数组和非空 reason。',
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                }
+                else {
+                    const expansion = request.expandToolGroups(parsed.groups, parsed.reason);
+                    const succeeded = expansion.added.length > 0;
+                    const details = [
+                        succeeded
+                            ? `Tool policy expanded to v${expansion.snapshot.version}; added groups: ${expansion.added.join(', ')}.`
+                            : `Tool policy was not expanded (still v${expansion.snapshot.version}).`,
+                        expansion.rejected.length > 0 ? `Rejected: ${expansion.rejected.join('; ')}.` : '',
+                        succeeded ? 'The added tool schemas become available on the next model step.' : '',
+                    ]
+                        .filter(Boolean)
+                        .join('\n');
+                    outcome = {
+                        status: succeeded ? 'success' : 'error',
+                        code: succeeded ? 'OK' : 'INVALID_ARGUMENTS',
+                        retryable: false,
+                        output: details,
+                        changedFiles: [],
+                        durationMs: 0,
+                    };
+                    request.onEvent({
+                        type: 'route_expand',
+                        fromVersion: request.policy.toolPolicy?.version,
+                        expansion,
+                        requestedGroups: parsed.groups,
+                        reason: parsed.reason,
+                        status: outcome.status,
+                    });
+                }
+                record(index, outcome);
+                request.onEvent({ type: 'host_outcome', call, parsed: parsed ?? {}, outcome });
+                resultEvent(index, outcome, null);
+                traceEnd(index, outcome);
+            }
+        }
+        let index = hasRouteBarrier ? calls.length : 0;
+        while (index < calls.length) {
+            const current = calls[index];
+            if (request.isDenied(current.name)) {
+                request.onEvent({ type: 'header', call: current });
+                const output = t('task.disabled');
+                const outcome = {
+                    status: 'denied',
+                    code: 'TOOL_DISABLED',
+                    retryable: false,
+                    output,
+                    changedFiles: [],
+                    durationMs: 0,
+                };
+                record(index, outcome);
+                resultEvent(index, outcome, null);
+                traceEnd(index, outcome);
+                index++;
+                continue;
+            }
+            if (isParallelTool(current.name, toolRuntime)) {
+                let end = index;
+                while (end < calls.length && isParallelTool(calls[end].name, toolRuntime) && !request.isDenied(calls[end].name))
+                    end++;
+                const batch = calls.slice(index, end);
+                for (const call of batch)
+                    request.onEvent({ type: 'header', call });
+                request.onEvent({ type: 'start', tool: batch[0].name });
+                const started = batch.map((call) => execute(call));
+                for (let offset = 0; offset < batch.length; offset++) {
+                    const callIndex = index + offset;
+                    const outcome = await started[offset];
+                    record(callIndex, outcome);
+                    executionEvents(callIndex, parseArgs(batch[offset].arguments), outcome);
+                    resultEvent(callIndex, outcome, null);
+                }
+                request.onEvent({ type: 'done' });
+                index = end;
+                continue;
+            }
+            if (isResourceLockedCall(current, toolRuntime) &&
+                !(request.policy.mode === 'plan' && getPlanDisabledTools().has(current.name))) {
+                let end = index;
+                while (end < calls.length &&
+                    isResourceLockedCall(calls[end], toolRuntime) &&
+                    !request.isDenied(calls[end].name) &&
+                    !(request.policy.mode === 'plan' && getPlanDisabledTools().has(calls[end].name)))
+                    end++;
+                const batch = calls.slice(index, end);
+                const entries = [];
+                for (let offset = 0; offset < batch.length; offset++) {
+                    const call = batch[offset];
+                    const parsed = parseArgs(call.arguments);
+                    const tool = toolRuntime.findTool(call.name);
+                    const argumentsValid = tool && parsed !== null ? validateToolArguments(tool, parsed).valid : false;
+                    let denied;
+                    if (tool && argumentsValid) {
+                        const decision = await checkPermission(tool, parsed ?? {}, request.signal, {
+                            prompt: request.permissionPrompt,
+                        });
+                        request.onEvent({ type: 'permission', call, callIndex: index + offset, decision });
+                        if (decision === 'deny')
+                            denied = deniedOutcome(call.name);
+                    }
+                    entries.push({
+                        call,
+                        parsed,
+                        diff: { preWriteOld: null, editStartLine: 1 },
+                        ...(denied ? { denied } : {}),
+                    });
+                }
+                for (const entry of entries)
+                    request.onEvent({ type: 'header', call: entry.call });
+                const firstAllowed = entries.find((entry) => !entry.denied);
+                if (firstAllowed)
+                    request.onEvent({ type: 'start', tool: firstAllowed.call.name });
+                const started = entries.map((entry) => {
+                    if (entry.denied)
+                        return Promise.resolve(entry.denied);
+                    return execute(entry.call, request.argumentErrorHint(entry.call.name), (lockedArgs) => {
+                        entry.diff = readDiffContext(entry.call, lockedArgs, jailResolve);
+                    });
+                });
+                for (let offset = 0; offset < entries.length; offset++) {
+                    const callIndex = index + offset;
+                    const entry = entries[offset];
+                    const outcome = await started[offset];
+                    record(callIndex, outcome);
+                    executionEvents(callIndex, entry.parsed, outcome);
+                    resultEvent(callIndex, outcome, entry.denied ? null : entry.parsed, entry.diff);
+                    invalidate(outcome);
+                }
+                if (firstAllowed)
+                    request.onEvent({ type: 'done' });
+                index = end;
+                continue;
+            }
+            const call = calls[index];
+            if (request.policy.mode === 'plan' && getPlanDisabledTools().has(call.name)) {
+                request.onEvent({ type: 'header', call });
+                const output = `错误:计划模式下禁用工具 ${call.name}(仅读探查,不改动文件 / 不跑命令)`;
+                const outcome = {
+                    status: 'denied',
+                    code: 'MODE_DENIED',
+                    retryable: false,
+                    output,
+                    changedFiles: [],
+                    durationMs: 0,
+                };
+                record(index, outcome);
+                resultEvent(index, outcome, null, undefined, false);
+                traceEnd(index, outcome);
+                index++;
+                continue;
+            }
+            const parsed = parseArgs(call.arguments);
+            const tool = toolRuntime.findTool(call.name);
+            const argumentsValid = tool && parsed !== null ? validateToolArguments(tool, parsed).valid : false;
+            if (tool && argumentsValid) {
+                const decision = await checkPermission(tool, parsed ?? {}, request.signal, {
+                    prompt: request.permissionPrompt,
+                });
+                request.onEvent({ type: 'permission', call, callIndex: index, decision });
+                if (decision === 'deny') {
+                    request.onEvent({ type: 'header', call });
+                    const outcome = deniedOutcome(call.name);
+                    record(index, outcome);
+                    resultEvent(index, outcome, null);
+                    traceEnd(index, outcome);
+                    index++;
+                    continue;
+                }
+            }
+            request.onEvent({ type: 'header', call });
+            const mutationParsed = toolRuntime.isFileMutationTool(call.name) ? parsed : null;
+            let diff = readDiffContext(call, mutationParsed, jailResolve);
+            request.onEvent({ type: 'start', tool: call.name });
+            const outcome = await execute(call, request.argumentErrorHint(call.name), (lockedArgs) => {
+                if (mutationParsed)
+                    diff = readDiffContext(call, lockedArgs, jailResolve);
+            });
+            record(index, outcome);
+            executionEvents(index, parsed, outcome);
+            request.onEvent({ type: 'done' });
+            resultEvent(index, outcome, mutationParsed, diff);
+            invalidate(outcome);
+            index++;
+        }
+        if (orderedResults.some((result) => !result)) {
+            throw new Error('Tool dispatcher did not settle every provider tool call.');
+        }
+        return {
+            orderedResults: orderedResults,
+            changedFiles: [...changedFiles],
+            modelAttachments,
+        };
+    }
+}
+class LegacyToolDispatcher extends LegacyCompatibleToolDispatcher {
+    constructor(dependencies = {}) {
+        super('legacy', dependencies);
+    }
+}
+class StagedToolDispatcher extends LegacyCompatibleToolDispatcher {
+    constructor(dependencies = {}) {
+        super('staged', dependencies);
+    }
+}
+export function createLegacyToolDispatcher(dependencies = {}) {
+    return new LegacyToolDispatcher(dependencies);
+}
+export function createStagedToolDispatcher(dependencies = {}) {
+    return new StagedToolDispatcher(dependencies);
+}

package/dist/agent/tool-helpers.js

@@ -9,7 +9,7 @@
  * pushToolResult 依赖 context/relevance/lifecycle/scheduler 的 metadata 登记,不改写历史正文。
  */
 import { readFileSync } from 'node:fs';
-import { findTool, getToolCapabilities } from '../tools/registry.js';
+import { defaultToolRuntime } from '../tools/registry.js';
 import { jailResolve } from '../sandbox/index.js';
 import { contextState } from '../session/compact.js';
 import { capToolResultForHistory } from '../session/compact.js';
@@ -46,19 +46,19 @@ export function isToolResultsNoise(content) {
     return /^(?:\s*Tool results:\s*)+$/i.test(content.trim());
 }
 /** 只有显式声明 parallel 且无需权限确认的工具才进入普通并发组。 */
-export function isParallelTool(name) {
-    const tool = findTool(name);
-    return !!tool && (tool.risk ?? 'safe') === 'safe' && getToolCapabilities(tool).concurrency === 'parallel';
+export function isParallelTool(name, toolRuntime = defaultToolRuntime) {
+    const tool = toolRuntime.findTool(name);
+    return !!tool && (tool.risk ?? 'safe') === 'safe' && toolRuntime.getToolCapabilities(tool).concurrency === 'parallel';
 }
 /** resource-locked 工具先顺序完成权限预检，再依赖 canonical resource lock 并发执行。 */
-export function isResourceLockedTool(name) {
-    const tool = findTool(name);
-    return !!tool && getToolCapabilities(tool).concurrency === 'resource-locked';
+export function isResourceLockedTool(name, toolRuntime = defaultToolRuntime) {
+    const tool = toolRuntime.findTool(name);
+    return !!tool && toolRuntime.getToolCapabilities(tool).concurrency === 'resource-locked';
 }
-export function isResourceLockedCall(call) {
+export function isResourceLockedCall(call, toolRuntime = defaultToolRuntime) {
     // sub-agent 是长时全域操作(嵌套 agent 与主 agent 同权,可写任意文件/跑任意命令),
     // 不进 mutation 并发批:逐个串行执行,避免两个子 agent 同时改工作区。
-    return call.name !== 'sub-agent' && isResourceLockedTool(call.name);
+    return call.name !== 'sub-agent' && isResourceLockedTool(call.name, toolRuntime);
 }
 /** 权限拒绝时的结构化 ToolOutcome(供调度器统一回灌,不抛错中断循环)。 */
 export function deniedOutcome(name) {
@@ -72,7 +72,7 @@ export function deniedOutcome(name) {
 /** mutation 执行前读旧内容供 diff:write_file 取整文件旧内容(不存在→null=新建),
  * edit_file 取 old_string 起始行号(供 diff 显示真实文件行号)。读不到则 diff 退化为相对行号。
  * 非 mutation 或参数非法返 { preWriteOld: null, editStartLine: 1 }。失败不阻断。 */
-export function readDiffContext(tc, parsed) {
+export function readDiffContext(tc, parsed, resolvePath = jailResolve) {
     if (!parsed)
         return { preWriteOld: null, editStartLine: 1 };
     const p = String(parsed.path ?? '');
@@ -81,7 +81,7 @@ export function readDiffContext(tc, parsed) {
     if (tc.name === 'write_file') {
         try {
             // jailResolve:沙箱越界(../../、绝对外圈、软链出圈)抛错 → catch 兜底返 null,不泄露牢外内容(TOCTOU)
-            return { preWriteOld: readFileSync(jailResolve(p), 'utf8'), editStartLine: 1 };
+            return { preWriteOld: readFileSync(resolvePath(p), 'utf8'), editStartLine: 1 };
         }
         catch {
             return { preWriteOld: null, editStartLine: 1 }; // 文件不存在(新建)、不可读 或 沙箱越界(不泄露)
@@ -95,7 +95,7 @@ export function readDiffContext(tc, parsed) {
             .replace(/\r/g, '\n');
         try {
             // jailResolve:同上,沙箱越界抛错 → catch 兜底,不泄露牢外内容
-            const raw = readFileSync(jailResolve(p), 'utf8');
+            const raw = readFileSync(resolvePath(p), 'utf8');
             const data = raw.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
             const idx = oldStr ? data.indexOf(oldStr) : -1;
             return {

package/dist/agent/tool-turn.js

@@ -0,0 +1,87 @@
+import { isToolResultsNoise } from './tool-helpers.js';
+const PLAN_NAG_THRESHOLD = 3;
+const PLAN_NAG_TEXT = '[mocode] Reminder: you have an active plan in notes.md but have not updated it recently. ' +
+    'If you finished a step, call plan_update to check it off (keep at most one in_progress); ' +
+    'if the whole plan is done, let plan_update settle it to ## Done:. If the plan changed scope, update it to match reality.';
+/** Owns tool-turn history publication, transaction settlement, plan nag, attachments and checkpoint ordering. */
+export async function runToolTurn(input) {
+    const { opts, ctx, historyManager, result, stream, step, maxSteps, planState, turnLifecycle, cancellationLifecycle, terminationPolicy, rebuildHistoryIndexes, dispatch, } = input;
+    const { hooks, signal } = opts;
+    turnLifecycle.addToolCalls(result.toolCalls.length);
+    if (result.content && isToolResultsNoise(result.content)) {
+        result.content = null;
+        stream.mode = 'idle';
+        stream.gotText = false;
+        stream.lastChar = '';
+    }
+    if (stream.mode !== 'idle' && stream.lastChar !== '\n')
+        hooks.onTextEnd?.();
+    historyManager.appendAssistantTurn({ content: result.content, toolCalls: result.toolCalls });
+    const toolBatch = historyManager.beginToolBatch(result.toolCalls);
+    const workingHistory = toolBatch.workingMessages;
+    try {
+        const toolResultStartIdx = workingHistory.length;
+        const notesMtimeBefore = ctx.getNotesMtime();
+        const narration = result.content?.trim() ?? '';
+        if (narration) {
+            turnLifecycle.emitTrace('narration', {
+                chars: [...narration].length,
+                toolCalls: result.toolCalls.length,
+                step,
+            });
+        }
+        const modelAttachments = [];
+        await dispatch(workingHistory, modelAttachments);
+        const notesMtimeAfter = ctx.getNotesMtime();
+        if (notesMtimeAfter !== notesMtimeBefore) {
+            planState.stepsSincePlanTouch = 0;
+        }
+        else {
+            planState.stepsSincePlanTouch += 1;
+            if (planState.stepsSincePlanTouch >= PLAN_NAG_THRESHOLD) {
+                const activePlan = ctx.extractActivePlanSection();
+                const firstToolMsg = workingHistory[toolResultStartIdx];
+                if (activePlan && firstToolMsg && firstToolMsg.role === 'tool' && typeof firstToolMsg.content === 'string') {
+                    firstToolMsg.content = `${PLAN_NAG_TEXT}\n\n${firstToolMsg.content}`;
+                }
+                planState.stepsSincePlanTouch = 0;
+            }
+        }
+        let attachmentMessage;
+        if (modelAttachments.length > 0) {
+            const names = modelAttachments.map((attachment) => attachment.name).join(', ');
+            const content = [
+                {
+                    type: 'text',
+                    text: `The view_image tool loaded the following visual input: ${names}. Analyze the attached image content directly.`,
+                },
+                ...modelAttachments.map((attachment) => ({
+                    type: 'image_url',
+                    image_url: {
+                        url: attachment.dataUrl,
+                        ...(attachment.detail === 'low' || attachment.detail === 'high' ? { detail: attachment.detail } : {}),
+                    },
+                })),
+            ];
+            attachmentMessage = { role: 'user', content };
+        }
+        toolBatch.commit(attachmentMessage);
+    }
+    catch (error) {
+        toolBatch.rollback();
+        rebuildHistoryIndexes();
+        throw error;
+    }
+    hooks.onToolBatchEnd?.();
+    cancellationLifecycle.checkpoint();
+    const batchDecision = terminationPolicy.decide({
+        phase: 'tool_batch_committed',
+        step,
+        maxSteps,
+        aborted: signal?.aborted === true,
+        modelResult: result,
+    });
+    if (batchDecision.kind !== 'continue') {
+        throw new Error(`Unexpected termination after committed tool batch: ${batchDecision.kind}.`);
+    }
+}