@blackbox_ai/blackbox-cli 0.8.3 → 0.9.2

package/dist/src/ui/hooks/useAgentCommandProcessor.js

@@ -0,0 +1,802 @@
+/**
+ * @license
+ * Copyright 2025 Blackbox
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useCallback, useRef } from 'react';
+import { ToolCallStatus } from '../types.js';
+import { AgentExecutor } from '../../services/agentExecutor.js';
+/**
+ * Enhanced parser to extract tool information from agent output
+ */
+function extractToolCallFromAgentOutput(toolContent) {
+    const lines = toolContent.split('\n');
+    let toolName = '';
+    let args = {};
+    let inPayload = false;
+    let payloadContent = '';
+    for (const line of lines) {
+        const cleanLine = line.replace(/[│\s]/g, '');
+        // Extract tool name
+        if (cleanLine.startsWith('Tool')) {
+            toolName = cleanLine.substring(4).trim();
+            continue;
+        }
+        // Start of invocation payload
+        if (cleanLine.includes('Invocationpayload:') || cleanLine.includes('payload:')) {
+            inPayload = true;
+            continue;
+        }
+        // End of payload section
+        if (cleanLine.includes('Result:') || cleanLine.includes('Output:')) {
+            inPayload = false;
+            break;
+        }
+        // Collect payload content
+        if (inPayload) {
+            payloadContent += line + '\n';
+        }
+    }
+    // Parse JSON payload if present
+    try {
+        if (payloadContent.trim()) {
+            // Clean up the payload content and try to parse as JSON
+            const cleanPayload = payloadContent.trim().replace(/^[{]/, '{').replace(/[}]$/, '}');
+            args = JSON.parse(cleanPayload);
+        }
+    }
+    catch {
+        // If JSON parsing fails, return null - this isn't a valid tool call
+        return null;
+    }
+    if (!toolName || Object.keys(args).length === 0) {
+        return null;
+    }
+    return {
+        callId: `agent-tool-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        name: toolName,
+        args,
+        isClientInitiated: false, // These come from the agent, not user
+        prompt_id: `agent-${Date.now()}`,
+    };
+}
+/**
+ * Parse Gemini agent streaming JSON output to extract text content and tool information
+ */
+function parseGeminiStreamingOutput(jsonLine) {
+    try {
+        const parsed = JSON.parse(jsonLine);
+        // Handle streaming text deltas
+        if (parsed.type === 'message' && parsed.role === 'assistant' && parsed.content && parsed.delta === true) {
+            return { type: 'delta', text: parsed.content };
+        }
+        // Handle complete assistant messages
+        if (parsed.type === 'message' && parsed.role === 'assistant' && parsed.content && !parsed.delta) {
+            return { type: 'final', text: parsed.content };
+        }
+        // Handle tool use events
+        if (parsed.type === 'tool_use') {
+            const toolCall = {
+                callId: parsed.tool_use_id || `gemini-tool-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                name: parsed.tool_name,
+                args: parsed.parameters || {},
+                isClientInitiated: false, // These come from Gemini, not user
+                prompt_id: `gemini-${Date.now()}`,
+            };
+            return { type: 'tool_use', toolCall };
+        }
+        // Handle tool results
+        if (parsed.type === 'tool_result') {
+            return {
+                type: 'tool_result',
+                toolResult: {
+                    toolId: parsed.tool_use_id,
+                    result: parsed.output || parsed.result || ''
+                }
+            };
+        }
+        // Handle final result
+        if (parsed.type === 'result' && parsed.status === 'success') {
+            return { type: 'final', text: parsed.result || '' };
+        }
+        // Skip init, system messages and other metadata
+        if (parsed.type === 'init' || parsed.type === 'system') {
+            return { type: 'skip' };
+        }
+        // Skip other metadata but log for debugging
+        return { type: 'skip' };
+    }
+    catch (error) {
+        console.log('[Gemini Parser] JSON parse error:', error);
+        return { type: 'skip' };
+    }
+}
+/**
+ * Parse Codex agent streaming JSON output to extract text content and tool information
+ */
+function parseCodexStreamingOutput(jsonLine) {
+    try {
+        const parsed = JSON.parse(jsonLine);
+        // Handle agent messages (text content)
+        if (parsed.type === 'item.completed' &&
+            parsed.item?.type === 'agent_message' &&
+            parsed.item?.text) {
+            return { type: 'delta', text: parsed.item.text + '\n\n' };
+        }
+        // Handle command execution start (tool use)
+        if (parsed.type === 'item.started' &&
+            parsed.item?.type === 'command_execution' &&
+            parsed.item?.command) {
+            // Create a tool call for command execution
+            const toolCall = {
+                callId: parsed.item.id || `codex-cmd-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                name: 'shell',
+                args: { command: parsed.item.command },
+                isClientInitiated: false,
+                prompt_id: `codex-${Date.now()}`,
+            };
+            return { type: 'tool_use', toolCall };
+        }
+        // Handle command execution completion (tool result)
+        if (parsed.type === 'item.completed' &&
+            parsed.item?.type === 'command_execution') {
+            const exitCode = parsed.item.exit_code;
+            return {
+                type: 'tool_result',
+                toolResult: {
+                    toolId: parsed.item.id,
+                    result: exitCode === 0 ? 'Command completed successfully' : `Command failed with exit code: ${exitCode}`
+                }
+            };
+        }
+        // Handle thread start
+        if (parsed.type === 'thread.started') {
+            return { type: 'skip' }; // Skip thread metadata
+        }
+        // Skip other metadata
+        return { type: 'skip' };
+    }
+    catch (error) {
+        console.log('[Codex Parser] JSON parse error:', error);
+        return { type: 'skip' };
+    }
+}
+/**
+ * Parse Claude Code agent streaming JSON output to extract text content and tool information
+ */
+function parseClaudeStreamingOutput(jsonLine) {
+    try {
+        const parsed = JSON.parse(jsonLine);
+        // Handle streaming text deltas
+        if (parsed.type === 'stream_event' &&
+            parsed.event?.type === 'content_block_delta' &&
+            parsed.event?.delta?.type === 'text_delta') {
+            return { type: 'delta', text: parsed.event.delta.text };
+        }
+        // Handle tool use in assistant messages
+        if (parsed.type === 'assistant' && parsed.message?.content) {
+            const content = parsed.message.content;
+            if (Array.isArray(content)) {
+                // Check for tool use
+                const toolUse = content.find(item => item.type === 'tool_use');
+                if (toolUse) {
+                    // Create a proper ToolCallRequestInfo for the scheduler
+                    const toolCall = {
+                        callId: toolUse.id || `claude-tool-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                        name: toolUse.name,
+                        args: toolUse.input || {},
+                        isClientInitiated: false, // These come from Claude, not user
+                        prompt_id: `claude-${Date.now()}`,
+                    };
+                    return { type: 'tool_use', toolCall };
+                }
+                // Extract text content
+                const text = content
+                    .filter(item => item.type === 'text')
+                    .map(item => item.text)
+                    .join('\n');
+                if (text) {
+                    return { type: 'final', text };
+                }
+            }
+            return { type: 'final', text: content };
+        }
+        // Handle tool results in user messages
+        if (parsed.type === 'user' && parsed.message?.content) {
+            const content = parsed.message.content;
+            if (Array.isArray(content)) {
+                const toolResult = content.find(item => item.type === 'tool_result');
+                if (toolResult) {
+                    // Return tool result information for the scheduler to handle
+                    return {
+                        type: 'tool_result',
+                        toolResult: {
+                            toolId: toolResult.tool_use_id,
+                            result: typeof toolResult.content === 'string' ? toolResult.content : JSON.stringify(toolResult.content)
+                        }
+                    };
+                }
+            }
+        }
+        // Handle final result (this is the cleanest output)
+        if (parsed.type === 'result' && parsed.result) {
+            return { type: 'final', text: parsed.result };
+        }
+        // Handle streaming result chunks - when Claude sends partial result data
+        if (parsed.type === 'result' && parsed.partial_result) {
+            return { type: 'delta', text: parsed.partial_result };
+        }
+        // Skip system messages and other metadata
+        return { type: 'skip' };
+    }
+    catch (error) {
+        console.log('[Claude Parser] JSON parse error:', error);
+        return { type: 'skip' };
+    }
+}
+/**
+ * Parse agent output to extract tool calls and clean message content
+ */
+function parseAgentOutputForToolCalls(output, lastProcessedLength, scheduleToolCalls, abortSignal, agentType) {
+    // Only process new content since last parse
+    const newContent = output.substring(lastProcessedLength);
+    if (!newContent) {
+        return { newProcessedLength: lastProcessedLength, messageContent: output };
+    }
+    let messageContent = '';
+    let currentToolContent = '';
+    let inToolBox = false;
+    const toolCallsToSchedule = [];
+    const lines = output.split('\n');
+    // Handle Claude Code agent's JSON streaming output format
+    if (agentType === 'claude') {
+        // For the fallback parsing in this context, we just use the raw output
+        // The actual streaming parsing happens in the main execution flow
+        messageContent = output;
+        // Fallback: if no content extracted, try the old method
+        if (!messageContent) {
+            const cleanMessages = [];
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                // Skip tool call indicators, empty lines, and JSON lines
+                if (trimmedLine.startsWith('✦ ') || !trimmedLine ||
+                    (trimmedLine.startsWith('{') && trimmedLine.endsWith('}'))) {
+                    continue;
+                }
+                // Add regular text content
+                cleanMessages.push(trimmedLine);
+            }
+            messageContent = cleanMessages.join('\n\n').trim();
+        }
+    }
+    else {
+        // Handle other agents with tool box format
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Detect tool box start
+            if (line.includes('┌─')) {
+                inToolBox = true;
+                currentToolContent = '';
+                continue;
+            }
+            // Detect tool box end
+            if (line.includes('└─') && inToolBox) {
+                inToolBox = false;
+                // Try to extract a tool call from the content
+                const toolCall = extractToolCallFromAgentOutput(currentToolContent);
+                if (toolCall) {
+                    toolCallsToSchedule.push(toolCall);
+                }
+                else {
+                    // If it's not a valid tool call, add it to message content
+                    messageContent += `\n┌─\n${currentToolContent}\n└─\n`;
+                }
+                continue;
+            }
+            // Collect tool box content
+            if (inToolBox) {
+                currentToolContent += line + '\n';
+                continue;
+            }
+            // Regular message content (skip tool call indicators)
+            if (!line.startsWith('✦ ')) {
+                messageContent += line + '\n';
+            }
+        }
+        messageContent = messageContent.trim();
+    }
+    // Schedule any tool calls we found
+    if (toolCallsToSchedule.length > 0) {
+        scheduleToolCalls(toolCallsToSchedule, abortSignal);
+    }
+    return {
+        newProcessedLength: output.length,
+        messageContent
+    };
+}
+/**
+ * Hook to process agent execution with proper tool scheduling like GeminiClient.
+ * This integrates with the existing tool scheduling system for consistent UI.
+ */
+export const useAgentCommandProcessor = (addItemToHistory, setPendingHistoryItem, onExec, onDebugMessage, config, scheduleToolCalls) => {
+    // Track the current pending item state with a ref for reading
+    const currentPendingItemRef = useRef(null);
+    // Wrapper to sync the ref when setPendingHistoryItem is called
+    const syncedSetPendingHistoryItem = useCallback((newItem) => {
+        currentPendingItemRef.current = newItem;
+        setPendingHistoryItem(newItem);
+    }, [setPendingHistoryItem]);
+    // Claude/Gemini streaming handler - exactly like Gemini's handleContentEvent
+    const handleStreamingContentEvent = useCallback((textDelta, currentMessageBuffer, userMessageTimestamp) => {
+        let newMessageBuffer = currentMessageBuffer + textDelta;
+        if (currentPendingItemRef.current?.type !== 'gemini' &&
+            currentPendingItemRef.current?.type !== 'gemini_content') {
+            if (currentPendingItemRef.current) {
+                addItemToHistory(currentPendingItemRef.current, userMessageTimestamp);
+            }
+            const newItem = { type: 'gemini', text: '' };
+            syncedSetPendingHistoryItem(newItem);
+            newMessageBuffer = textDelta;
+        }
+        // Update the existing message with accumulated content (same as Gemini)
+        const updatedItem = {
+            type: (currentPendingItemRef.current?.type || 'gemini'),
+            text: newMessageBuffer,
+        };
+        syncedSetPendingHistoryItem(updatedItem);
+        return newMessageBuffer;
+    }, [addItemToHistory, syncedSetPendingHistoryItem]);
+    const executeAgent = useCallback((agentType, model, task, abortSignal) => {
+        // Early return for blackbox agent - it should be handled directly by useGeminiStream
+        // to reuse all streaming, tools, and UI components
+        if (agentType === 'blackbox') {
+            return;
+        }
+        const userMessageTimestamp = Date.now();
+        // Note: User message is already added to history by the auto-routing logic in useGeminiStream
+        // We don't need to add it again here to avoid showing "/agent <task>"
+        const executeCommand = async (resolve) => {
+            let cumulativeOutput = '';
+            let lastProcessedLength = 0;
+            // Start with clean slate for real-time streaming (like Gemini does)
+            setPendingHistoryItem(null);
+            const executor = new AgentExecutor();
+            // Check if CLI is installed (since blackbox agent already returned early, 
+            // we only get here for claude, codex, and gemini agents)
+            const isInstalled = await executor.checkAgentCLI(agentType);
+            if (!isInstalled) {
+                onDebugMessage(`${agentType} CLI not found. Installing...`);
+                // Show installation message
+                setPendingHistoryItem({
+                    type: 'gemini_content',
+                    text: `Installing ${agentType} CLI...\n\nThis may take a few moments...`,
+                });
+                const installSuccess = await executor.installAgentCLI(agentType, (chunk) => {
+                    onDebugMessage(`Install output: ${chunk}`);
+                }, abortSignal);
+                if (!installSuccess) {
+                    setPendingHistoryItem(null);
+                    addItemToHistory({
+                        type: 'error',
+                        text: `Failed to install ${agentType} CLI. Please install it manually.`,
+                    }, userMessageTimestamp);
+                    resolve();
+                    return;
+                }
+                // Clear installation message and start agent execution
+                setPendingHistoryItem({
+                    type: 'gemini_content',
+                    text: '',
+                });
+            }
+            try {
+                // Create message buffer for streaming (like Gemini does)
+                let streamingMessageBuffer = '';
+                // Execute the agent with optimized streaming output
+                const executionPromise = executor.executeAgent({
+                    agentType,
+                    model,
+                    task,
+                    cwd: config.getTargetDir(),
+                    onOutput: (_, chunk) => {
+                        // Handle Claude, Codex, and Gemini streaming differently - use direct event processing like Gemini
+                        if (agentType === 'claude' || agentType === 'codex' || agentType === 'gemini') {
+                            // Add chunk to cumulative output for JSON buffer management
+                            cumulativeOutput += chunk;
+                            // Try to parse complete JSON objects from the buffer
+                            const jsonLines = cumulativeOutput.split('\n');
+                            let processedUpTo = 0;
+                            for (let i = 0; i < jsonLines.length - 1; i++) { // Skip last line as it might be incomplete
+                                const line = jsonLines[i].trim();
+                                if (line) {
+                                    const parsed = agentType === 'claude'
+                                        ? parseClaudeStreamingOutput(line)
+                                        : agentType === 'codex'
+                                            ? parseCodexStreamingOutput(line)
+                                            : parseGeminiStreamingOutput(line);
+                                    if (parsed.type === 'delta' && parsed.text) {
+                                        streamingMessageBuffer = handleStreamingContentEvent(parsed.text, streamingMessageBuffer, userMessageTimestamp);
+                                    }
+                                    else if (parsed.type === 'tool_use' && parsed.toolCall) {
+                                        // Create a proper tool call display object for the UI
+                                        // Format it like Gemini tools: name is the tool, description is the main argument
+                                        let toolDescription = '';
+                                        if (parsed.toolCall.args) {
+                                            // Extract the most relevant argument for the description based on tool type
+                                            const args = parsed.toolCall.args;
+                                            const toolName = parsed.toolCall.name.toLowerCase();
+                                            if (toolName.includes('websearch') || toolName.includes('web_search')) {
+                                                toolDescription = (args['query'] || args['search_query']) || 'web search';
+                                            }
+                                            else if (toolName.includes('todowrite') || toolName.includes('todo_write')) {
+                                                const todos = args['todos'];
+                                                if (todos && todos.length > 0) {
+                                                    toolDescription = `${todos.length} todo${todos.length > 1 ? 's' : ''}: ${todos[0].content}${todos.length > 1 ? '...' : ''}`;
+                                                }
+                                                else {
+                                                    toolDescription = 'todo list';
+                                                }
+                                            }
+                                            else if (toolName.includes('edit') || toolName.includes('write')) {
+                                                toolDescription = (args['file_path'] || args['path']) || 'file operation';
+                                            }
+                                            else if (toolName.includes('read') || toolName.includes('list')) {
+                                                toolDescription = (args['file_path'] || args['path'] || args['directory']) || 'file access';
+                                            }
+                                            else if (toolName.includes('shell') || toolName.includes('execute')) {
+                                                toolDescription = (args['command'] || args['cmd']) || 'command execution';
+                                            }
+                                            else if (args['file_path'] || args['path']) {
+                                                toolDescription = (args['file_path'] || args['path']);
+                                            }
+                                            else if (args['command']) {
+                                                toolDescription = args['command'];
+                                            }
+                                            else if (args['query']) {
+                                                toolDescription = args['query'];
+                                            }
+                                            else if (args['content']) {
+                                                toolDescription = 'content provided';
+                                            }
+                                            else {
+                                                // Fallback to first argument value
+                                                const firstValue = Object.values(args)[0];
+                                                toolDescription = typeof firstValue === 'string' ? firstValue : 'execution';
+                                            }
+                                        }
+                                        // Create appropriate result display based on tool type to match ToolMessage expectations
+                                        let resultDisplay = undefined;
+                                        const command = parsed.toolCall.args?.['command'] || '';
+                                        const toolName = parsed.toolCall.name.toLowerCase();
+                                        // Handle special Codex commands with enhanced formatting
+                                        if (command.startsWith('update_plan')) {
+                                            // Extract and format plan data
+                                            const planMatch = command.match(/update_plan\s+'(.+)'/);
+                                            if (planMatch) {
+                                                try {
+                                                    const planData = JSON.parse(planMatch[1]);
+                                                    if (Array.isArray(planData)) {
+                                                        const todoDisplay = {
+                                                            type: 'todo_list',
+                                                            todos: planData.map((item, index) => ({
+                                                                id: `plan-${index}`,
+                                                                content: item.description || 'Unknown task',
+                                                                status: item.status === 'completed' ? 'completed' :
+                                                                    item.status === 'in_progress' ? 'in_progress' :
+                                                                        'pending'
+                                                            })),
+                                                        };
+                                                        resultDisplay = todoDisplay;
+                                                        toolDescription = `Update project plan (${planData.length} tasks)`;
+                                                    }
+                                                }
+                                                catch (_e) {
+                                                    // Fallback to showing the command
+                                                    toolDescription = 'Update project plan';
+                                                }
+                                            }
+                                        }
+                                        else if (command.includes('apply_patch')) {
+                                            // Extract patch content and format as proper diff like Edit tool
+                                            const patchMatch = command.match(/apply_patch\s+<<'PATCH'\n([\s\S]*?)\nPATCH/);
+                                            if (patchMatch) {
+                                                const patchContent = patchMatch[1];
+                                                // Extract file information from patch
+                                                const addFileMatch = patchContent.match(/\*\*\* Add File: (.+)/);
+                                                const updateFileMatch = patchContent.match(/\*\*\* Update File: (.+)/);
+                                                const modifyFileMatch = patchContent.match(/\*\*\* Modify File: (.+)/);
+                                                if (addFileMatch) {
+                                                    const fileName = addFileMatch[1];
+                                                    // Extract new file content from patch (lines starting with +)
+                                                    const contentLines = patchContent.split('\n').filter(line => line.startsWith('+') && !line.startsWith('+++'));
+                                                    const newContent = contentLines.map(line => line.substring(1)).join('\n');
+                                                    // Create proper unified diff format like Edit tool for new files
+                                                    const baseName = fileName.split('/').pop() || fileName;
+                                                    const newContentLines = newContent.split('\n');
+                                                    const unifiedDiff = `--- /dev/null
++++ ${baseName}
+@@ -0,0 +1,${newContentLines.length} @@
+${newContentLines.map(line => `+${line}`).join('\n')}`;
+                                                    const fileDiff = {
+                                                        fileDiff: unifiedDiff,
+                                                        fileName: baseName,
+                                                        originalContent: '',
+                                                        newContent,
+                                                    };
+                                                    resultDisplay = fileDiff;
+                                                    toolDescription = `Add file: ${fileName}`;
+                                                }
+                                                else if (updateFileMatch || modifyFileMatch) {
+                                                    const fileName = (updateFileMatch || modifyFileMatch)[1];
+                                                    // Parse the patch to extract old and new content
+                                                    const patchLines = patchContent.split('\n');
+                                                    let oldContent = '';
+                                                    let newContent = '';
+                                                    let inOldSection = false;
+                                                    let inNewSection = false;
+                                                    for (const line of patchLines) {
+                                                        if (line.startsWith('@@')) {
+                                                            // Start of a diff section
+                                                            continue;
+                                                        }
+                                                        else if (line.startsWith('-') && !line.startsWith('---')) {
+                                                            // Old content (removed lines)
+                                                            oldContent += line.substring(1) + '\n';
+                                                            inOldSection = true;
+                                                        }
+                                                        else if (line.startsWith('+') && !line.startsWith('+++')) {
+                                                            // New content (added lines)
+                                                            newContent += line.substring(1) + '\n';
+                                                            inNewSection = true;
+                                                        }
+                                                        else if (!line.startsWith('***') && !line.startsWith('---') && !line.startsWith('+++')) {
+                                                            // Context lines (unchanged)
+                                                            if (inOldSection)
+                                                                oldContent += line + '\n';
+                                                            if (inNewSection)
+                                                                newContent += line + '\n';
+                                                        }
+                                                    }
+                                                    // If we couldn't parse properly, fall back to showing the raw patch
+                                                    if (!oldContent && !newContent) {
+                                                        // Try to reconstruct from the patch format
+                                                        const beforeMatch = patchContent.match(/(?:^|\n)([^@\-+*].*)(?=\n[-+@])/gm);
+                                                        const afterMatch = patchContent.match(/(?:^|\n)\+(.*)$/gm);
+                                                        if (beforeMatch && afterMatch) {
+                                                            oldContent = beforeMatch.join('\n');
+                                                            newContent = afterMatch.map(line => line.substring(1)).join('\n');
+                                                        }
+                                                    }
+                                                    // Create a proper unified diff format like Edit tool uses
+                                                    const baseName = fileName.split('/').pop() || fileName;
+                                                    const unifiedDiff = `--- ${baseName}
++++ ${baseName}
+@@ -1,${oldContent.split('\n').length} +1,${newContent.split('\n').length} @@
+${oldContent.split('\n').map(line => `-${line}`).join('\n')}
+${newContent.split('\n').map(line => `+${line}`).join('\n')}`;
+                                                    const fileDiff = {
+                                                        fileDiff: unifiedDiff,
+                                                        fileName: baseName,
+                                                        originalContent: oldContent.trim(),
+                                                        newContent: newContent.trim(),
+                                                    };
+                                                    resultDisplay = fileDiff;
+                                                    toolDescription = `Update file: ${fileName}`;
+                                                }
+                                                else {
+                                                    toolDescription = 'Apply patch';
+                                                    // Fallback for unrecognized patch format
+                                                    resultDisplay = `🔧 Applying patch
+
+${patchContent.substring(0, 500)}${patchContent.length > 500 ? '...' : ''}`;
+                                                }
+                                            }
+                                        }
+                                        else if (toolName.includes('edit') || toolName.includes('replace') || parsed.toolCall.name === 'Edit' || parsed.toolCall.name === 'replace') {
+                                            // For edit/replace tools, create a FileDiff object that ToolMessage expects
+                                            const args = parsed.toolCall.args;
+                                            if (args['old_string'] && args['new_string']) {
+                                                const filePath = (args['file_path'] || 'file');
+                                                const oldString = args['old_string'];
+                                                const newString = args['new_string'];
+                                                const fileName = filePath.split('/').pop() || filePath;
+                                                // Create a proper unified diff format that DiffRenderer expects (same as Edit tool)
+                                                // Use the same logic as the Edit tool in packages/core/src/tools/edit.ts
+                                                const oldLines = oldString.split('\n');
+                                                const newLines = newString.split('\n');
+                                                // Create unified diff format similar to what Edit tool generates
+                                                const diffContent = `--- ${fileName}
++++ ${fileName}
+@@ -1,${oldLines.length} +1,${newLines.length} @@
+${oldLines.map(line => `-${line}`).join('\n')}
+${newLines.map(line => `+${line}`).join('\n')}`;
+                                                const fileDiff = {
+                                                    fileDiff: diffContent,
+                                                    fileName,
+                                                    originalContent: oldString,
+                                                    newContent: newString,
+                                                };
+                                                resultDisplay = fileDiff;
+                                                // Update tool description to be more specific
+                                                const instruction = args['instruction'];
+                                                toolDescription = instruction ? `${fileName}: ${instruction}` : `Replace in ${fileName}`;
+                                            }
+                                        }
+                                        else if (toolName.includes('write') || parsed.toolCall.name === 'write_file') {
+                                            // For write_file tools, create a FileDiff object that ToolMessage expects
+                                            const args = parsed.toolCall.args;
+                                            if (args['content'] && args['file_path']) {
+                                                const filePath = args['file_path'];
+                                                const newContent = args['content'];
+                                                const fileName = filePath.split('/').pop() || filePath;
+                                                // Create a unified diff format for new file (like Edit tool does for new files)
+                                                const newContentLines = newContent.split('\n');
+                                                const diffContent = `--- /dev/null
++++ ${fileName}
+@@ -0,0 +1,${newContentLines.length} @@
+${newContentLines.map(line => `+${line}`).join('\n')}`;
+                                                const fileDiff = {
+                                                    fileDiff: diffContent,
+                                                    fileName,
+                                                    originalContent: '', // Assume new file for now
+                                                    newContent,
+                                                };
+                                                resultDisplay = fileDiff;
+                                                toolDescription = `Write file: ${fileName}`;
+                                            }
+                                        }
+                                        else if (toolName.includes('todowrite') || toolName.includes('todo_write')) {
+                                            // For todo tools, create a TodoResultDisplay object that ToolMessage expects
+                                            const args = parsed.toolCall.args;
+                                            if (args['todos'] && Array.isArray(args['todos'])) {
+                                                const todoDisplay = {
+                                                    type: 'todo_list',
+                                                    todos: args['todos'],
+                                                };
+                                                resultDisplay = todoDisplay;
+                                            }
+                                        }
+                                        else if (toolName.includes('websearch') || toolName.includes('web_search')) {
+                                            // For web search tools, create a formatted string display
+                                            const args = parsed.toolCall.args;
+                                            const query = (args['query'] || args['search_query']);
+                                            if (query) {
+                                                resultDisplay = `🔍 Searching for: "${query}"
+
+This tool will search the web and return relevant results.`;
+                                            }
+                                        }
+                                        const toolCallDisplay = {
+                                            callId: parsed.toolCall.callId,
+                                            name: parsed.toolCall.name,
+                                            description: toolDescription,
+                                            status: ToolCallStatus.Executing, // Show as executing initially
+                                            resultDisplay,
+                                            confirmationDetails: undefined,
+                                        };
+                                        // Add the current text content to history first
+                                        if (streamingMessageBuffer.trim()) {
+                                            addItemToHistory({ type: 'gemini', text: streamingMessageBuffer }, userMessageTimestamp);
+                                            streamingMessageBuffer = '';
+                                        }
+                                        // Add the tool call as a tool group to history
+                                        const toolGroup = {
+                                            type: 'tool_group',
+                                            tools: [toolCallDisplay],
+                                        };
+                                        addItemToHistory(toolGroup, userMessageTimestamp);
+                                        // Reset the pending item for continued streaming
+                                        syncedSetPendingHistoryItem({ type: 'gemini', text: '' });
+                                    }
+                                    else if (parsed.type === 'tool_result' && parsed.toolResult) {
+                                        // Update the last tool call with the result
+                                        // For now, we'll just continue with text streaming since updating
+                                        // the tool result in history is complex. The tool result will be
+                                        // visible in the agent's final output.
+                                    }
+                                    processedUpTo = cumulativeOutput.indexOf(line) + line.length + 1;
+                                }
+                            }
+                            // Keep only unprocessed part of the buffer
+                            if (processedUpTo > 0) {
+                                cumulativeOutput = cumulativeOutput.substring(processedUpTo);
+                            }
+                        }
+                        else {
+                            // Handle other agents with cumulative/incremental detection
+                            if (cumulativeOutput && chunk.startsWith(cumulativeOutput)) {
+                                // This is a cumulative chunk - use it directly instead of appending
+                                cumulativeOutput = chunk;
+                            }
+                            else {
+                                // This is an incremental chunk - append it
+                                cumulativeOutput += chunk;
+                            }
+                            // Parse agent output for tool calls and schedule them properly
+                            if (scheduleToolCalls) {
+                                const { newProcessedLength, messageContent } = parseAgentOutputForToolCalls(cumulativeOutput, lastProcessedLength, scheduleToolCalls, abortSignal, agentType);
+                                lastProcessedLength = newProcessedLength;
+                                // Update UI with the message content (excluding tool calls)
+                                setPendingHistoryItem((item) => ({
+                                    type: item?.type,
+                                    text: messageContent || cumulativeOutput,
+                                }));
+                            }
+                            else {
+                                // Fallback: just show the raw output if no tool scheduler available
+                                setPendingHistoryItem((item) => ({
+                                    type: item?.type,
+                                    text: cumulativeOutput,
+                                }));
+                            }
+                        }
+                    },
+                    onComplete: (_, exitCode) => {
+                        onDebugMessage(`${agentType} agent completed with exit code: ${exitCode}`);
+                    },
+                    onError: (_, error) => {
+                        onDebugMessage(`${agentType} agent error: ${error.message}`);
+                    },
+                    abortSignal,
+                });
+                // Wait for execution to complete
+                const result = await executionPromise;
+                setPendingHistoryItem(null);
+                // Get final output
+                let finalOutput;
+                if (agentType === 'claude' || agentType === 'codex' || agentType === 'gemini') {
+                    finalOutput = streamingMessageBuffer || '(Agent produced no output)';
+                }
+                else {
+                    finalOutput = cumulativeOutput || '(Agent produced no output)';
+                }
+                if (result.error) {
+                    finalOutput = `Error: ${result.error.message}\n\n${finalOutput}`;
+                    addItemToHistory({
+                        type: 'error',
+                        text: finalOutput,
+                    }, userMessageTimestamp);
+                }
+                else if (abortSignal.aborted) {
+                    finalOutput = `Agent execution was cancelled.\n\n${finalOutput}`;
+                    addItemToHistory({
+                        type: 'error',
+                        text: finalOutput,
+                    }, userMessageTimestamp);
+                }
+                else if (result.exitCode !== 0 && result.exitCode !== null) {
+                    finalOutput = `Agent exited with code ${result.exitCode}.\n\n${finalOutput}`;
+                    addItemToHistory({
+                        type: 'error',
+                        text: finalOutput,
+                    }, userMessageTimestamp);
+                }
+                else {
+                    // Success - add as gemini response (only if there's actual text content)
+                    if (finalOutput && finalOutput !== '(Agent produced no output)') {
+                        addItemToHistory({
+                            type: 'gemini',
+                            text: finalOutput,
+                        }, userMessageTimestamp);
+                    }
+                }
+                resolve();
+            }
+            catch (err) {
+                setPendingHistoryItem(null);
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                addItemToHistory({
+                    type: 'error',
+                    text: `An unexpected error occurred during ${agentType} agent execution: ${errorMessage}`,
+                }, userMessageTimestamp);
+                resolve();
+            }
+        };
+        const execPromise = new Promise((resolve) => {
+            executeCommand(resolve);
+        });
+        onExec(execPromise);
+    }, [addItemToHistory, onExec, setPendingHistoryItem, onDebugMessage, config, handleStreamingContentEvent, syncedSetPendingHistoryItem, scheduleToolCalls]);
+    return { executeAgent };
+};
+//# sourceMappingURL=useAgentCommandProcessor.js.map