@qduc/term2 0.1.3 → 0.1.5

package/dist/hooks/use-conversation.js

@@ -2,6 +2,8 @@ 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';
+import { createStreamingState, enhanceApiKeyError, isMaxTurnsError, } from '../utils/conversation-utils.js';
+import { createConversationEventHandler } from '../utils/conversation-event-handler.js';
 const LIVE_RESPONSE_THROTTLE_MS = 150;
 const REASONING_RESPONSE_THROTTLE_MS = 200;
 const MAX_MESSAGE_COUNT = 300;
@@ -33,6 +35,7 @@ export const useConversation = ({ conversationService, loggingService, }) => {
     const [pendingApproval, setPendingApproval] = useState(null);
     const [isProcessing, setIsProcessing] = useState(false);
     const [liveResponse, setLiveResponse] = useState(null);
+    const [lastUsage, setLastUsage] = useState(null);
     const approvedContextRef = useRef(null);
     const createLiveResponseUpdater = useCallback((liveMessageId) => createStreamingUpdateCoordinator((text) => {
         setLiveResponse(prev => prev && prev.id === liveMessageId
@@ -161,6 +164,9 @@ export const useConversation = ({ conversationService, loggingService, }) => {
         });
         setWaitingForApproval(false);
         setPendingApproval(null);
+        if (result.usage) {
+            setLastUsage(result.usage);
+        }
     }, [annotateCommandMessage, appendMessages, trimMessages]);
     const sendUserMessage = useCallback(async (value) => {
         if (!value.trim()) {
@@ -180,16 +186,12 @@ export const useConversation = ({ conversationService, loggingService, }) => {
             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
+        // Create streaming state object for this message send
+        const streamingState = createStreamingState();
         const reasoningUpdater = createStreamingUpdateCoordinator((newReasoningText) => {
             setMessages(prev => {
-                if (currentReasoningMessageId !== null) {
-                    const index = prev.findIndex(msg => msg.id === currentReasoningMessageId);
+                if (streamingState.currentReasoningMessageId !== null) {
+                    const index = prev.findIndex(msg => msg.id === streamingState.currentReasoningMessageId);
                     if (index === -1)
                         return prev;
                     const current = prev[index];
@@ -201,7 +203,7 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                     return trimMessages(next);
                 }
                 const newId = Date.now();
-                currentReasoningMessageId = newId;
+                streamingState.currentReasoningMessageId = newId;
                 return trimMessages([
                     ...prev,
                     {
@@ -212,175 +214,33 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                 ]);
             });
         }, REASONING_RESPONSE_THROTTLE_MS);
-        // Create event logger with deduplication for this message send
-        // const {logDeduplicated, flush: flushLog} = createEventLogger();
+        // Create event handler using extracted factory
+        const baseEventHandler = createConversationEventHandler({
+            liveResponseUpdater,
+            reasoningUpdater,
+            appendMessages,
+            setMessages,
+            setLiveResponse,
+            trimMessages,
+            annotateCommandMessage,
+        }, streamingState);
         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;
+            if (event.type === 'final') {
+                if (event.usage) {
+                    loggingService.debug('UI received final usage (sendUserMessage)', { usage: event.usage });
+                    setLastUsage(event.usage);
                 }
-                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;
+                else {
+                    loggingService.debug('UI final event has no usage (sendUserMessage)');
                 }
-                default:
-                    return;
             }
+            baseEventHandler(event);
         };
         try {
             const result = await conversationService.sendMessage(value, {
                 onEvent: applyConversationEvent,
             });
-            applyServiceResult(result, accumulatedText, accumulatedReasoningText, textWasFlushed);
+            applyServiceResult(result, streamingState.accumulatedText, streamingState.accumulatedReasoningText, streamingState.textWasFlushed);
         }
         catch (error) {
             loggingService.error('Error in sendUserMessage', {
@@ -393,19 +253,9 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                 // 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) {
+            const rawErrorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = enhanceApiKeyError(rawErrorMessage);
+            if (isMaxTurnsError(errorMessage)) {
                 // Create an approval prompt for max turns continuation
                 setPendingApproval({
                     agentName: 'System',
@@ -470,16 +320,12 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                 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;
+            // Create streaming state object for max turns continuation
+            const streamingState = createStreamingState();
             const reasoningUpdater = createStreamingUpdateCoordinator((newReasoningText) => {
                 setMessages(prev => {
-                    if (currentReasoningMessageId !== null) {
-                        const index = prev.findIndex(msg => msg.id === currentReasoningMessageId);
+                    if (streamingState.currentReasoningMessageId !== null) {
+                        const index = prev.findIndex(msg => msg.id === streamingState.currentReasoningMessageId);
                         if (index === -1)
                             return prev;
                         const current = prev[index];
@@ -494,7 +340,7 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                         return trimMessages(next);
                     }
                     const newId = Date.now();
-                    currentReasoningMessageId = newId;
+                    streamingState.currentReasoningMessageId = newId;
                     return trimMessages([
                         ...prev,
                         {
@@ -505,154 +351,27 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                     ]);
                 });
             }, REASONING_RESPONSE_THROTTLE_MS);
-            // const {logDeduplicated, flush: flushLog} = createEventLogger();
+            // Create event handler using extracted factory
+            const baseEventHandler = createConversationEventHandler({
+                liveResponseUpdater,
+                reasoningUpdater,
+                appendMessages,
+                setMessages,
+                setLiveResponse,
+                trimMessages,
+                annotateCommandMessage,
+            }, streamingState);
             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;
+                if (event.type === 'final') {
+                    if (event.usage) {
+                        loggingService.debug('UI received final usage (maxTurnsContinuation)', { usage: event.usage });
+                        setLastUsage(event.usage);
                     }
-                    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;
+                    else {
+                        loggingService.debug('UI final event has no usage (maxTurnsContinuation)');
                     }
-                    default:
-                        return;
                 }
+                baseEventHandler(event);
             };
             try {
                 // Send a continuation message to resume work
@@ -660,7 +379,7 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                 const result = await conversationService.sendMessage(continuationMessage, {
                     onEvent: applyConversationEvent,
                 });
-                applyServiceResult(result, accumulatedText, accumulatedReasoningText, textWasFlushed);
+                applyServiceResult(result, streamingState.accumulatedText, streamingState.accumulatedReasoningText, streamingState.textWasFlushed);
             }
             catch (error) {
                 loggingService.error('Error in continuation after max turns', {
@@ -704,16 +423,12 @@ export const useConversation = ({ conversationService, loggingService, }) => {
             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
+        // Create streaming state object for this approval decision
+        const streamingState = createStreamingState();
         const reasoningUpdater = createStreamingUpdateCoordinator((newReasoningText) => {
             setMessages(prev => {
-                if (currentReasoningMessageId !== null) {
-                    const index = prev.findIndex(msg => msg.id === currentReasoningMessageId);
+                if (streamingState.currentReasoningMessageId !== null) {
+                    const index = prev.findIndex(msg => msg.id === streamingState.currentReasoningMessageId);
                     if (index === -1)
                         return prev;
                     const current = prev[index];
@@ -725,7 +440,7 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                     return trimMessages(next);
                 }
                 const newId = Date.now();
-                currentReasoningMessageId = newId;
+                streamingState.currentReasoningMessageId = newId;
                 return trimMessages([
                     ...prev,
                     {
@@ -736,163 +451,33 @@ export const useConversation = ({ conversationService, loggingService, }) => {
                 ]);
             });
         }, REASONING_RESPONSE_THROTTLE_MS);
-        // Create event logger with deduplication for this approval decision
-        // const {logDeduplicated, flush: flushLog} = createEventLogger();
+        // Create event handler using extracted factory
+        const baseEventHandler = createConversationEventHandler({
+            liveResponseUpdater,
+            reasoningUpdater,
+            appendMessages,
+            setMessages,
+            setLiveResponse,
+            trimMessages,
+            annotateCommandMessage,
+        }, streamingState);
         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;
+            if (event.type === 'final') {
+                if (event.usage) {
+                    loggingService.debug('UI received final usage (approvalDecision)', { usage: event.usage });
+                    setLastUsage(event.usage);
                 }
-                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;
+                else {
+                    loggingService.debug('UI final event has no usage (approvalDecision)');
                 }
-                default:
-                    return;
             }
+            baseEventHandler(event);
         };
         try {
             const result = await conversationService.handleApprovalDecision(answer, rejectionReason, {
                 onEvent: applyConversationEvent,
             });
-            applyServiceResult(result, accumulatedText, accumulatedReasoningText, textWasFlushed);
+            applyServiceResult(result, streamingState.accumulatedText, streamingState.accumulatedReasoningText, streamingState.textWasFlushed);
         }
         catch (error) {
             loggingService.error('Error in handleApprovalDecision', {
@@ -998,6 +583,7 @@ export const useConversation = ({ conversationService, loggingService, }) => {
     return {
         messages,
         liveResponse,
+        lastUsage,
         pendingApproval,
         waitingForApproval,
         waitingForRejectionReason,