@qduc/term2 0.1.0

package/dist/hooks/use-conversation.js

@@ -0,0 +1,1017 @@
+import { useCallback, useRef, useState } from 'react';
+import { isAbortLikeError } from '../utils/error-helpers.js';
+import { createStreamingUpdateCoordinator } from '../utils/streaming-updater.js';
+import { appendMessagesCapped } from '../utils/message-buffer.js';
+const LIVE_RESPONSE_THROTTLE_MS = 150;
+const REASONING_RESPONSE_THROTTLE_MS = 200;
+const MAX_MESSAGE_COUNT = 300;
+export const filterPendingCommandMessagesForApproval = (messages, approval) => {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return messages ?? [];
+    }
+    const callId = approval?.callId ? String(approval.callId) : undefined;
+    const toolName = approval?.toolName;
+    if (!callId && !toolName) {
+        return messages;
+    }
+    return messages.filter(msg => {
+        if (!msg || msg.sender !== 'command') {
+            return true;
+        }
+        if (msg.status !== 'pending' && msg.status !== 'running') {
+            return true;
+        }
+        const matchesCallId = callId && msg.callId && String(msg.callId) === callId;
+        const matchesToolName = !callId && toolName && msg.toolName === toolName;
+        return !(matchesCallId || matchesToolName);
+    });
+};
+export const useConversation = ({ conversationService, loggingService, }) => {
+    const [messages, setMessages] = useState([]);
+    const [waitingForApproval, setWaitingForApproval] = useState(false);
+    const [waitingForRejectionReason, setWaitingForRejectionReason] = useState(false);
+    const [pendingApproval, setPendingApproval] = useState(null);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [liveResponse, setLiveResponse] = useState(null);
+    const approvedContextRef = useRef(null);
+    const createLiveResponseUpdater = useCallback((liveMessageId) => createStreamingUpdateCoordinator((text) => {
+        setLiveResponse(prev => prev && prev.id === liveMessageId
+            ? { ...prev, text }
+            : {
+                id: liveMessageId,
+                sender: 'bot',
+                text,
+            });
+    }, LIVE_RESPONSE_THROTTLE_MS), []);
+    const trimMessages = useCallback((list) => appendMessagesCapped(list, [], MAX_MESSAGE_COUNT), []);
+    const appendMessages = useCallback((additions) => {
+        if (!additions.length)
+            return;
+        setMessages(prev => trimMessages([...prev, ...additions]));
+    }, [trimMessages]);
+    // Helper to log events with deduplication
+    // const createEventLogger = () => {
+    //     let lastEventType: string | null = null;
+    //     let eventCount = 0;
+    //     let eventSequence: string[] = [];
+    //
+    //     const logDeduplicated = (eventType: string) => {
+    //         if (eventType !== lastEventType) {
+    //             if (lastEventType !== null) {
+    //                 loggingService.debug('Conversation event sequence', {
+    //                     event: lastEventType,
+    //                     count: eventCount,
+    //                     sequenceLength: eventSequence.length,
+    //                     sequence: eventSequence,
+    //                 });
+    //             }
+    //             lastEventType = eventType;
+    //             eventCount = 1;
+    //             if (!eventSequence.includes(eventType)) {
+    //                 eventSequence.push(eventType);
+    //             }
+    //         } else {
+    //             eventCount++;
+    //         }
+    //     };
+    //
+    //     const flush = () => {
+    //         if (lastEventType !== null) {
+    //             loggingService.debug('Conversation event sequence final', {
+    //                 event: lastEventType,
+    //                 count: eventCount,
+    //                 sequenceLength: eventSequence.length,
+    //                 sequence: eventSequence,
+    //             });
+    //             lastEventType = null;
+    //             eventCount = 0;
+    //             eventSequence = [];
+    //         }
+    //     };
+    //
+    //     return {logDeduplicated, flush};
+    // };
+    const annotateCommandMessage = useCallback((cmdMsg) => {
+        const approvalContext = approvedContextRef.current;
+        if (!approvalContext || cmdMsg.toolName !== 'search_replace') {
+            return cmdMsg;
+        }
+        const matchesCallId = approvalContext.callId &&
+            cmdMsg.callId &&
+            approvalContext.callId === cmdMsg.callId;
+        const matchesToolName = !approvalContext.callId &&
+            approvalContext.toolName &&
+            approvalContext.toolName === cmdMsg.toolName;
+        if (!matchesCallId && !matchesToolName) {
+            return cmdMsg;
+        }
+        if (matchesToolName && !approvalContext.callId) {
+            approvedContextRef.current = null;
+        }
+        return { ...cmdMsg, hadApproval: true };
+    }, []);
+    const applyServiceResult = useCallback((result, remainingText, remainingReasoningText, textWasFlushed) => {
+        if (!result) {
+            return;
+        }
+        if (result.type === 'approval_required') {
+            // Flush reasoning and text separately before showing approval prompt
+            const messagesToAdd = [];
+            if (remainingReasoningText?.trim() && !textWasFlushed) {
+                // Ensure reasoning is captured if not already streamed (edge case)
+                // But with new logic, it should be in messages.
+                // We'll leave this empty or remove it as reasoning is handled via stream
+            }
+            if (remainingText?.trim() && !textWasFlushed) {
+                const textMessage = {
+                    id: Date.now() + 1,
+                    sender: 'bot',
+                    text: remainingText,
+                };
+                messagesToAdd.push(textMessage);
+            }
+            appendMessages(messagesToAdd);
+            // If a tool call requires approval, we show it in the approval prompt.
+            // Don't also show the transient pending/running command message.
+            setMessages(prev => trimMessages(filterPendingCommandMessagesForApproval(prev, result.approval)));
+            setPendingApproval(result.approval);
+            // Set waiting state AFTER adding approval message to ensure proper render order
+            setWaitingForApproval(true);
+            return;
+        }
+        // If text was already flushed before command messages, don't add it again
+        // Only add final text if there's new text after the commands
+        const shouldAddBotMessage = !textWasFlushed || remainingText?.trim();
+        const finalText = remainingText?.trim()
+            ? remainingText
+            : result.finalText;
+        setMessages(prev => {
+            const messagesToAdd = [];
+            const annotatedCommands = result.commandMessages.map(annotateCommandMessage);
+            let next = [...prev, ...messagesToAdd, ...annotatedCommands];
+            if (shouldAddBotMessage && finalText) {
+                const botMessage = {
+                    id: Date.now() + 1,
+                    sender: 'bot',
+                    text: finalText,
+                };
+                next = [...next, botMessage];
+            }
+            return trimMessages(next);
+        });
+        setWaitingForApproval(false);
+        setPendingApproval(null);
+    }, [annotateCommandMessage, appendMessages, trimMessages]);
+    const sendUserMessage = useCallback(async (value) => {
+        if (!value.trim()) {
+            return;
+        }
+        const userMessage = {
+            id: Date.now(),
+            sender: 'user',
+            text: value,
+        };
+        appendMessages([userMessage]);
+        setIsProcessing(true);
+        const liveMessageId = Date.now();
+        setLiveResponse({
+            id: liveMessageId,
+            sender: 'bot',
+            text: '',
+        });
+        const liveResponseUpdater = createLiveResponseUpdater(liveMessageId);
+        // Track accumulated text so we can flush it before command messages
+        let accumulatedText = '';
+        let accumulatedReasoningText = '';
+        let flushedReasoningLength = 0; // Track how much reasoning has been flushed
+        let textWasFlushed = false;
+        let currentReasoningMessageId = null; // Track current reasoning message ID
+        const reasoningUpdater = createStreamingUpdateCoordinator((newReasoningText) => {
+            setMessages(prev => {
+                if (currentReasoningMessageId !== null) {
+                    const index = prev.findIndex(msg => msg.id === currentReasoningMessageId);
+                    if (index === -1)
+                        return prev;
+                    const current = prev[index];
+                    if (current.sender !== 'reasoning') {
+                        return prev;
+                    }
+                    const next = prev.slice();
+                    next[index] = { ...current, text: newReasoningText };
+                    return trimMessages(next);
+                }
+                const newId = Date.now();
+                currentReasoningMessageId = newId;
+                return trimMessages([
+                    ...prev,
+                    {
+                        id: newId,
+                        sender: 'reasoning',
+                        text: newReasoningText,
+                    },
+                ]);
+            });
+        }, REASONING_RESPONSE_THROTTLE_MS);
+        // Create event logger with deduplication for this message send
+        // const {logDeduplicated, flush: flushLog} = createEventLogger();
+        const applyConversationEvent = (event) => {
+            switch (event.type) {
+                case 'text_delta': {
+                    // logDeduplicated('text_delta');
+                    accumulatedText += event.delta;
+                    liveResponseUpdater.push(accumulatedText);
+                    return;
+                }
+                case 'reasoning_delta': {
+                    // logDeduplicated('reasoning_delta');
+                    const fullReasoningText = event.fullText ?? '';
+                    // Only show reasoning text after what was already flushed
+                    const newReasoningText = fullReasoningText.slice(flushedReasoningLength);
+                    accumulatedReasoningText = newReasoningText;
+                    if (!newReasoningText.trim())
+                        return;
+                    reasoningUpdater.push(newReasoningText);
+                    return;
+                }
+                case 'tool_started': {
+                    // Flush reasoning state
+                    if (accumulatedReasoningText.trim()) {
+                        reasoningUpdater.flush();
+                        flushedReasoningLength += accumulatedReasoningText.length;
+                        accumulatedReasoningText = '';
+                        currentReasoningMessageId = null;
+                    }
+                    // Flush any accumulated text before showing the tool call
+                    if (accumulatedText.trim()) {
+                        const textMessage = {
+                            id: Date.now() + 1,
+                            sender: 'bot',
+                            text: accumulatedText,
+                        };
+                        appendMessages([textMessage]);
+                        accumulatedText = '';
+                        textWasFlushed = true;
+                        liveResponseUpdater.cancel();
+                        setLiveResponse(null);
+                    }
+                    // Emit a "pending" command message when tool starts running
+                    // This provides immediate UI feedback before output is available
+                    const { toolCallId, toolName, arguments: rawArgs } = event;
+                    // tool_started.arguments may be either an object or a JSON string
+                    // depending on provider. Normalize so we can render params.
+                    const args = (() => {
+                        if (typeof rawArgs !== 'string') {
+                            return rawArgs;
+                        }
+                        const trimmed = rawArgs.trim();
+                        if (!trimmed) {
+                            return rawArgs;
+                        }
+                        try {
+                            return JSON.parse(trimmed);
+                        }
+                        catch {
+                            return rawArgs;
+                        }
+                    })();
+                    // Create a command string from the tool info
+                    const command = (() => {
+                        if (toolName === 'shell') {
+                            const cmd = args?.command ?? args?.commands;
+                            if (typeof cmd === 'string' && cmd.trim()) {
+                                return cmd;
+                            }
+                            if (Array.isArray(cmd) && cmd.length > 0) {
+                                return cmd.join('\n');
+                            }
+                        }
+                        if (toolName === 'grep' && args?.pattern) {
+                            return `grep "${args.pattern}" ${args.path ?? '.'}`;
+                        }
+                        if (toolName === 'search_replace') {
+                            return `search_replace "${args.search_content ?? ''}" → "${args.replace_content ?? ''}" ${args.path ?? ''}`;
+                        }
+                        if (toolName === 'apply_patch') {
+                            return `apply_patch ${args?.type ?? 'unknown'} ${args?.path ?? ''}`;
+                        }
+                        if (toolName === 'ask_mentor') {
+                            return `ask_mentor: ${args?.question ?? ''}`;
+                        }
+                        return `${toolName ?? 'unknown_tool'}`;
+                    })();
+                    const pendingMessage = {
+                        id: toolCallId ?? String(Date.now()),
+                        sender: 'command',
+                        status: 'running',
+                        command,
+                        output: '',
+                        callId: toolCallId,
+                        toolName,
+                        toolArgs: args,
+                    };
+                    appendMessages([pendingMessage]);
+                    return;
+                }
+                case 'command_message': {
+                    // logDeduplicated('command_message');
+                    const cmdMsg = event.message;
+                    const annotated = annotateCommandMessage(cmdMsg);
+                    // Before adding command message, flush reasoning and text separately
+                    // This preserves the order: reasoning -> command -> response text
+                    const messagesToAdd = [];
+                    if (accumulatedReasoningText.trim()) {
+                        reasoningUpdater.flush();
+                        // Reasoning is already in messages via stream updates.
+                        // We just need to track what we've "flushed" (sealed) so next reasoning chunks start fresh.
+                        flushedReasoningLength +=
+                            accumulatedReasoningText.length;
+                        accumulatedReasoningText = '';
+                        currentReasoningMessageId = null; // Reset for potential post-command reasoning
+                    }
+                    if (accumulatedText.trim()) {
+                        const textMessage = {
+                            id: Date.now() + 1,
+                            sender: 'bot',
+                            text: accumulatedText,
+                        };
+                        messagesToAdd.push(textMessage);
+                        accumulatedText = '';
+                        textWasFlushed = true;
+                    }
+                    if (messagesToAdd.length > 0) {
+                        appendMessages(messagesToAdd);
+                        // Clear live response since we've committed the text
+                        liveResponseUpdater.cancel();
+                        setLiveResponse(null);
+                    }
+                    // Replace pending message with completed one, or add new if not found
+                    setMessages(prev => {
+                        // Try to find the pending message by callId
+                        const pendingIndex = annotated.callId
+                            ? prev.findIndex(msg => msg.sender === 'command' &&
+                                msg.callId === annotated.callId &&
+                                msg.status === 'running')
+                            : -1;
+                        if (pendingIndex !== -1) {
+                            // Replace the pending message with the completed one
+                            const next = [...prev];
+                            next[pendingIndex] = annotated;
+                            return trimMessages(next);
+                        }
+                        // If no pending message found, append the completed one
+                        return trimMessages([...prev, annotated]);
+                    });
+                    return;
+                }
+                case 'retry': {
+                    const systemMessage = {
+                        id: Date.now(),
+                        sender: 'system',
+                        text: `Tool hallucination detected (${event.toolName}). Retrying... (Attempt ${event.attempt}/${event.maxRetries})`,
+                    };
+                    setMessages(prev => [...prev, systemMessage]);
+                    return;
+                }
+                default:
+                    return;
+            }
+        };
+        try {
+            const result = await conversationService.sendMessage(value, {
+                onEvent: applyConversationEvent,
+            });
+            applyServiceResult(result, accumulatedText, accumulatedReasoningText, textWasFlushed);
+        }
+        catch (error) {
+            loggingService.error('Error in sendUserMessage', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            // Don't show error messages for user-initiated aborts
+            if (isAbortLikeError(error)) {
+                loggingService.debug('Suppressing abort error in sendUserMessage');
+                // The finally block will handle cleanup
+                return;
+            }
+            let errorMessage = error instanceof Error ? error.message : String(error);
+            // Enhance error messages for common issues
+            if (errorMessage.includes('OPENAI_API_KEY') ||
+                (errorMessage.includes('401') &&
+                    errorMessage.toLowerCase().includes('unauthorized'))) {
+                errorMessage =
+                    'OpenAI API key is not configured or invalid. Please set the OPENAI_API_KEY environment variable. ' +
+                        'Get your API key from: https://platform.openai.com/api-keys';
+            }
+            // Check if this is a max turns exceeded error
+            const isMaxTurnsError = errorMessage.includes('Max turns') &&
+                errorMessage.includes('exceeded');
+            if (isMaxTurnsError) {
+                // Create an approval prompt for max turns continuation
+                setPendingApproval({
+                    agentName: 'System',
+                    toolName: 'max_turns_exceeded',
+                    argumentsText: errorMessage,
+                    rawInterruption: null,
+                    isMaxTurnsPrompt: true,
+                });
+                setWaitingForApproval(true);
+            }
+            else {
+                // For other errors, just show the error message
+                const botErrorMessage = {
+                    id: Date.now(),
+                    sender: 'bot',
+                    text: `Error: ${errorMessage}`,
+                };
+                appendMessages([botErrorMessage]);
+                // Reset approval state on error to allow user to continue
+                setWaitingForApproval(false);
+                setPendingApproval(null);
+            }
+        }
+        finally {
+            loggingService.debug('sendUserMessage finally block - resetting state');
+            // flushLog();
+            reasoningUpdater.flush();
+            liveResponseUpdater.cancel();
+            setLiveResponse(null);
+            setIsProcessing(false);
+            // Don't reset waitingForApproval here - it's set by applyServiceResult
+            // and should only be cleared by handleApprovalDecision or stopProcessing
+        }
+    }, [conversationService, applyServiceResult, appendMessages, trimMessages, loggingService, createLiveResponseUpdater]);
+    const handleApprovalDecision = useCallback(async (answer, rejectionReason) => {
+        if (!waitingForApproval || !pendingApproval) {
+            return;
+        }
+        // Check if this is a max turns exceeded prompt
+        const isMaxTurnsPrompt = pendingApproval.isMaxTurnsPrompt;
+        if (answer === 'y' &&
+            pendingApproval.toolName === 'search_replace') {
+            approvedContextRef.current = {
+                callId: pendingApproval.callId,
+                toolName: pendingApproval.toolName,
+            };
+        }
+        setPendingApproval(null);
+        setWaitingForApproval(false);
+        // Handle "n" answer for max turns - return to input
+        if (isMaxTurnsPrompt && answer === 'n') {
+            setIsProcessing(false);
+            return;
+        }
+        // Handle "y" answer for max turns - continue execution automatically
+        if (isMaxTurnsPrompt && answer === 'y') {
+            setIsProcessing(true);
+            const liveMessageId = Date.now();
+            setLiveResponse({
+                id: liveMessageId,
+                sender: 'bot',
+                text: '',
+            });
+            const liveResponseUpdater = createLiveResponseUpdater(liveMessageId);
+            // Track accumulated text so we can flush it before command messages
+            let accumulatedText = '';
+            let accumulatedReasoningText = '';
+            let flushedReasoningLength = 0;
+            let textWasFlushed = false;
+            let currentReasoningMessageId = null;
+            const reasoningUpdater = createStreamingUpdateCoordinator((newReasoningText) => {
+                setMessages(prev => {
+                    if (currentReasoningMessageId !== null) {
+                        const index = prev.findIndex(msg => msg.id === currentReasoningMessageId);
+                        if (index === -1)
+                            return prev;
+                        const current = prev[index];
+                        if (current.sender !== 'reasoning') {
+                            return prev;
+                        }
+                        const next = prev.slice();
+                        next[index] = {
+                            ...current,
+                            text: newReasoningText,
+                        };
+                        return trimMessages(next);
+                    }
+                    const newId = Date.now();
+                    currentReasoningMessageId = newId;
+                    return trimMessages([
+                        ...prev,
+                        {
+                            id: newId,
+                            sender: 'reasoning',
+                            text: newReasoningText,
+                        },
+                    ]);
+                });
+            }, REASONING_RESPONSE_THROTTLE_MS);
+            // const {logDeduplicated, flush: flushLog} = createEventLogger();
+            const applyConversationEvent = (event) => {
+                switch (event.type) {
+                    case 'text_delta': {
+                        // logDeduplicated('text_delta');
+                        accumulatedText += event.delta;
+                        liveResponseUpdater.push(accumulatedText);
+                        return;
+                    }
+                    case 'reasoning_delta': {
+                        // logDeduplicated('reasoning_delta');
+                        const fullReasoningText = event.fullText ?? '';
+                        const newReasoningText = fullReasoningText.slice(flushedReasoningLength);
+                        accumulatedReasoningText = newReasoningText;
+                        if (!newReasoningText.trim())
+                            return;
+                        reasoningUpdater.push(newReasoningText);
+                        return;
+                    }
+                    case 'tool_started': {
+                        // Flush reasoning state
+                        if (accumulatedReasoningText.trim()) {
+                            reasoningUpdater.flush();
+                            flushedReasoningLength += accumulatedReasoningText.length;
+                            accumulatedReasoningText = '';
+                            currentReasoningMessageId = null;
+                        }
+                        // Flush any accumulated text before showing the tool call
+                        if (accumulatedText.trim()) {
+                            const textMessage = {
+                                id: Date.now() + 1,
+                                sender: 'bot',
+                                text: accumulatedText,
+                            };
+                            appendMessages([textMessage]);
+                            accumulatedText = '';
+                            textWasFlushed = true;
+                            liveResponseUpdater.cancel();
+                            setLiveResponse(null);
+                        }
+                        const { toolCallId, toolName, arguments: rawArgs } = event;
+                        const args = (() => {
+                            if (typeof rawArgs !== 'string') {
+                                return rawArgs;
+                            }
+                            const trimmed = rawArgs.trim();
+                            if (!trimmed) {
+                                return rawArgs;
+                            }
+                            try {
+                                return JSON.parse(trimmed);
+                            }
+                            catch {
+                                return rawArgs;
+                            }
+                        })();
+                        const command = (() => {
+                            if (toolName === 'shell') {
+                                const cmd = args?.command ?? args?.commands;
+                                if (typeof cmd === 'string' && cmd.trim()) {
+                                    return cmd;
+                                }
+                                if (Array.isArray(cmd) && cmd.length > 0) {
+                                    return cmd.join('\n');
+                                }
+                            }
+                            if (toolName === 'grep' && args?.pattern) {
+                                return `grep "${args.pattern}" ${args.path ?? '.'}`;
+                            }
+                            if (toolName === 'search_replace') {
+                                return `search_replace "${args.search_content ?? ''}" → "${args.replace_content ?? ''}" ${args.path ?? ''}`;
+                            }
+                            if (toolName === 'apply_patch') {
+                                return `apply_patch ${args?.type ?? 'unknown'} ${args?.path ?? ''}`;
+                            }
+                            if (toolName === 'ask_mentor') {
+                                return `ask_mentor: ${args?.question ?? ''}`;
+                            }
+                            return `${toolName ?? 'unknown_tool'}`;
+                        })();
+                        const pendingMessage = {
+                            id: toolCallId ?? String(Date.now()),
+                            sender: 'command',
+                            status: 'running',
+                            command,
+                            output: '',
+                            callId: toolCallId,
+                            toolName,
+                            toolArgs: args,
+                        };
+                        appendMessages([pendingMessage]);
+                        return;
+                    }
+                    case 'command_message': {
+                        // logDeduplicated('command_message');
+                        const cmdMsg = event.message;
+                        const annotated = annotateCommandMessage(cmdMsg);
+                        const messagesToAdd = [];
+                        if (accumulatedReasoningText.trim()) {
+                            reasoningUpdater.flush();
+                            flushedReasoningLength +=
+                                accumulatedReasoningText.length;
+                            accumulatedReasoningText = '';
+                            currentReasoningMessageId = null;
+                        }
+                        if (accumulatedText.trim()) {
+                            const textMessage = {
+                                id: Date.now() + 1,
+                                sender: 'bot',
+                                text: accumulatedText,
+                            };
+                            messagesToAdd.push(textMessage);
+                            accumulatedText = '';
+                            textWasFlushed = true;
+                        }
+                        if (messagesToAdd.length > 0) {
+                            appendMessages(messagesToAdd);
+                            liveResponseUpdater.cancel();
+                            setLiveResponse(null);
+                        }
+                        // Replace pending message with completed one, or add new if not found
+                        setMessages(prev => {
+                            const pendingIndex = annotated.callId
+                                ? prev.findIndex(msg => msg.sender === 'command' &&
+                                    msg.callId === annotated.callId &&
+                                    msg.status === 'running')
+                                : -1;
+                            if (pendingIndex !== -1) {
+                                const next = [...prev];
+                                next[pendingIndex] = annotated;
+                                return trimMessages(next);
+                            }
+                            return trimMessages([...prev, annotated]);
+                        });
+                        return;
+                    }
+                    case 'retry': {
+                        const systemMessage = {
+                            id: Date.now(),
+                            sender: 'system',
+                            text: `Tool hallucination detected (${event.toolName}). Retrying... (Attempt ${event.attempt}/${event.maxRetries})`,
+                        };
+                        setMessages(prev => [...prev, systemMessage]);
+                        return;
+                    }
+                    default:
+                        return;
+                }
+            };
+            try {
+                // Send a continuation message to resume work
+                const continuationMessage = 'Please continue with your previous task.';
+                const result = await conversationService.sendMessage(continuationMessage, {
+                    onEvent: applyConversationEvent,
+                });
+                applyServiceResult(result, accumulatedText, accumulatedReasoningText, textWasFlushed);
+            }
+            catch (error) {
+                loggingService.error('Error in continuation after max turns', {
+                    error: error instanceof Error
+                        ? error.message
+                        : String(error),
+                    stack: error instanceof Error
+                        ? error.stack
+                        : undefined,
+                });
+                // Don't show error messages for user-initiated aborts
+                if (isAbortLikeError(error)) {
+                    loggingService.debug('Suppressing abort error in max turns continuation');
+                    // The finally block will handle cleanup
+                    return;
+                }
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const botErrorMessage = {
+                    id: Date.now(),
+                    sender: 'bot',
+                    text: `Error: ${errorMessage}`,
+                };
+                appendMessages([botErrorMessage]);
+                setWaitingForApproval(false);
+                setPendingApproval(null);
+            }
+            finally {
+                // flushLog();
+                reasoningUpdater.flush();
+                liveResponseUpdater.cancel();
+                setLiveResponse(null);
+                setIsProcessing(false);
+            }
+            return;
+        }
+        setIsProcessing(true);
+        const liveMessageId = Date.now();
+        setLiveResponse({
+            id: liveMessageId,
+            sender: 'bot',
+            text: '',
+        });
+        const liveResponseUpdater = createLiveResponseUpdater(liveMessageId);
+        // Track accumulated text so we can flush it before command messages
+        let accumulatedText = '';
+        let accumulatedReasoningText = '';
+        let flushedReasoningLength = 0; // Track how much reasoning has been flushed
+        let textWasFlushed = false;
+        let currentReasoningMessageId = null; // Track current reasoning message ID
+        const reasoningUpdater = createStreamingUpdateCoordinator((newReasoningText) => {
+            setMessages(prev => {
+                if (currentReasoningMessageId !== null) {
+                    const index = prev.findIndex(msg => msg.id === currentReasoningMessageId);
+                    if (index === -1)
+                        return prev;
+                    const current = prev[index];
+                    if (current.sender !== 'reasoning') {
+                        return prev;
+                    }
+                    const next = prev.slice();
+                    next[index] = { ...current, text: newReasoningText };
+                    return trimMessages(next);
+                }
+                const newId = Date.now();
+                currentReasoningMessageId = newId;
+                return trimMessages([
+                    ...prev,
+                    {
+                        id: newId,
+                        sender: 'reasoning',
+                        text: newReasoningText,
+                    },
+                ]);
+            });
+        }, REASONING_RESPONSE_THROTTLE_MS);
+        // Create event logger with deduplication for this approval decision
+        // const {logDeduplicated, flush: flushLog} = createEventLogger();
+        const applyConversationEvent = (event) => {
+            switch (event.type) {
+                case 'text_delta': {
+                    // logDeduplicated('text_delta');
+                    accumulatedText += event.delta;
+                    liveResponseUpdater.push(accumulatedText);
+                    return;
+                }
+                case 'reasoning_delta': {
+                    // logDeduplicated('reasoning_delta');
+                    const fullReasoningText = event.fullText ?? '';
+                    const newReasoningText = fullReasoningText.slice(flushedReasoningLength);
+                    accumulatedReasoningText = newReasoningText;
+                    if (!newReasoningText.trim())
+                        return;
+                    reasoningUpdater.push(newReasoningText);
+                    return;
+                }
+                case 'tool_started': {
+                    // Flush reasoning state
+                    if (accumulatedReasoningText.trim()) {
+                        reasoningUpdater.flush();
+                        flushedReasoningLength += accumulatedReasoningText.length;
+                        accumulatedReasoningText = '';
+                        currentReasoningMessageId = null;
+                    }
+                    // Flush any accumulated text before showing the tool call
+                    if (accumulatedText.trim()) {
+                        const textMessage = {
+                            id: Date.now() + 1,
+                            sender: 'bot',
+                            text: accumulatedText,
+                        };
+                        appendMessages([textMessage]);
+                        accumulatedText = '';
+                        textWasFlushed = true;
+                        liveResponseUpdater.cancel();
+                        setLiveResponse(null);
+                    }
+                    const { toolCallId, toolName, arguments: rawArgs } = event;
+                    // tool_started.arguments may be either an object or a JSON string
+                    // depending on provider. Normalize so we can render params.
+                    const args = (() => {
+                        if (typeof rawArgs !== 'string') {
+                            return rawArgs;
+                        }
+                        const trimmed = rawArgs.trim();
+                        if (!trimmed) {
+                            return rawArgs;
+                        }
+                        try {
+                            return JSON.parse(trimmed);
+                        }
+                        catch {
+                            return rawArgs;
+                        }
+                    })();
+                    const command = (() => {
+                        if (toolName === 'shell') {
+                            const cmd = args?.command ?? args?.commands;
+                            if (typeof cmd === 'string' && cmd.trim()) {
+                                return cmd;
+                            }
+                            if (Array.isArray(cmd) && cmd.length > 0) {
+                                return cmd.join('\n');
+                            }
+                        }
+                        if (toolName === 'grep' && args?.pattern) {
+                            return `grep "${args.pattern}" ${args.path ?? '.'}`;
+                        }
+                        if (toolName === 'search_replace') {
+                            return `search_replace "${args.search_content ?? ''}" → "${args.replace_content ?? ''}" ${args.path ?? ''}`;
+                        }
+                        if (toolName === 'apply_patch') {
+                            return `apply_patch ${args?.type ?? 'unknown'} ${args?.path ?? ''}`;
+                        }
+                        if (toolName === 'ask_mentor') {
+                            return `ask_mentor: ${args?.question ?? ''}`;
+                        }
+                        return `${toolName ?? 'unknown_tool'}`;
+                    })();
+                    const pendingMessage = {
+                        id: toolCallId ?? String(Date.now()),
+                        sender: 'command',
+                        status: 'running',
+                        command,
+                        output: '',
+                        callId: toolCallId,
+                        toolName,
+                        toolArgs: args,
+                    };
+                    appendMessages([pendingMessage]);
+                    return;
+                }
+                case 'command_message': {
+                    // logDeduplicated('command_message');
+                    const cmdMsg = event.message;
+                    const annotated = annotateCommandMessage(cmdMsg);
+                    const messagesToAdd = [];
+                    if (accumulatedReasoningText.trim()) {
+                        reasoningUpdater.flush();
+                        flushedReasoningLength +=
+                            accumulatedReasoningText.length;
+                        accumulatedReasoningText = '';
+                        currentReasoningMessageId = null;
+                    }
+                    if (accumulatedText.trim()) {
+                        const textMessage = {
+                            id: Date.now() + 1,
+                            sender: 'bot',
+                            text: accumulatedText,
+                        };
+                        messagesToAdd.push(textMessage);
+                        accumulatedText = '';
+                        textWasFlushed = true;
+                    }
+                    if (messagesToAdd.length > 0) {
+                        appendMessages(messagesToAdd);
+                        liveResponseUpdater.cancel();
+                        setLiveResponse(null);
+                    }
+                    // Replace pending message with completed one, or add new if not found
+                    setMessages(prev => {
+                        const pendingIndex = annotated.callId
+                            ? prev.findIndex(msg => msg.sender === 'command' &&
+                                msg.callId === annotated.callId &&
+                                msg.status === 'running')
+                            : -1;
+                        if (pendingIndex !== -1) {
+                            const next = [...prev];
+                            next[pendingIndex] = annotated;
+                            return trimMessages(next);
+                        }
+                        return trimMessages([...prev, annotated]);
+                    });
+                    return;
+                }
+                case 'retry': {
+                    const systemMessage = {
+                        id: Date.now(),
+                        sender: 'system',
+                        text: `Tool hallucination detected (${event.toolName}). Retrying... (Attempt ${event.attempt}/${event.maxRetries})`,
+                    };
+                    setMessages(prev => [...prev, systemMessage]);
+                    return;
+                }
+                default:
+                    return;
+            }
+        };
+        try {
+            const result = await conversationService.handleApprovalDecision(answer, rejectionReason, {
+                onEvent: applyConversationEvent,
+            });
+            applyServiceResult(result, accumulatedText, accumulatedReasoningText, textWasFlushed);
+        }
+        catch (error) {
+            loggingService.error('Error in handleApprovalDecision', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            // Don't show error messages for user-initiated aborts
+            if (isAbortLikeError(error)) {
+                loggingService.debug('Suppressing abort error in handleApprovalDecision');
+                // The finally block will handle cleanup
+                return;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const botErrorMessage = {
+                id: Date.now(),
+                sender: 'bot',
+                text: `Error: ${errorMessage}`,
+            };
+            appendMessages([botErrorMessage]);
+            // Reset approval state on error to allow user to continue
+            setWaitingForApproval(false);
+            setPendingApproval(null);
+        }
+        finally {
+            loggingService.debug('handleApprovalDecision finally block - resetting state');
+            // flushLog();
+            reasoningUpdater.flush();
+            liveResponseUpdater.cancel();
+            setLiveResponse(null);
+            setIsProcessing(false);
+            // Don't reset approval state here - if the result is another approval_required,
+            // applyServiceResult will set waitingForApproval=true, but this finally block
+            // would immediately clear it, causing the input box to reappear
+        }
+    }, [
+        applyServiceResult,
+        conversationService,
+        waitingForApproval,
+        pendingApproval,
+        appendMessages,
+        trimMessages,
+        loggingService,
+        createLiveResponseUpdater,
+    ]);
+    const clearConversation = useCallback(() => {
+        conversationService.reset();
+        setMessages([]);
+        setWaitingForApproval(false);
+        setPendingApproval(null);
+        approvedContextRef.current = null;
+        setIsProcessing(false);
+        setLiveResponse(null);
+    }, [conversationService]);
+    const stopProcessing = useCallback(() => {
+        conversationService.abort();
+        setWaitingForApproval(false);
+        setWaitingForRejectionReason(false);
+        setPendingApproval(null);
+        approvedContextRef.current = null;
+        setIsProcessing(false);
+        setLiveResponse(null);
+    }, [conversationService]);
+    const setModel = useCallback((model) => {
+        conversationService.setModel(model);
+    }, [conversationService]);
+    const setReasoningEffort = useCallback((effort) => {
+        conversationService.setReasoningEffort?.(effort);
+    }, [conversationService]);
+    const setTemperature = useCallback((temperature) => {
+        conversationService.setTemperature?.(temperature);
+    }, [conversationService]);
+    const addSystemMessage = useCallback((text) => {
+        appendMessages([
+            {
+                id: Date.now(),
+                sender: 'system',
+                text,
+            },
+        ]);
+    }, [appendMessages]);
+    const addShellMessage = useCallback((command, output, exitCode, timedOut) => {
+        const success = !timedOut && exitCode === 0;
+        const failureReason = timedOut
+            ? 'timeout'
+            : exitCode == null
+                ? 'error'
+                : exitCode !== 0
+                    ? `exit ${exitCode}`
+                    : undefined;
+        appendMessages([
+            {
+                id: String(Date.now()),
+                sender: 'command',
+                status: success ? 'completed' : 'failed',
+                command,
+                output,
+                success,
+                failureReason,
+                toolName: 'shell',
+            },
+        ]);
+    }, [appendMessages]);
+    return {
+        messages,
+        liveResponse,
+        pendingApproval,
+        waitingForApproval,
+        waitingForRejectionReason,
+        setWaitingForRejectionReason,
+        isProcessing,
+        sendUserMessage,
+        handleApprovalDecision,
+        clearConversation,
+        stopProcessing,
+        setModel,
+        setReasoningEffort,
+        setTemperature,
+        addSystemMessage,
+        addShellMessage,
+    };
+};
+//# sourceMappingURL=use-conversation.js.map