@xcanwin/manyoyo 5.6.8 → 5.6.10

package/lib/web/server.js

@@ -321,6 +321,7 @@ function hasAgentConversationHistory(history) {
     for (const message of messages) {
         if (!message || typeof message !== 'object') continue;
         if (message.mode !== 'agent') continue;
+        if (message.streamTrace === true) continue;
         if (message.role === 'user' || message.role === 'assistant') {
             return true;
         }
@@ -339,7 +340,12 @@ function clipAgentContextMessageText(text) {
 function buildAgentPromptWithHistory(history, prompt) {
     const sessionHistory = history && Array.isArray(history.messages) ? history.messages : [];
     const relevantMessages = sessionHistory
-        .filter(message => message && message.mode === 'agent' && (message.role === 'user' || message.role === 'assistant'))
+        .filter(message => (
+            message
+            && message.mode === 'agent'
+            && message.streamTrace !== true
+            && (message.role === 'user' || message.role === 'assistant')
+        ))
         .slice(-WEB_AGENT_CONTEXT_MAX_MESSAGES);
     if (!relevantMessages.length) {
         return String(prompt || '');
@@ -370,6 +376,305 @@ function buildAgentPromptWithHistory(history, prompt) {
     ].join('\n');
 }
 
+function prepareCodexTraceEvent(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+
+    const eventType = typeof payload.type === 'string' ? payload.type : '';
+    const item = payload.item && typeof payload.item === 'object' && !Array.isArray(payload.item)
+        ? payload.item
+        : {};
+    const itemType = typeof item.type === 'string' ? item.type : '';
+    const text = pickFirstString(
+        item.title,
+        item.summary,
+        item.text,
+        item.name,
+        item.command,
+        payload.message,
+        payload.text
+    );
+    const toolName = pickFirstString(
+        item.name,
+        item.tool_name,
+        item.tool,
+        item.command
+    );
+    const commandText = pickFirstString(item.command);
+    const mcpServer = pickFirstString(item.server);
+    const mcpTool = pickFirstString(item.tool);
+    const itemStatus = pickFirstString(item.status);
+
+    function shortenText(value, maxChars = 140) {
+        const raw = clipText(stripAnsi(String(value || '')).replace(/\s+/g, ' ').trim(), maxChars);
+        return raw.trim();
+    }
+
+    function summarizeArguments(args) {
+        if (!args || typeof args !== 'object' || Array.isArray(args)) {
+            return '';
+        }
+        const parts = [];
+        for (const [key, value] of Object.entries(args)) {
+            if (value === undefined || value === null) continue;
+            if (typeof value === 'string') {
+                const textValue = value.trim();
+                if (!textValue) continue;
+                parts.push(`${key}=${shortenText(textValue, 80)}`);
+                continue;
+            }
+            if (typeof value === 'number' || typeof value === 'boolean') {
+                parts.push(`${key}=${String(value)}`);
+            }
+        }
+        return parts.slice(0, 3).join(', ');
+    }
+
+    function pickDisplayStatus(defaultStatus) {
+        const status = String(itemStatus || defaultStatus || '').trim();
+        return status || '';
+    }
+
+    function createTraceEvent(kind, textValue, extra = {}) {
+        const normalizedText = String(textValue || '').trim();
+        if (!normalizedText) {
+            return null;
+        }
+        return {
+            provider: 'codex',
+            kind,
+            eventType,
+            itemType: itemType || '',
+            text: normalizedText,
+            ...extra
+        };
+    }
+
+    if (eventType === 'thread.started') {
+        return createTraceEvent('thread', '[会话] Codex 已开始处理', {
+            phase: 'started',
+            status: 'started'
+        });
+    }
+    if (eventType === 'thread.completed') {
+        return createTraceEvent('thread', '[会话] Codex 已完成当前任务', {
+            phase: 'completed',
+            status: 'completed'
+        });
+    }
+    if (eventType === 'turn.started') {
+        return createTraceEvent('turn', '[回合] 开始生成响应', {
+            phase: 'started',
+            status: 'started'
+        });
+    }
+    if (eventType === 'turn.completed') {
+        return createTraceEvent('turn', '[回合] 响应完成', {
+            phase: 'completed',
+            status: 'completed'
+        });
+    }
+    if (eventType === 'item.started') {
+        if (itemType === 'tool_call') {
+            return createTraceEvent('tool', `[工具开始] ${toolName || 'tool_call'}`, {
+                phase: 'started',
+                status: pickDisplayStatus('in_progress'),
+                toolName: toolName || 'tool_call'
+            });
+        }
+        if (itemType === 'command_execution') {
+            return createTraceEvent('command', `[命令开始] ${commandText || 'command_execution'}`, {
+                phase: 'started',
+                status: pickDisplayStatus('in_progress'),
+                command: commandText || 'command_execution'
+            });
+        }
+        if (itemType === 'mcp_tool_call') {
+            const summary = summarizeArguments(item.arguments);
+            return createTraceEvent(
+                'mcp',
+                summary
+                    ? `[MCP开始] ${mcpServer || 'mcp'}.${mcpTool || 'tool'} (${summary})`
+                    : `[MCP开始] ${mcpServer || 'mcp'}.${mcpTool || 'tool'}`,
+                {
+                    phase: 'started',
+                    status: pickDisplayStatus('in_progress'),
+                    server: mcpServer || 'mcp',
+                    tool: mcpTool || 'tool',
+                    arguments: item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
+                        ? item.arguments
+                        : null,
+                    argumentSummary: summary
+                }
+            );
+        }
+        if (itemType === 'reasoning') {
+            return createTraceEvent('status', text ? `[状态] ${text}` : '[状态] Codex 正在分析', {
+                phase: 'started',
+                status: pickDisplayStatus('in_progress'),
+                detail: text || 'Codex 正在分析'
+            });
+        }
+        if (itemType === 'agent_message') {
+            return createTraceEvent('agent_message', text ? `[说明] ${text}` : '[回复] 正在生成最终答复', {
+                phase: 'started',
+                status: pickDisplayStatus('in_progress'),
+                detail: text || '正在生成最终答复'
+            });
+        }
+        return createTraceEvent('event', text ? `[事件开始] ${text}` : `[事件开始] ${itemType || eventType}`, {
+            phase: 'started',
+            status: pickDisplayStatus('in_progress'),
+            detail: text || itemType || eventType
+        });
+    }
+    if (eventType === 'item.completed') {
+        if (itemType === 'tool_call') {
+            return createTraceEvent('tool', `[工具完成] ${toolName || 'tool_call'}`, {
+                phase: 'completed',
+                status: pickDisplayStatus('completed'),
+                toolName: toolName || 'tool_call'
+            });
+        }
+        if (itemType === 'command_execution') {
+            const suffix = itemStatus || (typeof item.exit_code === 'number' ? `exit=${item.exit_code}` : 'completed');
+            return createTraceEvent('command', `[命令完成] ${commandText || 'command_execution'} (${suffix})`, {
+                phase: 'completed',
+                status: pickDisplayStatus(suffix),
+                command: commandText || 'command_execution',
+                exitCode: typeof item.exit_code === 'number' ? item.exit_code : null
+            });
+        }
+        if (itemType === 'mcp_tool_call') {
+            const summary = summarizeArguments(item.arguments);
+            return createTraceEvent(
+                'mcp',
+                summary
+                    ? `[MCP完成] ${mcpServer || 'mcp'}.${mcpTool || 'tool'} (${summary})`
+                    : `[MCP完成] ${mcpServer || 'mcp'}.${mcpTool || 'tool'}`,
+                {
+                    phase: 'completed',
+                    status: pickDisplayStatus('completed'),
+                    server: mcpServer || 'mcp',
+                    tool: mcpTool || 'tool',
+                    arguments: item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
+                        ? item.arguments
+                        : null,
+                    argumentSummary: summary,
+                    result: item.result !== undefined ? item.result : null,
+                    error: item.error !== undefined ? item.error : null
+                }
+            );
+        }
+        if (itemType === 'reasoning') {
+            return createTraceEvent('status', text ? `[状态] ${text}` : '', {
+                phase: 'completed',
+                status: pickDisplayStatus('completed'),
+                detail: text || ''
+            });
+        }
+        if (itemType === 'agent_message') {
+            return createTraceEvent('agent_message', text ? `[说明] ${text}` : '[回复] 已生成', {
+                phase: 'completed',
+                status: pickDisplayStatus('completed'),
+                detail: text || '已生成'
+            });
+        }
+        return createTraceEvent('event', text ? `[事件完成] ${text}` : `[事件完成] ${itemType || eventType}`, {
+            phase: 'completed',
+            status: pickDisplayStatus('completed'),
+            detail: text || itemType || eventType
+        });
+    }
+    if (eventType === 'error') {
+        return createTraceEvent('error', text ? `[错误] ${text}` : '[错误] Codex 返回了错误事件', {
+            status: 'error',
+            detail: text || 'Codex 返回了错误事件'
+        });
+    }
+
+    return createTraceEvent('event', `[事件] ${eventType}`, {
+        status: itemStatus || '',
+        detail: eventType
+    });
+}
+
+async function prepareWebAgentExecution(ctx, state, containerName, prompt) {
+    const history = loadWebSessionHistory(state.webHistoryDir, containerName);
+    const normalizedTemplate = normalizeAgentPromptCommandTemplate(history.agentPromptCommand, 'agentPromptCommand');
+    if (normalizedTemplate !== history.agentPromptCommand) {
+        history.agentPromptCommand = normalizedTemplate;
+        saveWebSessionHistory(state.webHistoryDir, containerName, history);
+    }
+    if (!isAgentPromptCommandEnabled(history.agentPromptCommand)) {
+        throw new Error('当前会话未配置 agentPromptCommand');
+    }
+
+    await ensureWebContainer(ctx, state, containerName);
+    const agentMeta = getAgentRuntimeMeta(history);
+    const hasPriorConversation = hasAgentConversationHistory(history);
+    let resumeAttempted = false;
+    let resumeSucceeded = false;
+    let resumeError = '';
+
+    if (hasPriorConversation && agentMeta.resumeSupported && agentMeta.resumeCommand) {
+        resumeAttempted = true;
+        const resumeResult = await execCommandInWebContainer(ctx, containerName, agentMeta.resumeCommand);
+        if (resumeResult.exitCode === 0) {
+            resumeSucceeded = true;
+        } else {
+            resumeError = clipText(String(resumeResult.output || '(无输出)'), 1200);
+        }
+    }
+
+    const effectivePrompt = resumeSucceeded
+        ? prompt
+        : buildAgentPromptWithHistory(history, prompt);
+    const command = buildWebAgentExecCommand(history.agentPromptCommand, effectivePrompt, agentMeta.agentProgram);
+    const contextMode = resumeSucceeded ? 'resume' : (hasPriorConversation ? 'history-injected' : 'first-turn');
+
+    return {
+        history,
+        agentMeta,
+        command,
+        contextMode,
+        resumeAttempted,
+        resumeSucceeded,
+        resumeError
+    };
+}
+
+function finalizeWebAgentExecution(state, containerName, history, agentMeta, meta, result) {
+    appendWebSessionMessage(state.webHistoryDir, containerName, 'assistant', result.output, {
+        exitCode: result.exitCode,
+        mode: 'agent',
+        contextMode: meta.contextMode,
+        resumeAttempted: meta.resumeAttempted,
+        resumeSucceeded: meta.resumeSucceeded,
+        interrupted: result.interrupted === true
+    });
+    patchWebSessionAgentState(state.webHistoryDir, containerName, {
+        agentProgram: agentMeta.agentProgram,
+        resumeSupported: agentMeta.resumeSupported,
+        lastResumeAt: meta.resumeAttempted ? new Date().toISOString() : history.lastResumeAt || null,
+        lastResumeOk: meta.resumeAttempted ? meta.resumeSucceeded : history.lastResumeOk,
+        lastResumeError: meta.resumeAttempted ? (meta.resumeSucceeded ? '' : meta.resumeError) : history.lastResumeError || ''
+    });
+}
+
+function appendWebAgentTraceMessage(webHistoryDir, containerName, content, extra = {}) {
+    const text = String(content || '').trim();
+    if (!text) {
+        return;
+    }
+    appendWebSessionMessage(webHistoryDir, containerName, 'assistant', text, {
+        mode: 'agent',
+        streamTrace: true,
+        ...extra
+    });
+}
+
 function secureStringEqual(a, b) {
     const aStr = String(a || '');
     const bStr = String(b || '');
@@ -1177,6 +1482,150 @@ async function execCommandInWebContainer(ctx, containerName, command) {
     });
 }
 
+async function execAgentInWebContainerStream(ctx, state, containerName, command, options = {}) {
+    const opts = options && typeof options === 'object' ? options : {};
+    const agentProgram = typeof opts.agentProgram === 'string' ? opts.agentProgram : '';
+    const onEvent = typeof opts.onEvent === 'function' ? opts.onEvent : () => {};
+    const process = spawn(
+        ctx.dockerCmd,
+        ['exec', containerName, '/bin/bash', '-lc', command],
+        { stdio: ['ignore', 'pipe', 'pipe'] }
+    );
+
+    const runState = {
+        containerName,
+        process,
+        command,
+        startedAt: new Date().toISOString(),
+        stopping: false
+    };
+    state.agentRuns.set(containerName, runState);
+
+    return await new Promise((resolve, reject) => {
+        const MAX_RAW_OUTPUT_CHARS = 32 * 1024 * 1024;
+        let stdoutOutput = '';
+        let stderrOutput = '';
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        let stdoutPending = '';
+        let stderrPending = '';
+        function appendChunk(chunk, target) {
+            if (!chunk) return;
+            const text = chunk.toString('utf-8');
+            if (!text) return;
+            if (target.value.length >= MAX_RAW_OUTPUT_CHARS) {
+                target.truncated = true;
+                return;
+            }
+            const remain = MAX_RAW_OUTPUT_CHARS - target.value.length;
+            if (text.length > remain) {
+                target.value += text.slice(0, remain);
+                target.truncated = true;
+                return;
+            }
+            target.value += text;
+        }
+
+        function emitStdoutTraceLine(line) {
+            const rawLine = String(line || '').trim();
+            if (!rawLine) {
+                return;
+            }
+            if (agentProgram === 'codex') {
+                let payload = null;
+                try {
+                    payload = JSON.parse(rawLine);
+                } catch (e) {
+                    payload = null;
+                }
+                if (payload) {
+                    const traceEvent = prepareCodexTraceEvent(payload);
+                    if (traceEvent && traceEvent.text) {
+                        onEvent({
+                            type: 'trace',
+                            stream: 'stdout',
+                            text: traceEvent.text,
+                            traceEvent
+                        });
+                    }
+                    return;
+                }
+                if (/^OpenAI Codex\b/.test(rawLine) || /^tokens used\b/i.test(rawLine)) {
+                    return;
+                }
+            }
+            onEvent({ type: 'trace', stream: 'stdout', text: rawLine });
+        }
+
+        function emitStderrTraceLine(line) {
+            const rawLine = String(line || '').trim();
+            if (!rawLine) {
+                return;
+            }
+            onEvent({ type: 'trace', stream: 'stderr', text: `[stderr] ${rawLine}` });
+        }
+
+        function drainLines(text, carry, handleLine) {
+            let pending = carry + String(text || '');
+            let newlineIndex = pending.indexOf('\n');
+            while (newlineIndex !== -1) {
+                const line = pending.slice(0, newlineIndex).replace(/\r$/, '');
+                handleLine(line);
+                pending = pending.slice(newlineIndex + 1);
+                newlineIndex = pending.indexOf('\n');
+            }
+            return pending;
+        }
+
+        process.stdout.on('data', chunk => {
+            appendChunk(chunk, {
+                get value() { return stdoutOutput; },
+                set value(nextValue) { stdoutOutput = nextValue; },
+                get truncated() { return stdoutTruncated; },
+                set truncated(nextValue) { stdoutTruncated = nextValue; }
+            });
+            stdoutPending = drainLines(chunk.toString('utf-8'), stdoutPending, emitStdoutTraceLine);
+        });
+        process.stderr.on('data', chunk => {
+            appendChunk(chunk, {
+                get value() { return stderrOutput; },
+                set value(nextValue) { stderrOutput = nextValue; },
+                get truncated() { return stderrTruncated; },
+                set truncated(nextValue) { stderrTruncated = nextValue; }
+            });
+            stderrPending = drainLines(chunk.toString('utf-8'), stderrPending, emitStderrTraceLine);
+        });
+
+        process.on('error', error => {
+            state.agentRuns.delete(containerName);
+            reject(error);
+        });
+        process.on('close', code => {
+            state.agentRuns.delete(containerName);
+            if (stdoutPending) {
+                emitStdoutTraceLine(stdoutPending);
+                stdoutPending = '';
+            }
+            if (stderrPending) {
+                emitStderrTraceLine(stderrPending);
+                stderrPending = '';
+            }
+            const exitCode = typeof code === 'number' ? code : 1;
+            const clippedStdout = stdoutTruncated ? `${stdoutOutput}\n...[stdout-truncated]` : stdoutOutput;
+            const clippedStderr = stderrTruncated ? `${stderrOutput}\n...[stderr-truncated]` : stderrOutput;
+            const clippedRaw = `${clippedStdout}${clippedStdout && clippedStderr ? '\n' : ''}${clippedStderr}`;
+            const extractedJsonAgentMessage = extractAgentMessageFromCodexJsonl(clippedStdout);
+            const cleanOutputSource = extractedJsonAgentMessage || clippedRaw;
+            const output = clipText(stripAnsi(cleanOutputSource).trim() || '(无输出)');
+            resolve({
+                exitCode,
+                output,
+                interrupted: exitCode !== 0 && runState.stopping === true
+            });
+        });
+    });
+}
+
 function readRequestBody(req) {
     return new Promise((resolve, reject) => {
         let body = '';
@@ -1213,6 +1662,24 @@ function sendJson(res, statusCode, payload, extraHeaders = {}) {
     res.end(JSON.stringify(payload));
 }
 
+function sendNdjson(res, payload) {
+    res.write(`${JSON.stringify(payload)}\n`);
+}
+
+function stopWebAgentRun(state, containerName) {
+    const runState = state.agentRuns.get(containerName);
+    if (!runState || !runState.process || runState.process.killed) {
+        return false;
+    }
+    runState.stopping = true;
+    try {
+        runState.process.kill('SIGTERM');
+    } catch (e) {
+        return false;
+    }
+    return true;
+}
+
 function sendHtml(res, statusCode, html, extraHeaders = {}) {
     res.writeHead(statusCode, {
         'Content-Type': 'text/html; charset=utf-8',
@@ -1807,72 +2274,162 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     return;
                 }
 
-                const history = loadWebSessionHistory(state.webHistoryDir, containerName);
-                const normalizedTemplate = normalizeAgentPromptCommandTemplate(history.agentPromptCommand, 'agentPromptCommand');
-                if (normalizedTemplate !== history.agentPromptCommand) {
-                    history.agentPromptCommand = normalizedTemplate;
-                    saveWebSessionHistory(state.webHistoryDir, containerName, history);
-                }
-                if (!isAgentPromptCommandEnabled(history.agentPromptCommand)) {
-                    sendJson(res, 400, { error: '当前会话未配置 agentPromptCommand' });
+                let prepared = null;
+                try {
+                    prepared = await prepareWebAgentExecution(ctx, state, containerName, prompt);
+                } catch (e) {
+                    sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
                     return;
                 }
 
-                await ensureWebContainer(ctx, state, containerName);
-                const agentMeta = getAgentRuntimeMeta(history);
-                const hasPriorConversation = hasAgentConversationHistory(history);
-                let resumeAttempted = false;
-                let resumeSucceeded = false;
-                let resumeError = '';
-                if (hasPriorConversation && agentMeta.resumeSupported && agentMeta.resumeCommand) {
-                    resumeAttempted = true;
-                    const resumeResult = await execCommandInWebContainer(ctx, containerName, agentMeta.resumeCommand);
-                    if (resumeResult.exitCode === 0) {
-                        resumeSucceeded = true;
-                    } else {
-                        resumeError = clipText(String(resumeResult.output || '(无输出)'), 1200);
-                    }
-                }
-
-                const effectivePrompt = resumeSucceeded
-                    ? prompt
-                    : buildAgentPromptWithHistory(history, prompt);
-                const command = buildWebAgentExecCommand(history.agentPromptCommand, effectivePrompt, agentMeta.agentProgram);
-                const contextMode = resumeSucceeded ? 'resume' : (hasPriorConversation ? 'history-injected' : 'first-turn');
+                const { history, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
                 appendWebSessionMessage(state.webHistoryDir, containerName, 'user', prompt, {
                     mode: 'agent',
                     contextMode
                 });
                 const result = await execCommandInWebContainer(ctx, containerName, command);
-                appendWebSessionMessage(
-                    state.webHistoryDir,
-                    containerName,
-                    'assistant',
-                    result.output,
-                    {
-                        exitCode: result.exitCode,
-                        mode: 'agent',
-                        contextMode,
-                        resumeAttempted,
-                        resumeSucceeded
-                    }
-                );
-                patchWebSessionAgentState(state.webHistoryDir, containerName, {
-                    agentProgram: agentMeta.agentProgram,
-                    resumeSupported: agentMeta.resumeSupported,
-                    lastResumeAt: resumeAttempted ? new Date().toISOString() : history.lastResumeAt || null,
-                    lastResumeOk: resumeAttempted ? resumeSucceeded : history.lastResumeOk,
-                    lastResumeError: resumeAttempted ? (resumeSucceeded ? '' : resumeError) : history.lastResumeError || ''
-                });
+                finalizeWebAgentExecution(state, containerName, history, agentMeta, {
+                    contextMode,
+                    resumeAttempted,
+                    resumeSucceeded,
+                    resumeError
+                }, result);
                 sendJson(res, 200, {
                     exitCode: result.exitCode,
                     output: result.output,
                     contextMode,
                     resumeAttempted,
-                    resumeSucceeded
+                    resumeSucceeded,
+                    interrupted: result.interrupted === true
                 });
             }
         },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/stream$/),
+            handler: async match => {
+                const containerName = getValidSessionName(ctx, res, match[1]);
+                if (!containerName) {
+                    return;
+                }
+
+                const payload = await readJsonBody(req);
+                const prompt = (payload.prompt || '').trim();
+                if (!prompt) {
+                    sendJson(res, 400, { error: 'prompt 不能为空' });
+                    return;
+                }
+                if (state.agentRuns.has(containerName)) {
+                    sendJson(res, 409, { error: '当前会话已有运行中的 agent 任务' });
+                    return;
+                }
+
+                let prepared = null;
+                try {
+                    prepared = await prepareWebAgentExecution(ctx, state, containerName, prompt);
+                } catch (e) {
+                    sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
+                    return;
+                }
+
+                const { history, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
+                const traceLines = ['[执行过程]'];
+                const traceEvents = [];
+                appendWebSessionMessage(state.webHistoryDir, containerName, 'user', prompt, {
+                    mode: 'agent',
+                    contextMode
+                });
+
+                res.writeHead(200, {
+                    'Content-Type': 'application/x-ndjson; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                    'X-Accel-Buffering': 'no'
+                });
+                sendNdjson(res, {
+                    type: 'meta',
+                    containerName,
+                    contextMode,
+                    resumeAttempted,
+                    resumeSucceeded,
+                    agentProgram: agentMeta.agentProgram
+                });
+                if (contextMode) {
+                    traceLines.push(`上下文模式: ${contextMode}`);
+                }
+                if (resumeAttempted) {
+                    traceLines.push(resumeSucceeded ? '会话恢复成功' : '会话恢复失败，已回退到历史注入');
+                }
+
+                try {
+                    const result = await execAgentInWebContainerStream(ctx, state, containerName, command, {
+                        agentProgram: agentMeta.agentProgram,
+                        onEvent: event => {
+                            if (event && event.type === 'trace' && event.text) {
+                                traceLines.push(String(event.text));
+                                if (event.traceEvent && typeof event.traceEvent === 'object') {
+                                    traceEvents.push(event.traceEvent);
+                                }
+                            }
+                            sendNdjson(res, event);
+                        }
+                    });
+                    traceLines.push(result.interrupted === true ? '[任务] 已停止' : '[任务] 已完成');
+                    appendWebAgentTraceMessage(state.webHistoryDir, containerName, traceLines.join('\n'), {
+                        traceEvents,
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        interrupted: result.interrupted === true
+                    });
+                    finalizeWebAgentExecution(state, containerName, history, agentMeta, {
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        resumeError
+                    }, result);
+                    sendNdjson(res, {
+                        type: 'result',
+                        exitCode: result.exitCode,
+                        output: result.output,
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        interrupted: result.interrupted === true
+                    });
+                } catch (e) {
+                    traceLines.push(`[错误] ${e && e.message ? e.message : 'Agent 执行失败'}`);
+                    appendWebAgentTraceMessage(state.webHistoryDir, containerName, traceLines.join('\n'), {
+                        traceEvents,
+                        contextMode,
+                        resumeAttempted,
+                        resumeSucceeded,
+                        interrupted: true
+                    });
+                    sendNdjson(res, {
+                        type: 'error',
+                        error: e && e.message ? e.message : 'Agent 执行失败'
+                    });
+                } finally {
+                    res.end();
+                }
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/stop$/),
+            handler: async match => {
+                const containerName = getValidSessionName(ctx, res, match[1]);
+                if (!containerName) {
+                    return;
+                }
+                const stopped = stopWebAgentRun(state, containerName);
+                if (!stopped) {
+                    sendJson(res, 404, { error: '当前会话没有运行中的 agent 任务' });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, stopping: true });
+            }
+        },
         {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/remove$/),
@@ -1971,7 +2528,8 @@ async function startWebServer(options) {
         webHistoryDir: options.webHistoryDir || path.join(os.homedir(), '.manyoyo', 'web-history'),
         webConfigPath: options.webConfigPath || getDefaultWebConfigPath(),
         authSessions: new Map(),
-        terminalSessions: new Map()
+        terminalSessions: new Map(),
+        agentRuns: new Map()
     };
 
     ensureWebHistoryDir(state.webHistoryDir);
@@ -2197,6 +2755,13 @@ async function startWebServer(options) {
                 }
             }
             state.terminalSessions.clear();
+            for (const runState of state.agentRuns.values()) {
+                const child = runState && runState.process;
+                if (child && !child.killed) {
+                    try { child.kill('SIGTERM'); } catch (e) {}
+                }
+            }
+            state.agentRuns.clear();
 
             const closeHttp = () => {
                 if (!server.listening) {