@xcanwin/manyoyo 5.6.10 → 5.7.1

package/lib/agent-resume.js

@@ -16,7 +16,10 @@ const AGENT_PROMPT_TEMPLATE_MAP = {
     opencode: 'opencode run {prompt}'
 };
 
+const CLAUDE_DANGEROUS_FLAG = '--dangerously-skip-permissions';
+const GEMINI_YOLO_FLAG = '--yolo';
 const CODEX_DANGEROUS_FLAG = '--dangerously-bypass-approvals-and-sandbox';
+const OPENCODE_PERMISSION_KEY = 'OPENCODE_PERMISSION=';
 
 function stripLeadingAssignments(commandText) {
     let rest = String(commandText || '').trim();
@@ -80,11 +83,20 @@ function resolveAgentPromptCommandTemplate(commandText) {
     const normalizedCommand = String(commandText || '').trim();
     const program = resolveAgentProgram(commandText);
     const template = AGENT_PROMPT_TEMPLATE_MAP[program] || '';
+    if (program === 'claude' && normalizedCommand.includes(CLAUDE_DANGEROUS_FLAG)) {
+        return `${normalizedCommand} -p {prompt}`;
+    }
+    if (program === 'gemini' && normalizedCommand.includes(GEMINI_YOLO_FLAG)) {
+        return `${normalizedCommand} -p {prompt}`;
+    }
     if (program === 'codex' && template) {
         if (normalizedCommand.includes(CODEX_DANGEROUS_FLAG)) {
             return `codex exec ${CODEX_DANGEROUS_FLAG} --skip-git-repo-check {prompt}`;
         }
     }
+    if (program === 'opencode' && normalizedCommand.includes(OPENCODE_PERMISSION_KEY)) {
+        return `${normalizedCommand} run {prompt}`;
+    }
     return template;
 }
 

package/lib/web/frontend/app.js

@@ -178,6 +178,10 @@
         codex: 'codex exec --skip-git-repo-check {prompt}',
         opencode: 'opencode run {prompt}'
     };
+    const CLAUDE_DANGEROUS_FLAG = '--dangerously-skip-permissions';
+    const GEMINI_YOLO_FLAG = '--yolo';
+    const CODEX_DANGEROUS_FLAG = '--dangerously-bypass-approvals-and-sandbox';
+    const OPENCODE_PERMISSION_KEY = 'OPENCODE_PERMISSION=';
     const markdownRenderer = window.ManyoyoMarkdown
         && typeof window.ManyoyoMarkdown.shouldRenderMessage === 'function'
         && typeof window.ManyoyoMarkdown.render === 'function'
@@ -559,11 +563,21 @@
     }
 
     function resolveAgentPromptTemplate(commandText) {
+        const normalizedCommand = String(commandText || '').trim();
         const program = resolveAgentProgram(commandText);
         const template = AGENT_PROMPT_TEMPLATE_MAP[program] || '';
-        if (program === 'codex' && String(commandText || '').includes('--dangerously-bypass-approvals-and-sandbox')) {
+        if (program === 'claude' && normalizedCommand.includes(CLAUDE_DANGEROUS_FLAG)) {
+            return `${normalizedCommand} -p {prompt}`;
+        }
+        if (program === 'gemini' && normalizedCommand.includes(GEMINI_YOLO_FLAG)) {
+            return `${normalizedCommand} -p {prompt}`;
+        }
+        if (program === 'codex' && normalizedCommand.includes(CODEX_DANGEROUS_FLAG)) {
             return 'codex exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check {prompt}';
         }
+        if (program === 'opencode' && normalizedCommand.includes(OPENCODE_PERMISSION_KEY)) {
+            return `${normalizedCommand} run {prompt}`;
+        }
         return template;
     }
 

package/lib/web/server.js

@@ -297,13 +297,210 @@ function buildCodexAgentExecCommand(template, prompt) {
         : renderAgentPromptCommand(codexTemplate, prompt);
 }
 
+function prependAgentFlags(commandText, matchPattern, flagSpecs) {
+    const matched = String(commandText || '').match(matchPattern);
+    if (!matched) {
+        return String(commandText || '');
+    }
+    const prefix = matched[1] || '';
+    let suffix = matched[matched.length - 1] || '';
+    for (let i = flagSpecs.length - 1; i >= 0; i -= 1) {
+        const spec = flagSpecs[i];
+        if (!spec || !spec.flag || !(spec.pattern instanceof RegExp) || spec.pattern.test(suffix)) {
+            continue;
+        }
+        suffix = ` ${spec.flag}${suffix}`;
+    }
+    return `${prefix}${suffix}`;
+}
+
+function buildClaudeAgentExecCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const claudeTemplate = prependAgentFlags(
+        templateText,
+        /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)claude\b)(.*)$/,
+        [
+            { flag: '--verbose', pattern: /(?:^|\s)--verbose(?:\s|$)/ },
+            { flag: '--output-format stream-json', pattern: /(?:^|\s)--output-format(?:\s|$)/ }
+        ]
+    );
+    return claudeTemplate === templateText
+        ? renderAgentPromptCommand(templateText, prompt)
+        : renderAgentPromptCommand(claudeTemplate, prompt);
+}
+
+function buildGeminiAgentExecCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const geminiTemplate = prependAgentFlags(
+        templateText,
+        /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)gemini\b)(.*)$/,
+        [
+            { flag: '--output-format stream-json', pattern: /(?:^|\s)--output-format(?:\s|$)/ }
+        ]
+    );
+    return geminiTemplate === templateText
+        ? renderAgentPromptCommand(templateText, prompt)
+        : renderAgentPromptCommand(geminiTemplate, prompt);
+}
+
+function buildOpenCodeAgentExecCommand(template, prompt) {
+    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const opencodeTemplate = prependAgentFlags(
+        templateText,
+        /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)opencode\s+run\b)(.*)$/,
+        [
+            { flag: '--format json', pattern: /(?:^|\s)--format(?:\s|$)/ }
+        ]
+    );
+    return opencodeTemplate === templateText
+        ? renderAgentPromptCommand(templateText, prompt)
+        : renderAgentPromptCommand(opencodeTemplate, prompt);
+}
+
 function buildWebAgentExecCommand(template, prompt, agentProgram) {
-    if (agentProgram === 'codex') {
+    switch (agentProgram) {
+    case 'claude':
+        return buildClaudeAgentExecCommand(template, prompt);
+    case 'gemini':
+        return buildGeminiAgentExecCommand(template, prompt);
+    case 'codex':
         return buildCodexAgentExecCommand(template, prompt);
+    case 'opencode':
+        return buildOpenCodeAgentExecCommand(template, prompt);
+    default:
+        break;
     }
     return renderAgentPromptCommand(template, prompt);
 }
 
+function parseJsonObjectLine(line) {
+    const text = String(line || '').trim();
+    if (!text) {
+        return null;
+    }
+    try {
+        const payload = JSON.parse(text);
+        return payload && typeof payload === 'object' ? payload : null;
+    } catch (e) {
+        return null;
+    }
+}
+
+function collectStructuredText(value) {
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => collectStructuredText(item)).filter(Boolean).join('\n').trim();
+    }
+    if (!value || typeof value !== 'object') {
+        return '';
+    }
+    if (typeof value.text === 'string' && value.text.trim()) {
+        return value.text.trim();
+    }
+    if (typeof value.content === 'string' && value.content.trim()) {
+        return value.content.trim();
+    }
+    if (Array.isArray(value.content)) {
+        return value.content.map(item => collectStructuredText(item)).filter(Boolean).join('\n').trim();
+    }
+    return '';
+}
+
+function extractClaudeAgentMessage(text) {
+    let lastMessage = '';
+    for (const rawLine of String(text || '').split('\n')) {
+        const payload = parseJsonObjectLine(rawLine);
+        if (!payload || payload.type !== 'assistant') {
+            continue;
+        }
+        const message = toPlainObject(payload.message);
+        const content = Array.isArray(message.content) ? message.content : [];
+        const nextMessage = content
+            .filter(item => item && typeof item === 'object' && item.type === 'text')
+            .map(item => collectStructuredText(item))
+            .filter(Boolean)
+            .join('\n')
+            .trim();
+        if (nextMessage) {
+            lastMessage = nextMessage;
+        }
+    }
+    return lastMessage.trim();
+}
+
+function extractGeminiAgentMessage(text) {
+    let lastMessage = '';
+    let deltaMessage = '';
+    for (const rawLine of String(text || '').split('\n')) {
+        const payload = parseJsonObjectLine(rawLine);
+        if (!payload || payload.type !== 'message' || payload.role !== 'assistant') {
+            continue;
+        }
+        const content = collectStructuredText(payload.content);
+        if (!content) {
+            continue;
+        }
+        if (payload.delta === true) {
+            deltaMessage += content;
+            lastMessage = deltaMessage.trim();
+            continue;
+        }
+        deltaMessage = '';
+        lastMessage = content;
+    }
+    return lastMessage.trim();
+}
+
+function extractOpenCodeAgentMessage(text) {
+    let lastMessage = '';
+    let deltaMessage = '';
+    for (const rawLine of String(text || '').split('\n')) {
+        const payload = parseJsonObjectLine(rawLine);
+        if (!payload) {
+            continue;
+        }
+        const eventType = pickFirstString(payload.type);
+        const message = toPlainObject(payload.message);
+        const role = pickFirstString(payload.role, message.role);
+        if (eventType !== 'message' && eventType !== 'assistant' && eventType !== 'assistant_message' && eventType !== 'text') {
+            continue;
+        }
+        if (role && role !== 'assistant') {
+            continue;
+        }
+        const content = collectStructuredText(message.content || payload.content || payload.text || payload);
+        if (!content) {
+            continue;
+        }
+        if (payload.delta === true) {
+            deltaMessage += content;
+            lastMessage = deltaMessage.trim();
+            continue;
+        }
+        deltaMessage = '';
+        lastMessage = content;
+    }
+    return lastMessage.trim();
+}
+
+function extractAgentMessageFromStructuredOutput(agentProgram, text) {
+    if (agentProgram === 'codex') {
+        return extractAgentMessageFromCodexJsonl(text);
+    }
+    if (agentProgram === 'claude') {
+        return extractClaudeAgentMessage(text);
+    }
+    if (agentProgram === 'gemini') {
+        return extractGeminiAgentMessage(text);
+    }
+    if (agentProgram === 'opencode') {
+        return extractOpenCodeAgentMessage(text);
+    }
+    return '';
+}
+
 function getAgentRuntimeMeta(history) {
     const sessionHistory = history && typeof history === 'object' ? history : {};
     const template = normalizeAgentPromptCommandTemplate(sessionHistory.agentPromptCommand, 'agentPromptCommand');
@@ -376,6 +573,333 @@ function buildAgentPromptWithHistory(history, prompt) {
     ].join('\n');
 }
 
+function shortenTraceText(value, maxChars = 140) {
+    const raw = clipText(stripAnsi(String(value || '')).replace(/\s+/g, ' ').trim(), maxChars);
+    return raw.trim();
+}
+
+function summarizeTraceArguments(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}=${shortenTraceText(textValue, 80)}`);
+            continue;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            parts.push(`${key}=${String(value)}`);
+        }
+    }
+    return parts.slice(0, 3).join(', ');
+}
+
+function createStructuredTraceEvent(provider, kind, eventType, textValue, extra = {}) {
+    const normalizedText = String(textValue || '').trim();
+    if (!normalizedText) {
+        return null;
+    }
+    return {
+        provider,
+        kind,
+        eventType,
+        text: normalizedText,
+        ...extra
+    };
+}
+
+function prepareClaudeTraceEvents(payload, state) {
+    const eventType = pickFirstString(payload.type);
+    const subtype = pickFirstString(payload.subtype);
+    const message = toPlainObject(payload.message);
+    const content = Array.isArray(message.content) ? message.content : [];
+    const toolNamesById = state.toolNamesById;
+    const events = [];
+
+    if (eventType === 'system' && subtype === 'init') {
+        events.push(createStructuredTraceEvent('claude', 'thread', eventType, '[会话] Claude 已开始处理', {
+            phase: 'started',
+            status: 'started',
+            subtype
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'assistant') {
+        content.forEach(item => {
+            if (!item || typeof item !== 'object') {
+                return;
+            }
+            if (item.type === 'text') {
+                const detail = collectStructuredText(item);
+                if (detail) {
+                    events.push(createStructuredTraceEvent('claude', 'agent_message', eventType, `[说明] ${detail}`, {
+                        phase: 'completed',
+                        status: 'completed',
+                        detail
+                    }));
+                }
+                return;
+            }
+            if (item.type === 'tool_use') {
+                const toolName = pickFirstString(item.name, item.id, 'tool');
+                const toolId = pickFirstString(item.id);
+                if (toolId) {
+                    toolNamesById.set(toolId, toolName);
+                }
+                const summary = summarizeTraceArguments(toPlainObject(item.input));
+                events.push(createStructuredTraceEvent(
+                    'claude',
+                    'tool',
+                    eventType,
+                    summary ? `[工具开始] ${toolName} (${summary})` : `[工具开始] ${toolName}`,
+                    {
+                        phase: 'started',
+                        status: 'in_progress',
+                        toolName,
+                        toolId,
+                        arguments: toPlainObject(item.input),
+                        argumentSummary: summary
+                    }
+                ));
+            }
+        });
+        return events.filter(Boolean);
+    }
+    if (eventType === 'user') {
+        content.forEach(item => {
+            if (!item || typeof item !== 'object' || item.type !== 'tool_result') {
+                return;
+            }
+            const toolId = pickFirstString(item.tool_use_id);
+            const toolName = pickFirstString(toolNamesById.get(toolId), toolId, 'tool');
+            const status = item.is_error === true ? 'error' : 'success';
+            events.push(createStructuredTraceEvent('claude', 'tool', eventType, `[工具完成] ${toolName} (${status})`, {
+                phase: 'completed',
+                status,
+                toolName,
+                toolId,
+                result: collectStructuredText(item.content),
+                error: item.is_error === true ? collectStructuredText(item.content) : ''
+            }));
+        });
+        return events.filter(Boolean);
+    }
+    if (eventType === 'result') {
+        events.push(createStructuredTraceEvent('claude', 'turn', eventType, '[回合] 响应完成', {
+            phase: 'completed',
+            status: pickFirstString(subtype, 'completed'),
+            subtype
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'error') {
+        const detail = pickFirstString(payload.message, payload.error);
+        events.push(createStructuredTraceEvent('claude', 'error', eventType, detail ? `[错误] ${detail}` : '[错误] Claude 返回了错误事件', {
+            status: 'error',
+            detail
+        }));
+        return events.filter(Boolean);
+    }
+    return [];
+}
+
+function prepareGeminiTraceEvents(payload, state) {
+    const eventType = pickFirstString(payload.type);
+    const toolNamesById = state.toolNamesById;
+    const events = [];
+
+    if (eventType === 'init') {
+        events.push(createStructuredTraceEvent('gemini', 'thread', eventType, '[会话] Gemini 已开始处理', {
+            phase: 'started',
+            status: 'started',
+            sessionId: pickFirstString(payload.session_id),
+            model: pickFirstString(payload.model)
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'message' && payload.role === 'assistant') {
+        if (payload.delta === true) {
+            return [];
+        }
+        const detail = collectStructuredText(payload.content);
+        if (!detail) {
+            return [];
+        }
+        events.push(createStructuredTraceEvent('gemini', 'agent_message', eventType, `[说明] ${detail}`, {
+            phase: 'completed',
+            status: 'completed',
+            detail
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'tool_use') {
+        const toolName = pickFirstString(payload.tool_name, payload.tool_id, 'tool');
+        const toolId = pickFirstString(payload.tool_id);
+        if (toolId) {
+            toolNamesById.set(toolId, toolName);
+        }
+        const summary = summarizeTraceArguments(toPlainObject(payload.parameters));
+        events.push(createStructuredTraceEvent(
+            'gemini',
+            'tool',
+            eventType,
+            summary ? `[工具开始] ${toolName} (${summary})` : `[工具开始] ${toolName}`,
+            {
+                phase: 'started',
+                status: 'in_progress',
+                toolName,
+                toolId,
+                arguments: toPlainObject(payload.parameters),
+                argumentSummary: summary
+            }
+        ));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'tool_result') {
+        const toolId = pickFirstString(payload.tool_id);
+        const toolName = pickFirstString(toolNamesById.get(toolId), toolId, 'tool');
+        const status = pickFirstString(payload.status, 'completed');
+        events.push(createStructuredTraceEvent('gemini', 'tool', eventType, `[工具完成] ${toolName} (${status})`, {
+            phase: 'completed',
+            status,
+            toolName,
+            toolId,
+            result: collectStructuredText(payload.output),
+            error: toPlainObject(payload.error)
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'result') {
+        events.push(createStructuredTraceEvent('gemini', 'turn', eventType, '[回合] 响应完成', {
+            phase: 'completed',
+            status: pickFirstString(payload.status, 'completed')
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'error') {
+        const detail = pickFirstString(payload.message);
+        events.push(createStructuredTraceEvent('gemini', 'error', eventType, detail ? `[错误] ${detail}` : '[错误] Gemini 返回了错误事件', {
+            status: pickFirstString(payload.severity, 'error'),
+            detail
+        }));
+        return events.filter(Boolean);
+    }
+    return [];
+}
+
+function prepareOpenCodeTraceEvents(payload, state) {
+    const eventType = pickFirstString(payload.type);
+    const message = toPlainObject(payload.message);
+    const role = pickFirstString(payload.role, message.role);
+    const toolNamesById = state.toolNamesById;
+    const events = [];
+
+    if (eventType === 'session.start' || eventType === 'init') {
+        events.push(createStructuredTraceEvent('opencode', 'thread', eventType, '[会话] OpenCode 已开始处理', {
+            phase: 'started',
+            status: 'started',
+            sessionId: pickFirstString(payload.session_id, payload.sessionID)
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'message' || eventType === 'assistant' || eventType === 'assistant_message' || eventType === 'text') {
+        if (role && role !== 'assistant') {
+            return [];
+        }
+        if (payload.delta === true) {
+            return [];
+        }
+        const detail = collectStructuredText(message.content || payload.content || payload.text || payload);
+        if (!detail) {
+            return [];
+        }
+        events.push(createStructuredTraceEvent('opencode', 'agent_message', eventType, `[说明] ${detail}`, {
+            phase: 'completed',
+            status: 'completed',
+            detail
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'tool_use' || eventType === 'step_start') {
+        const toolName = pickFirstString(payload.tool_name, payload.name, payload.tool, payload.step, payload.tool_id, 'tool');
+        const toolId = pickFirstString(payload.tool_id, payload.id);
+        if (toolId) {
+            toolNamesById.set(toolId, toolName);
+        }
+        const argumentsValue = toPlainObject(payload.parameters || payload.input || payload.arguments);
+        const summary = summarizeTraceArguments(argumentsValue);
+        events.push(createStructuredTraceEvent(
+            'opencode',
+            'tool',
+            eventType,
+            summary ? `[工具开始] ${toolName} (${summary})` : `[工具开始] ${toolName}`,
+            {
+                phase: 'started',
+                status: pickFirstString(payload.status, 'in_progress'),
+                toolName,
+                toolId,
+                arguments: argumentsValue,
+                argumentSummary: summary
+            }
+        ));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'tool_result' || eventType === 'step_finish') {
+        const toolId = pickFirstString(payload.tool_id, payload.id);
+        const toolName = pickFirstString(toolNamesById.get(toolId), payload.tool_name, payload.name, payload.tool, toolId, 'tool');
+        const status = pickFirstString(payload.status, payload.state, 'completed');
+        events.push(createStructuredTraceEvent('opencode', 'tool', eventType, `[工具完成] ${toolName} (${status})`, {
+            phase: 'completed',
+            status,
+            toolName,
+            toolId,
+            result: collectStructuredText(payload.output || payload.result),
+            error: toPlainObject(payload.error)
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'result') {
+        events.push(createStructuredTraceEvent('opencode', 'turn', eventType, '[回合] 响应完成', {
+            phase: 'completed',
+            status: pickFirstString(payload.status, 'completed')
+        }));
+        return events.filter(Boolean);
+    }
+    if (eventType === 'error') {
+        const detail = pickFirstString(payload.message, payload.error && payload.error.message);
+        events.push(createStructuredTraceEvent('opencode', 'error', eventType, detail ? `[错误] ${detail}` : '[错误] OpenCode 返回了错误事件', {
+            status: 'error',
+            detail
+        }));
+        return events.filter(Boolean);
+    }
+    return [];
+}
+
+function prepareStructuredTraceEvents(agentProgram, payload, state) {
+    if (!payload || typeof payload !== 'object') {
+        return [];
+    }
+    if (agentProgram === 'codex') {
+        const traceEvent = prepareCodexTraceEvent(payload);
+        return traceEvent ? [traceEvent] : [];
+    }
+    if (agentProgram === 'claude') {
+        return prepareClaudeTraceEvents(payload, state);
+    }
+    if (agentProgram === 'gemini') {
+        return prepareGeminiTraceEvents(payload, state);
+    }
+    if (agentProgram === 'opencode') {
+        return prepareOpenCodeTraceEvents(payload, state);
+    }
+    return [];
+}
+
 function prepareCodexTraceEvent(payload) {
     if (!payload || typeof payload !== 'object') {
         return null;
@@ -1424,7 +1948,9 @@ async function ensureWebContainer(ctx, state, containerInput) {
     }
 }
 
-async function execCommandInWebContainer(ctx, containerName, command) {
+async function execCommandInWebContainer(ctx, containerName, command, options = {}) {
+    const opts = options && typeof options === 'object' ? options : {};
+    const agentProgram = typeof opts.agentProgram === 'string' ? opts.agentProgram : '';
     return await new Promise((resolve, reject) => {
         const process = spawn(
             ctx.dockerCmd,
@@ -1474,8 +2000,8 @@ async function execCommandInWebContainer(ctx, containerName, command) {
             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 extractedAgentMessage = extractAgentMessageFromStructuredOutput(agentProgram, clippedStdout);
+            const cleanOutputSource = extractedAgentMessage || clippedRaw;
             const output = clipText(stripAnsi(cleanOutputSource).trim() || '(无输出)');
             resolve({ exitCode, output });
         });
@@ -1509,6 +2035,9 @@ async function execAgentInWebContainerStream(ctx, state, containerName, command,
         let stderrTruncated = false;
         let stdoutPending = '';
         let stderrPending = '';
+        const structuredTraceState = {
+            toolNamesById: new Map()
+        };
         function appendChunk(chunk, target) {
             if (!chunk) return;
             const text = chunk.toString('utf-8');
@@ -1531,26 +2060,24 @@ async function execAgentInWebContainerStream(ctx, state, containerName, command,
             if (!rawLine) {
                 return;
             }
-            if (agentProgram === 'codex') {
-                let payload = null;
-                try {
-                    payload = JSON.parse(rawLine);
-                } catch (e) {
-                    payload = null;
-                }
+            if (agentProgram === 'claude' || agentProgram === 'gemini' || agentProgram === 'codex' || agentProgram === 'opencode') {
+                const payload = parseJsonObjectLine(rawLine);
                 if (payload) {
-                    const traceEvent = prepareCodexTraceEvent(payload);
-                    if (traceEvent && traceEvent.text) {
+                    const traceEvents = prepareStructuredTraceEvents(agentProgram, payload, structuredTraceState);
+                    traceEvents.forEach(traceEvent => {
+                        if (!traceEvent || !traceEvent.text) {
+                            return;
+                        }
                         onEvent({
                             type: 'trace',
                             stream: 'stdout',
                             text: traceEvent.text,
                             traceEvent
                         });
-                    }
+                    });
                     return;
                 }
-                if (/^OpenAI Codex\b/.test(rawLine) || /^tokens used\b/i.test(rawLine)) {
+                if (agentProgram === 'codex' && (/^OpenAI Codex\b/.test(rawLine) || /^tokens used\b/i.test(rawLine))) {
                     return;
                 }
             }
@@ -1614,8 +2141,8 @@ async function execAgentInWebContainerStream(ctx, state, containerName, command,
             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 extractedAgentMessage = extractAgentMessageFromStructuredOutput(agentProgram, clippedStdout);
+            const cleanOutputSource = extractedAgentMessage || clippedRaw;
             const output = clipText(stripAnsi(cleanOutputSource).trim() || '(无输出)');
             resolve({
                 exitCode,
@@ -2287,7 +2814,9 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     mode: 'agent',
                     contextMode
                 });
-                const result = await execCommandInWebContainer(ctx, containerName, command);
+                const result = await execCommandInWebContainer(ctx, containerName, command, {
+                    agentProgram: agentMeta.agentProgram
+                });
                 finalizeWebAgentExecution(state, containerName, history, agentMeta, {
                     contextMode,
                     resumeAttempted,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "5.6.10",
+    "version": "5.7.1",
     "imageVersion": "1.9.0-common",
     "playwrightCliVersion": "0.1.1",
     "description": "AI Agent CLI Security Sandbox for Docker and Podman",