@vybestack/llxprt-code 0.2.25 → 0.3.4-nightly.250912.5e46408e

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

@@ -1,10 +1,10 @@
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2025 Vybestack LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
-import { GeminiEventType as ServerGeminiEventType, getErrorMessage, isNodeError, MessageSenderType, GitService, UnauthorizedError, DEFAULT_GEMINI_FLASH_MODEL, AuthType, parseAndFormatApiError, EmojiFilter, DebugLogger, } from '@vybestack/llxprt-code-core';
+import { GeminiEventType as ServerGeminiEventType, getErrorMessage, isNodeError, MessageSenderType, logUserPrompt, GitService, UnauthorizedError, UserPromptEvent, DEFAULT_GEMINI_FLASH_MODEL, parseAndFormatApiError, } from '@vybestack/llxprt-code-core';
 import { FinishReason } from '@google/genai';
 import { StreamingState, MessageType, ToolCallStatus, } from '../types.js';
 import { isAtCommand } from '../utils/commandUtils.js';
@@ -17,7 +17,6 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { useReactToolScheduler, mapToDisplay as mapTrackedToolCallsToDisplay, } from './useReactToolScheduler.js';
 import { useSessionStats } from '../contexts/SessionContext.js';
-import { useTodoContinuation } from './useTodoContinuation.js';
 import { useKeypress } from './useKeypress.js';
 export function mergePartListUnions(list) {
     const resultParts = [];
@@ -42,7 +41,6 @@ export function mergePartListUnions(list) {
     }
     return resultParts;
 }
-const debugLogger = new DebugLogger('llxprt:cli:gemini-stream');
 var StreamProcessingStatus;
 (function (StreamProcessingStatus) {
     StreamProcessingStatus[StreamProcessingStatus["Completed"] = 0] = "Completed";
@@ -53,34 +51,23 @@ var StreamProcessingStatus;
  * Manages the Gemini stream, including user input, command processing,
  * API interaction, and tool call lifecycle.
  */
-export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, config, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, _onOAuthCodeNeeded) => {
+export const useGeminiStream = (geminiClient, history, addItem, config, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit) => {
     const [initError, setInitError] = useState(null);
     const abortControllerRef = useRef(null);
     const turnCancelledRef = useRef(false);
     const [isResponding, setIsResponding] = useState(false);
     const [thought, setThought] = useState(null);
-    const queuedToolResponsesRef = useRef([]);
-    const queuedSystemFeedbackRef = useRef([]);
-    const handleCompletedToolsRef = useRef(null);
     const [pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
     const processedMemoryToolsRef = useRef(new Set());
-    // FIX: Use ref to access latest history without causing re-renders
-    // This prevents infinite loops in the useEffect that saves checkpoints
-    const historyRef = useRef(history);
-    // Keep historyRef updated with latest history value
-    useEffect(() => {
-        historyRef.current = history;
-    }, [history]);
     const { startNewPrompt, getPromptCount } = useSessionStats();
-    const logger = useLogger();
-    // Todo continuation hook integration - stub implementation
-    const { handleStreamCompleted: _handleStreamCompleted } = useTodoContinuation(geminiClient, config, isResponding, onDebugMessage);
+    const storage = config.storage;
+    const logger = useLogger(storage);
     const gitService = useMemo(() => {
         if (!config.getProjectRoot()) {
             return;
         }
-        return new GitService(config.getProjectRoot());
-    }, [config]);
+        return new GitService(config.getProjectRoot(), storage);
+    }, [config, storage]);
     const [toolCalls, scheduleToolCalls, markToolsAsSubmitted] = useReactToolScheduler(async (completedToolCallsFromScheduler) => {
         // This onComplete is called when ALL scheduled tools for a given batch are done.
         if (completedToolCallsFromScheduler.length > 0) {
@@ -124,33 +111,8 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         }
         turnCancelledRef.current = true;
         abortControllerRef.current?.abort();
-        setThought(null); // Reset thought when user cancels
-        // Don't add incomplete/partial assistant messages to history
-        // These can corrupt the context and cause 400 errors
         if (pendingHistoryItemRef.current) {
-            // Only add if there's actual content worth preserving
-            const pendingItem = pendingHistoryItemRef.current;
-            if (pendingItem.type === 'gemini' ||
-                pendingItem.type === 'gemini_content') {
-                // Check if the message has meaningful content
-                if (pendingItem.text && pendingItem.text.trim().length > 0) {
-                    // Add the partial response without cancellation marker to preserve clean content
-                    addItem({
-                        ...pendingItem,
-                    }, Date.now());
-                }
-                // Otherwise, don't add empty/incomplete messages that could corrupt context
-            }
-            else if (pendingItem.type === 'tool_group') {
-                // Don't add incomplete tool groups - these can corrupt context
-                // Tool groups are only valid if they have completed tool calls
-                debugLogger.debug(() => 'Skipping incomplete tool_group on cancel');
-                // Don't add incomplete tool groups to history
-            }
-            else {
-                // For other types that are complete (info, error, etc), add as-is
-                addItem(pendingHistoryItemRef.current, Date.now());
-            }
+            addItem(pendingHistoryItemRef.current, Date.now());
         }
         addItem({
             type: MessageType.INFO,
@@ -169,9 +131,6 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
     useKeypress((key) => {
         if (key.name === 'escape') {
             cancelOngoingRequest();
-            // Clear the queues on cancel - we don't want to process tools or feedback after user cancellation
-            queuedToolResponsesRef.current = [];
-            queuedSystemFeedbackRef.current = [];
         }
     }, { isActive: streamingState === StreamingState.Responding });
     const prepareQueryForGemini = useCallback(async (query, userMessageTimestamp, abortSignal, prompt_id) => {
@@ -181,40 +140,10 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         if (typeof query === 'string' && query.trim().length === 0) {
             return { queryToSend: null, shouldProceed: false };
         }
-        // Lazily refresh auth if needed.
-        if (!geminiClient.isInitialized()) {
-            onDebugMessage('[Auth] GeminiClient not initialized, checking auth...');
-            // First check if we already have a content generator config
-            // This would be the case if refreshAuth was already called (e.g., from /key command)
-            let authType = config.getContentGeneratorConfig()?.authType;
-            onDebugMessage(`[Auth] Current authType from config: ${authType}`);
-            // If authType is not set, determine it from environment variables
-            if (!authType) {
-                if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-                    authType = AuthType.USE_VERTEX_AI;
-                }
-                else if (process.env.GEMINI_API_KEY) {
-                    authType = AuthType.USE_GEMINI;
-                }
-                else {
-                    authType = AuthType.LOGIN_WITH_GOOGLE; // Default to OAuth (interactive)
-                }
-                onDebugMessage(`[Auth] Determined authType from environment: ${authType}`);
-            }
-            // Only refresh auth if we don't have a valid content generator config
-            // or if the auth type differs from what's configured
-            const currentAuthType = config.getContentGeneratorConfig()?.authType;
-            if (!currentAuthType || currentAuthType !== authType) {
-                onDebugMessage(`[Auth] Refreshing auth with type: ${authType}`);
-                await config.refreshAuth(authType);
-            }
-            else {
-                onDebugMessage(`[Auth] Auth type unchanged, skipping refresh`);
-            }
-        }
         let localQueryToSendToGemini = null;
         if (typeof query === 'string') {
             const trimmedQuery = query.trim();
+            logUserPrompt(config, new UserPromptEvent(trimmedQuery.length, prompt_id, config.getContentGeneratorConfig()?.authType, trimmedQuery));
             onDebugMessage(`User query: '${trimmedQuery}'`);
             await logger?.logMessage(MessageSenderType.USER, trimmedQuery);
             // Handle UI-only commands first
@@ -293,18 +222,14 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         logger,
         shellModeActive,
         scheduleToolCalls,
-        geminiClient,
     ]);
     // --- Stream Event Handlers ---
     const handleContentEvent = useCallback((eventValue, currentGeminiMessageBuffer, userMessageTimestamp) => {
         if (turnCancelledRef.current) {
             // Prevents additional output after a user initiated cancel.
-            // Return the current buffer unchanged to preserve existing content
-            return currentGeminiMessageBuffer;
+            return '';
         }
         let newGeminiMessageBuffer = currentGeminiMessageBuffer + eventValue;
-        // Debug logging for repetition issue
-        debugLogger.debug(() => `Content event: eventValue=${eventValue.substring(0, 100)}, currentBuffer=${currentGeminiMessageBuffer.substring(0, 100)}, newBuffer=${newGeminiMessageBuffer.substring(0, 100)}, pendingType=${pendingHistoryItemRef.current?.type}`);
         if (pendingHistoryItemRef.current?.type !== 'gemini' &&
             pendingHistoryItemRef.current?.type !== 'gemini_content') {
             if (pendingHistoryItemRef.current) {
@@ -347,20 +272,13 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         if (turnCancelledRef.current) {
             return;
         }
-        // Track cancelled tool IDs for synthetic response generation
-        const cancelledToolIds = [];
         if (pendingHistoryItemRef.current) {
             if (pendingHistoryItemRef.current.type === 'tool_group') {
-                const updatedTools = pendingHistoryItemRef.current.tools.map((tool) => {
-                    if (tool.status === ToolCallStatus.Pending ||
-                        tool.status === ToolCallStatus.Confirming ||
-                        tool.status === ToolCallStatus.Executing) {
-                        // Track the cancelled tool ID
-                        cancelledToolIds.push(tool.callId);
-                        return { ...tool, status: ToolCallStatus.Canceled };
-                    }
-                    return tool;
-                });
+                const updatedTools = pendingHistoryItemRef.current.tools.map((tool) => tool.status === ToolCallStatus.Pending ||
+                    tool.status === ToolCallStatus.Confirming ||
+                    tool.status === ToolCallStatus.Executing
+                    ? { ...tool, status: ToolCallStatus.Canceled }
+                    : tool);
                 const pendingItem = {
                     ...pendingHistoryItemRef.current,
                     tools: updatedTools,
@@ -372,14 +290,7 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
             }
             setPendingHistoryItem(null);
         }
-        // Log cancelled tool IDs for debugging
-        if (cancelledToolIds.length > 0) {
-            debugLogger.debug(() => `[ESC] Cancelled tool IDs: ${JSON.stringify(cancelledToolIds)}`);
-        }
-        addItem({
-            type: MessageType.INFO,
-            text: `User cancelled the request${cancelledToolIds.length > 0 ? ` (${cancelledToolIds.length} tool${cancelledToolIds.length > 1 ? 's' : ''} cancelled)` : ''}.`,
-        }, userMessageTimestamp);
+        addItem({ type: MessageType.INFO, text: 'User cancelled the request.' }, userMessageTimestamp);
         setIsResponding(false);
         setThought(null); // Reset thought when user cancels
     }, [addItem, pendingHistoryItemRef, setPendingHistoryItem, setThought]);
@@ -388,30 +299,12 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
             addItem(pendingHistoryItemRef.current, userMessageTimestamp);
             setPendingHistoryItem(null);
         }
-        setThought(null); // Reset thought when there is an error
-        const errorText = parseAndFormatApiError(eventValue.error, config.getContentGeneratorConfig()?.authType, undefined, config.getModel(), DEFAULT_GEMINI_FLASH_MODEL);
-        // Check if this is an authentication error that should trigger onAuthError
-        // Match various authentication error patterns from different providers
-        // But DON'T trigger if we're in the middle of OAuth flow
-        if ((errorText.includes('Failed to resolve authentication') ||
-            errorText.includes('Authentication required')) &&
-            !global.__oauth_needs_code) {
-            // Call the onAuthError callback which will be handled by App.tsx
-            onAuthError();
-        }
         addItem({
             type: MessageType.ERROR,
-            text: errorText,
+            text: parseAndFormatApiError(eventValue.error, config.getContentGeneratorConfig()?.authType, undefined, config.getModel(), DEFAULT_GEMINI_FLASH_MODEL),
         }, userMessageTimestamp);
         setThought(null); // Reset thought when there's an error
-    }, [
-        addItem,
-        pendingHistoryItemRef,
-        setPendingHistoryItem,
-        config,
-        setThought,
-        onAuthError,
-    ]);
+    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem, config, setThought]);
     const handleFinishedEvent = useCallback((event, userMessageTimestamp) => {
         const finishReason = event.value;
         const finishReasonMessages = {
@@ -458,69 +351,15 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
     const processGeminiStreamEvents = useCallback(async (stream, userMessageTimestamp, signal) => {
         let geminiMessageBuffer = '';
         const toolCallRequests = [];
-        // Initialize emoji filter for stream processing from settings
-        const emojiFilterMode = config.getEphemeralSetting('emojifilter') || 'auto';
-        /**
-         * @requirement REQ-004.1 - Silent filtering in auto mode
-         * Use mode from settings or default to auto
-         */
-        const filterConfig = { mode: emojiFilterMode };
-        const emojiFilter = new EmojiFilter(filterConfig);
         for await (const event of stream) {
             switch (event.type) {
                 case ServerGeminiEventType.Thought:
                     setThought(event.value);
                     break;
-                case ServerGeminiEventType.Content: {
-                    // Filter the content chunk through emoji filter
-                    const filterResult = emojiFilter.filterStreamChunk(event.value);
-                    if (filterResult.blocked) {
-                        // In error mode: stop displaying and inject error feedback as tool response
-                        // Clear any partial content that was being built (don't display it)
-                        if (geminiMessageBuffer.trim()) {
-                            geminiMessageBuffer = '';
-                        }
-                        // Show a brief message to user
-                        addItem({
-                            type: 'info',
-                            text: 'Emojis detected - requesting retry without emojis...',
-                        }, userMessageTimestamp);
-                        // Queue the error feedback to be sent with the next tool response
-                        // This ensures the model gets the feedback on the next interaction
-                        if (!queuedSystemFeedbackRef.current) {
-                            queuedSystemFeedbackRef.current = [];
-                        }
-                        queuedSystemFeedbackRef.current.push(`<system-reminder>ERROR: Your response contained emojis which are strictly prohibited. Please regenerate your response without using any emojis.</system-reminder>`);
-                        // Cancel current stream to stop processing
-                        if (abortControllerRef.current) {
-                            abortControllerRef.current.abort();
-                        }
-                        // Stop processing this chunk
-                        break;
-                    }
-                    // Handle the filtered content
-                    const filteredText = typeof filterResult.filtered === 'string'
-                        ? filterResult.filtered
-                        : '';
-                    geminiMessageBuffer = handleContentEvent(filteredText, geminiMessageBuffer, userMessageTimestamp);
-                    // Queue system feedback to be sent to model in next tool response
-                    // This feedback is for the LLM, not for display to the user
-                    if (filterResult.systemFeedback) {
-                        // We'll append this to the next tool response or create a special system message
-                        // Store it in a ref so it persists across renders
-                        if (!queuedSystemFeedbackRef.current) {
-                            queuedSystemFeedbackRef.current = [];
-                        }
-                        queuedSystemFeedbackRef.current.push(`<system-reminder>${filterResult.systemFeedback}</system-reminder>`);
-                    }
-                    // If cancelled after processing this content event, stop further processing
-                    if (turnCancelledRef.current) {
-                        break;
-                    }
+                case ServerGeminiEventType.Content:
+                    geminiMessageBuffer = handleContentEvent(event.value, geminiMessageBuffer, userMessageTimestamp);
                     break;
-                }
                 case ServerGeminiEventType.ToolCallRequest:
-                    debugLogger.debug(() => `ToolCallRequest event: ${JSON.stringify(event.value, null, 2)}`);
                     toolCallRequests.push(event.value);
                     break;
                 case ServerGeminiEventType.UserCancelled:
@@ -534,7 +373,6 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                     break;
                 case ServerGeminiEventType.ToolCallConfirmation:
                 case ServerGeminiEventType.ToolCallResponse:
-                case ServerGeminiEventType.UsageMetadata:
                     // do nothing
                     break;
                 case ServerGeminiEventType.MaxSessionTurns:
@@ -548,6 +386,9 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                     // before we add loop detected message to history
                     loopDetectedRef.current = true;
                     break;
+                case ServerGeminiEventType.UsageMetadata:
+                    // Handle usage metadata - for now just ignore
+                    break;
                 default: {
                     // enforces exhaustive switch-case
                     const unreachable = event;
@@ -555,19 +396,10 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                 }
             }
         }
-        // Flush any remaining content from emoji filter buffer
-        const remainingContent = emojiFilter.flushBuffer();
-        if (remainingContent.length > 0) {
-            geminiMessageBuffer = handleContentEvent(remainingContent, geminiMessageBuffer, userMessageTimestamp);
-        }
         if (toolCallRequests.length > 0) {
-            debugLogger.debug(() => `Scheduling tool calls: ${JSON.stringify(toolCallRequests.map((tc) => ({ name: tc.name, callId: tc.callId })))}`);
             scheduleToolCalls(toolCallRequests, signal);
         }
-        return {
-            status: StreamProcessingStatus.Completed,
-            hadToolCalls: toolCallRequests.length > 0,
-        };
+        return StreamProcessingStatus.Completed;
     }, [
         handleContentEvent,
         handleUserCancelledEvent,
@@ -576,8 +408,6 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         handleChatCompressionEvent,
         handleFinishedEvent,
         handleMaxSessionTurnsEvent,
-        config,
-        addItem,
     ]);
     const submitQuery = useCallback(async (query, options, prompt_id) => {
         if ((streamingState === StreamingState.Responding ||
@@ -585,7 +415,6 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
             !options?.isContinuation)
             return;
         const userMessageTimestamp = Date.now();
-        setShowHelp(false);
         // Reset quota error flag when starting a new query (not a continuation)
         if (!options?.isContinuation) {
             setModelSwitchedFromQuotaError(false);
@@ -608,10 +437,9 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         setIsResponding(true);
         setInitError(null);
         try {
-            onDebugMessage(`[Submit] Sending message to Gemini: ${typeof queryToSend === 'string' ? queryToSend : 'non-string content'}`);
             const stream = geminiClient.sendMessageStream(queryToSend, abortSignal, prompt_id);
-            const processingResult = await processGeminiStreamEvents(stream, userMessageTimestamp, abortSignal);
-            if (processingResult.status === StreamProcessingStatus.UserCancelled) {
+            const processingStatus = await processGeminiStreamEvents(stream, userMessageTimestamp, abortSignal);
+            if (processingStatus === StreamProcessingStatus.UserCancelled) {
                 return;
             }
             if (pendingHistoryItemRef.current) {
@@ -622,10 +450,6 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                 loopDetectedRef.current = false;
                 handleLoopDetectedEvent();
             }
-            // TODO: Continuation hook integration point - stub implementation
-            // This triggers todo continuation logic when stream completes
-            // without tool calls but with active todos
-            _handleStreamCompleted(processingResult.hadToolCalls);
         }
         catch (error) {
             if (error instanceof UnauthorizedError) {
@@ -640,20 +464,9 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         }
         finally {
             setIsResponding(false);
-            // Process any queued tool responses after the response completes
-            if (queuedToolResponsesRef.current.length > 0) {
-                const queuedTools = [...queuedToolResponsesRef.current];
-                queuedToolResponsesRef.current = [];
-                debugLogger.debug(() => `Processing queued tool responses: ${JSON.stringify(queuedTools.map((tc) => tc.request.name))}`);
-                // Process the queued tools now that we're not responding
-                if (handleCompletedToolsRef.current) {
-                    await handleCompletedToolsRef.current(queuedTools);
-                }
-            }
         }
     }, [
         streamingState,
-        setShowHelp,
         setModelSwitchedFromQuotaError,
         prepareQueryForGemini,
         processGeminiStreamEvents,
@@ -667,17 +480,9 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         startNewPrompt,
         getPromptCount,
         handleLoopDetectedEvent,
-        onDebugMessage,
-        _handleStreamCompleted,
     ]);
     const handleCompletedTools = useCallback(async (completedToolCallsFromScheduler) => {
         if (isResponding) {
-            // Queue the tools to be processed after the current response completes
-            queuedToolResponsesRef.current = [
-                ...queuedToolResponsesRef.current,
-                ...completedToolCallsFromScheduler,
-            ];
-            debugLogger.debug(() => `Queuing tool responses while model is responding: ${JSON.stringify(completedToolCallsFromScheduler.map((tc) => tc.request.name))}`);
             return;
         }
         const completedAndReadyToSubmitTools = completedToolCallsFromScheduler.filter((tc) => {
@@ -709,120 +514,33 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         if (geminiTools.length === 0) {
             return;
         }
-        // Group tools by prompt_id to ensure we send all tools from the same turn together
-        const toolsByPromptId = new Map();
-        geminiTools.forEach((tool) => {
-            const promptId = tool.request.prompt_id;
-            if (!toolsByPromptId.has(promptId)) {
-                toolsByPromptId.set(promptId, []);
-            }
-            toolsByPromptId.get(promptId).push(tool);
-        });
-        // Process each prompt_id group
-        for (const [promptId, toolsInPrompt] of toolsByPromptId) {
-            // Check if we're still waiting for other tools with the same prompt_id
-            // Include both global toolCalls and the current batch to ensure we have all tools
-            const allToolCallsGlobal = toolCalls.filter((tc) => !tc.request.isClientInitiated && tc.request.prompt_id === promptId);
-            // Also check if there are other tools in the current batch that we haven't processed yet
-            const allToolsInBatch = geminiTools.filter((tc) => tc.request.prompt_id === promptId);
-            const pendingTools = allToolCallsGlobal.filter((tc) => tc.status !== 'success' &&
-                tc.status !== 'error' &&
-                tc.status !== 'cancelled');
-            if (pendingTools.length > 0) {
-                // Still waiting for other tools in this turn, skip for now
-                debugLogger.debug(() => `Waiting for ${pendingTools.length} more tools to complete for prompt ${promptId}: ${JSON.stringify(pendingTools.map((t) => t.request.name))}`);
-                continue;
-            }
-            // If all tools for this prompt_id in the current batch are complete, use them all
-            // This ensures that if multiple tools complete together, they're processed together
-            const toolsToProcess = allToolsInBatch.length > 0 ? allToolsInBatch : toolsInPrompt;
-            // All tools for this prompt_id are complete, process them
-            debugLogger.debug(() => `All tools complete for prompt ${promptId}, sending ${toolsToProcess.length} responses`);
-            // If all the tools were cancelled, don't submit a response to Gemini.
-            const allToolsCancelled = toolsToProcess.every((tc) => tc.status === 'cancelled');
-            if (allToolsCancelled) {
-                if (geminiClient) {
-                    // We need to manually add the function responses to the history
-                    // so the model knows the tools were cancelled.
-                    const responsesToAdd = toolsToProcess.flatMap((toolCall) => toolCall.response.responseParts);
-                    const combinedParts = [];
-                    for (const response of responsesToAdd) {
-                        if (Array.isArray(response)) {
-                            combinedParts.push(...response);
-                        }
-                        else if (typeof response === 'string') {
-                            combinedParts.push({ text: response });
-                        }
-                        else {
-                            combinedParts.push(response);
-                        }
-                    }
-                    geminiClient.addHistory({
-                        role: 'user',
-                        parts: combinedParts,
-                    });
-                }
-                const callIdsToMarkAsSubmitted = toolsToProcess.map((toolCall) => toolCall.request.callId);
-                markToolsAsSubmitted(callIdsToMarkAsSubmitted);
-                continue;
-            }
-            const responsesToSend = toolsToProcess
-                .map((toolCall, index) => {
-                // responseParts is now an array with [functionCall, functionResponse]
-                // We need to send BOTH to the model (they're not in history yet)
-                const parts = Array.isArray(toolCall.response.responseParts)
-                    ? toolCall.response.responseParts
-                    : [toolCall.response.responseParts];
-                debugLogger.debug(() => `Tool response for ${toolCall.request.name} (${toolCall.request.callId}): ${JSON.stringify(parts, null, 2)}`);
-                // For the last tool response, append any queued system feedback
-                // This ensures the model receives the emoji filter warnings
-                if (index === toolsToProcess.length - 1 &&
-                    queuedSystemFeedbackRef.current.length > 0) {
-                    const feedbackMessages = queuedSystemFeedbackRef.current.join('\n');
-                    queuedSystemFeedbackRef.current = []; // Clear the queue
-                    // Since we need to return a single Part (functionResponse),
-                    // we can't append text directly. Log a warning instead.
-                    console.warn('[Warning] System feedback queued but cannot be appended to function response:', feedbackMessages);
-                }
-                // Return all parts (both tool call and response)
-                // They'll be added to history together after model responds
-                return parts;
-            })
-                .flat(); // Flatten since we now have arrays of parts
-            const callIdsToMarkAsSubmitted = toolsToProcess.map((toolCall) => toolCall.request.callId);
-            // Don't mark as submitted yet - wait until after responses are actually sent
-            // Don't continue if model was switched due to quota error
-            if (modelSwitchedFromQuotaError) {
-                return;
-            }
-            // Debug logging BEFORE merging
-            debugLogger.debug(() => `responsesToSend before merge: ${JSON.stringify(responsesToSend, null, 2)}, length: ${responsesToSend.length}`);
-            responsesToSend.forEach((resp, idx) => {
-                debugLogger.debug(() => `responsesToSend[${idx}] type: ${typeof resp}, isArray: ${Array.isArray(resp)}`);
-            });
-            // For Gemini, when there are multiple function responses, they should be sent
-            // as an array of parts in a single message
-            if (responsesToSend.length === 1) {
-                // Single response - send as-is
-                debugLogger.debug(() => 'Single function response, sending directly');
-                submitQuery(responsesToSend[0], {
-                    isContinuation: true,
-                }, promptId);
-                // Mark as submitted after sending
-                markToolsAsSubmitted(callIdsToMarkAsSubmitted);
-            }
-            else {
-                // Multiple responses - send as array of parts
-                debugLogger.debug(() => `Multiple function responses (${responsesToSend.length}), sending as array: ${JSON.stringify(responsesToSend, null, 2)}`);
-                // Send all function responses as an array of parts
-                // Gemini expects multiple function responses as separate parts in the same message
-                submitQuery(responsesToSend, {
-                    isContinuation: true,
-                }, promptId);
-                // Mark all as submitted after sending
-                markToolsAsSubmitted(callIdsToMarkAsSubmitted);
+        // If all the tools were cancelled, don't submit a response to Gemini.
+        const allToolsCancelled = geminiTools.every((tc) => tc.status === 'cancelled');
+        if (allToolsCancelled) {
+            if (geminiClient) {
+                // We need to manually add the function responses to the history
+                // so the model knows the tools were cancelled.
+                const combinedParts = geminiTools.flatMap((toolCall) => toolCall.response.responseParts);
+                geminiClient.addHistory({
+                    role: 'user',
+                    parts: combinedParts,
+                });
             }
-        } // End of prompt_id loop
+            const callIdsToMarkAsSubmitted = geminiTools.map((toolCall) => toolCall.request.callId);
+            markToolsAsSubmitted(callIdsToMarkAsSubmitted);
+            return;
+        }
+        const responsesToSend = geminiTools.flatMap((toolCall) => toolCall.response.responseParts);
+        const callIdsToMarkAsSubmitted = geminiTools.map((toolCall) => toolCall.request.callId);
+        const prompt_ids = geminiTools.map((toolCall) => toolCall.request.prompt_id);
+        markToolsAsSubmitted(callIdsToMarkAsSubmitted);
+        // Don't continue if model was switched due to quota error
+        if (modelSwitchedFromQuotaError) {
+            return;
+        }
+        submitQuery(responsesToSend, {
+            isContinuation: true,
+        }, prompt_ids[0]);
     }, [
         isResponding,
         submitQuery,
@@ -830,10 +548,7 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
         geminiClient,
         performMemoryRefresh,
         modelSwitchedFromQuotaError,
-        toolCalls,
     ]);
-    // Assign the function to the ref so submitQuery can access it
-    handleCompletedToolsRef.current = handleCompletedTools;
     const pendingHistoryItems = [
         pendingHistoryItemRef.current,
         pendingToolCallGroupDisplay,
@@ -847,9 +562,7 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                 toolCall.request.name === 'write_file') &&
                 toolCall.status === 'awaiting_approval');
             if (restorableToolCalls.length > 0) {
-                const checkpointDir = config.getProjectTempDir()
-                    ? path.join(config.getProjectTempDir(), 'checkpoints')
-                    : undefined;
+                const checkpointDir = storage.getProjectTempCheckpointsDir();
                 if (!checkpointDir) {
                     return;
                 }
@@ -869,12 +582,22 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                         continue;
                     }
                     try {
-                        let commitHash = await gitService?.createFileSnapshot(`Snapshot for ${toolCall.request.name}`);
+                        if (!gitService) {
+                            onDebugMessage(`Checkpointing is enabled but Git service is not available. Failed to create snapshot for ${filePath}. Ensure Git is installed and working properly.`);
+                            continue;
+                        }
+                        let commitHash;
+                        try {
+                            commitHash = await gitService.createFileSnapshot(`Snapshot for ${toolCall.request.name}`);
+                        }
+                        catch (error) {
+                            onDebugMessage(`Failed to create new snapshot: ${getErrorMessage(error)}. Attempting to use current commit.`);
+                        }
                         if (!commitHash) {
-                            commitHash = await gitService?.getCurrentCommitHash();
+                            commitHash = await gitService.getCurrentCommitHash();
                         }
                         if (!commitHash) {
-                            onDebugMessage(`Failed to create snapshot for ${filePath}. Skipping restorable tool call.`);
+                            onDebugMessage(`Failed to create snapshot for ${filePath}. Checkpointing may not be working properly. Ensure Git is installed and the project directory is accessible.`);
                             continue;
                         }
                         const timestamp = new Date()
@@ -887,7 +610,7 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                         const clientHistory = await geminiClient?.getHistory();
                         const toolCallWithSnapshotFilePath = path.join(checkpointDir, toolCallWithSnapshotFileName);
                         await fs.writeFile(toolCallWithSnapshotFilePath, JSON.stringify({
-                            history: historyRef.current,
+                            history,
                             clientHistory,
                             toolCall: {
                                 name: toolCall.request.name,
@@ -898,15 +621,21 @@ export const useGeminiStream = (geminiClient, history, addItem, setShowHelp, con
                         }, null, 2));
                     }
                     catch (error) {
-                        onDebugMessage(`Failed to write restorable tool call file: ${getErrorMessage(error)}`);
+                        onDebugMessage(`Failed to create checkpoint for ${filePath}: ${getErrorMessage(error)}. This may indicate a problem with Git or file system permissions.`);
                     }
                 }
             }
         };
         saveRestorableToolCalls();
-        // FIX: Removed 'history' from dependencies to prevent infinite loops
-        // We use historyRef.current to access the latest history value
-    }, [toolCalls, config, onDebugMessage, gitService, geminiClient]);
+    }, [
+        toolCalls,
+        config,
+        onDebugMessage,
+        gitService,
+        history,
+        geminiClient,
+        storage,
+    ]);
     return {
         streamingState,
         submitQuery,