@umsai/ums-code 0.0.14-v1 → 0.1.4-v2

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

@@ -4,60 +4,57 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
-import { useInput } from 'ink';
-import { GeminiEventType as ServerGeminiEventType, getErrorMessage, isNodeError, MessageSenderType, logUserPrompt, GitService, UnauthorizedError, UserPromptEvent, DEFAULT_GEMINI_FLASH_MODEL, trackUserQueryEvent, trackTaskStatusEvent, trackToolCallStatusEvent, } from '@umsai/ums-code-core';
+import { GeminiEventType as ServerGeminiEventType, getErrorMessage, isNodeError, MessageSenderType, logUserPrompt, GitService, UnauthorizedError, UserPromptEvent, DEFAULT_GEMINI_FLASH_MODEL, logConversationFinishedEvent, ConversationFinishedEvent, ApprovalMode, parseAndFormatApiError, promptIdContext, ToolConfirmationOutcome, logApiCancel, ApiCancelEvent, trackUserQueryEvent, trackTaskStatusEvent, trackToolCallStatusEvent, } from '@umsai/ums-code-core';
 import { FinishReason } from '@google/genai';
-import { StreamingState, MessageType, ToolCallStatus, } from '../types.js';
-import { isAtCommand } from '../utils/commandUtils.js';
-import { parseAndFormatApiError } from '../utils/errorParsing.js';
+import { StreamingState, MessageType, ToolCallStatus } from '../types.js';
+import { isAtCommand, isSlashCommand } from '../utils/commandUtils.js';
 import { useShellCommandProcessor } from './shellCommandProcessor.js';
+import { useVisionAutoSwitch } from './useVisionAutoSwitch.js';
 import { handleAtCommand } from './atCommandProcessor.js';
 import { findLastSafeSplitPoint } from '../utils/markdownUtilities.js';
 import { useStateAndRef } from './useStateAndRef.js';
 import { useLogger } from './useLogger.js';
-import { promises as fs } from 'fs';
-import path from 'path';
 import { useReactToolScheduler, mapToDisplay as mapTrackedToolCallsToDisplay, } from './useReactToolScheduler.js';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
 import { useSessionStats } from '../contexts/SessionContext.js';
-export function mergePartListUnions(list) {
-    const resultParts = [];
-    for (const item of list) {
-        if (Array.isArray(item)) {
-            resultParts.push(...item);
-        }
-        else {
-            resultParts.push(item);
-        }
-    }
-    return resultParts;
-}
+import { useKeypress } from './useKeypress.js';
 var StreamProcessingStatus;
 (function (StreamProcessingStatus) {
     StreamProcessingStatus[StreamProcessingStatus["Completed"] = 0] = "Completed";
     StreamProcessingStatus[StreamProcessingStatus["UserCancelled"] = 1] = "UserCancelled";
     StreamProcessingStatus[StreamProcessingStatus["Error"] = 2] = "Error";
 })(StreamProcessingStatus || (StreamProcessingStatus = {}));
+const EDIT_TOOL_NAMES = new Set(['replace', 'write_file']);
+function showCitations(settings) {
+    const enabled = settings?.merged?.ui?.showCitations;
+    if (enabled !== undefined) {
+        return enabled;
+    }
+    return true;
+}
 /**
  * Manages the Gemini stream, including user input, command processing,
  * API interaction, and tool call lifecycle.
  */
-export const useGeminiStream = (geminiClient, history, addItem, config, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose) => {
+export const useGeminiStream = (geminiClient, history, addItem, config, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, visionModelPreviewEnabled, setShellInputFocused, terminalWidth, terminalHeight, onVisionSwitchRequired, isShellFocused) => {
     const [initError, setInitError] = useState(null);
     const abortControllerRef = useRef(null);
     const turnCancelledRef = useRef(false);
     const isSubmittingQueryRef = useRef(false);
     const [isResponding, setIsResponding] = useState(false);
     const [thought, setThought] = useState(null);
-    const [pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
+    const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
     const processedMemoryToolsRef = useRef(new Set());
     const { startNewPrompt, getPromptCount } = useSessionStats();
-    const logger = useLogger();
+    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) {
@@ -66,15 +63,30 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
             // Handle tool response submission immediately when tools complete
             await handleCompletedTools(completedToolCallsFromScheduler);
         }
-    }, config, setPendingHistoryItem, getPreferredEditor, onEditorClose);
+    }, config, getPreferredEditor, onEditorClose);
     const pendingToolCallGroupDisplay = useMemo(() => toolCalls.length ? mapTrackedToolCallsToDisplay(toolCalls) : undefined, [toolCalls]);
+    const activeToolPtyId = useMemo(() => {
+        const executingShellTool = toolCalls?.find((tc) => tc.status === 'executing' && tc.request.name === 'run_shell_command');
+        if (executingShellTool) {
+            return executingShellTool.pid;
+        }
+        return undefined;
+    }, [toolCalls]);
     const loopDetectedRef = useRef(false);
+    const [loopDetectionConfirmationRequest, setLoopDetectionConfirmationRequest,] = useState(null);
     const onExec = useCallback(async (done) => {
         setIsResponding(true);
         await done;
         setIsResponding(false);
     }, []);
-    const { handleShellCommand } = useShellCommandProcessor(addItem, setPendingHistoryItem, onExec, onDebugMessage, config, geminiClient);
+    const { handleShellCommand, activeShellPtyId } = useShellCommandProcessor(addItem, setPendingHistoryItem, onExec, onDebugMessage, config, geminiClient, setShellInputFocused, terminalWidth, terminalHeight);
+    const { handleVisionSwitch, restoreOriginalModel } = useVisionAutoSwitch(config, addItem, visionModelPreviewEnabled, onVisionSwitchRequired);
+    const activePtyId = activeShellPtyId || activeToolPtyId;
+    useEffect(() => {
+        if (!activePtyId) {
+            setShellInputFocused(false);
+        }
+    }, [activePtyId, setShellInputFocused]);
     // 工具调用状态
     const streamingState = useMemo(() => {
         if (toolCalls.some((tc) => tc.status === 'awaiting_approval')) {
@@ -93,24 +105,56 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         }
         return StreamingState.Idle;
     }, [isResponding, toolCalls]);
-    useInput((_input, key) => {
-        if (streamingState === StreamingState.Responding && key.escape) {
-            if (turnCancelledRef.current) {
-                return;
-            }
-            turnCancelledRef.current = true;
-            abortControllerRef.current?.abort();
-            if (pendingHistoryItemRef.current) {
-                addItem(pendingHistoryItemRef.current, Date.now());
+    useEffect(() => {
+        if (config.getApprovalMode() === ApprovalMode.YOLO &&
+            streamingState === StreamingState.Idle) {
+            const lastUserMessageIndex = history.findLastIndex((item) => item.type === MessageType.USER);
+            const turnCount = lastUserMessageIndex === -1 ? 0 : history.length - lastUserMessageIndex;
+            if (turnCount > 0) {
+                logConversationFinishedEvent(config, new ConversationFinishedEvent(config.getApprovalMode(), turnCount));
             }
-            addItem({
-                type: MessageType.INFO,
-                text: 'Request cancelled.',
-            }, Date.now());
-            setPendingHistoryItem(null);
-            setIsResponding(false);
         }
-    });
+    }, [streamingState, config, history]);
+    const cancelOngoingRequest = useCallback(() => {
+        if (streamingState !== StreamingState.Responding) {
+            return;
+        }
+        if (turnCancelledRef.current) {
+            return;
+        }
+        turnCancelledRef.current = true;
+        isSubmittingQueryRef.current = false;
+        abortControllerRef.current?.abort();
+        // Log API cancellation
+        const prompt_id = config.getSessionId() + '########' + getPromptCount();
+        const cancellationEvent = new ApiCancelEvent(config.getModel(), prompt_id, config.getContentGeneratorConfig()?.authType);
+        logApiCancel(config, cancellationEvent);
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, Date.now());
+        }
+        addItem({
+            type: MessageType.INFO,
+            text: 'Request cancelled.',
+        }, Date.now());
+        setPendingHistoryItem(null);
+        onCancelSubmit();
+        setIsResponding(false);
+        setShellInputFocused(false);
+    }, [
+        streamingState,
+        addItem,
+        setPendingHistoryItem,
+        onCancelSubmit,
+        pendingHistoryItemRef,
+        setShellInputFocused,
+        config,
+        getPromptCount,
+    ]);
+    useKeypress((key) => {
+        if (key.name === 'escape' && !isShellFocused) {
+            cancelOngoingRequest();
+        }
+    }, { isActive: streamingState === StreamingState.Responding });
     const prepareQueryForGemini = useCallback(async (query, userMessageTimestamp, abortSignal, prompt_id) => {
         if (turnCancelledRef.current) {
             return { queryToSend: null, shouldProceed: false };
@@ -121,11 +165,12 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         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
-            const slashCommandResult = await handleSlashCommand(trimmedQuery);
+            const slashCommandResult = isSlashCommand(trimmedQuery)
+                ? await handleSlashCommand(trimmedQuery)
+                : false;
             if (slashCommandResult) {
                 switch (slashCommandResult.type) {
                     case 'schedule_tool': {
@@ -170,6 +215,8 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
                     messageId: userMessageTimestamp,
                     signal: abortSignal,
                 });
+                // Add user's turn after @ command processing is done.
+                addItem({ type: MessageType.USER, text: trimmedQuery }, userMessageTimestamp);
                 if (!atCommandResult.shouldProceed) {
                     return { queryToSend: null, shouldProceed: false };
                 }
@@ -282,8 +329,21 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         }, userMessageTimestamp);
         setThought(null); // Reset thought when there's an error
     }, [addItem, pendingHistoryItemRef, setPendingHistoryItem, config, setThought]);
+    const handleCitationEvent = useCallback((text, userMessageTimestamp) => {
+        if (!showCitations(settings)) {
+            return;
+        }
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            setPendingHistoryItem(null);
+        }
+        addItem({ type: MessageType.INFO, text }, userMessageTimestamp);
+    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem, settings]);
     const handleFinishedEvent = useCallback((event, userMessageTimestamp) => {
-        const finishReason = event.value;
+        const finishReason = event.value.reason;
+        if (!finishReason) {
+            return;
+        }
         const finishReasonMessages = {
             [FinishReason.FINISH_REASON_UNSPECIFIED]: undefined,
             [FinishReason.STOP]: undefined,
@@ -307,13 +367,19 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
             }, userMessageTimestamp);
         }
     }, [addItem]);
-    const handleChatCompressionEvent = useCallback((eventValue) => addItem({
-        type: 'info',
-        text: `IMPORTANT: This conversation approached the input token limit for ${config.getModel()}. ` +
-            `A compressed context will be sent for future messages (compressed from: ` +
-            `${eventValue?.originalTokenCount ?? 'unknown'} to ` +
-            `${eventValue?.newTokenCount ?? 'unknown'} tokens).`,
-    }, Date.now()), [addItem, config]);
+    const handleChatCompressionEvent = useCallback((eventValue, userMessageTimestamp) => {
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            setPendingHistoryItem(null);
+        }
+        return addItem({
+            type: 'info',
+            text: `IMPORTANT: This conversation approached the input token limit for ${config.getModel()}. ` +
+                `A compressed context will be sent for future messages (compressed from: ` +
+                `${eventValue?.originalTokenCount ?? 'unknown'} to ` +
+                `${eventValue?.newTokenCount ?? 'unknown'} tokens).`,
+        }, Date.now());
+    }, [addItem, config, pendingHistoryItemRef, setPendingHistoryItem]);
     const handleMaxSessionTurnsEvent = useCallback(() => addItem({
         type: 'info',
         text: `The session has reached the maximum number of turns: ${config.getMaxSessionTurns()}. ` +
@@ -327,12 +393,28 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
             `   • Increase limit: Add "sessionTokenLimit": (e.g., 128000) to your settings.json\n` +
             `   • Compress history: Use /compress command to compress history`,
     }, Date.now()), [addItem]);
+    const handleLoopDetectionConfirmation = useCallback((result) => {
+        setLoopDetectionConfirmationRequest(null);
+        if (result.userSelection === 'disable') {
+            config.getGeminiClient().getLoopDetectionService().disableForSession();
+            addItem({
+                type: 'info',
+                text: `Loop detection has been disabled for this session. Please try your request again.`,
+            }, Date.now());
+        }
+        else {
+            addItem({
+                type: 'info',
+                text: `A potential loop was detected. This can happen due to repetitive tool calls or other model behavior. The request has been halted.`,
+            }, Date.now());
+        }
+    }, [config, addItem]);
     const handleLoopDetectedEvent = useCallback(() => {
-        addItem({
-            type: 'info',
-            text: `A potential loop was detected. This can happen due to repetitive tool calls or other model behavior. The request has been halted.`,
-        }, Date.now());
-    }, [addItem]);
+        // Show the confirmation dialog to choose whether to disable loop detection
+        setLoopDetectionConfirmationRequest({
+            onComplete: handleLoopDetectionConfirmation,
+        });
+    }, [handleLoopDetectionConfirmation]);
     const processGeminiStreamEvents = useCallback(async (stream, userMessageTimestamp, signal, model, sessionId) => {
         let geminiMessageBuffer = '';
         const toolCallRequests = [];
@@ -363,7 +445,7 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
                 case ServerGeminiEventType.ChatCompressed:
                     // 上下文压缩事件
                     trackTaskStatusEvent(model, sessionId, event.type);
-                    handleChatCompressionEvent(event.value);
+                    handleChatCompressionEvent(event.value, userMessageTimestamp);
                     break;
                 case ServerGeminiEventType.ToolCallConfirmation:
                 case ServerGeminiEventType.ToolCallResponse:
@@ -383,11 +465,14 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
                     break;
                 case ServerGeminiEventType.Finished:
                     // 结束事件
-                    if (event.value === FinishReason.STOP || event.value === FinishReason.MAX_TOKENS) {
+                    if (event.value.reason === FinishReason.STOP || event.value.reason === FinishReason.MAX_TOKENS) {
                         trackTaskStatusEvent(model, sessionId, event.type);
                     }
                     handleFinishedEvent(event, userMessageTimestamp);
                     break;
+                case ServerGeminiEventType.Citation:
+                    handleCitationEvent(event.value, userMessageTimestamp);
+                    break;
                 case ServerGeminiEventType.LoopDetected:
                     // handle later because we want to move pending history to history
                     // before we add loop detected message to history
@@ -395,6 +480,11 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
                     trackTaskStatusEvent(model, sessionId, event.type);
                     loopDetectedRef.current = true;
                     break;
+                case ServerGeminiEventType.Retry:
+                    // Will add the missing logic later
+                    // 重试事件
+                    trackTaskStatusEvent(model, sessionId, event.type);
+                    break;
                 default: {
                     // enforces exhaustive switch-case
                     const unreachable = event;
@@ -416,10 +506,12 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         handleFinishedEvent,
         handleMaxSessionTurnsEvent,
         handleSessionTokenLimitExceededEvent,
+        handleCitationEvent,
     ]);
     const submitQuery = useCallback(async (query, options, prompt_id) => {
-        // Prevent concurrent executions of submitQuery
-        if (isSubmittingQueryRef.current) {
+        // Prevent concurrent executions of submitQuery, but allow continuations
+        // which are part of the same logical flow (tool responses)
+        if (isSubmittingQueryRef.current && !options?.isContinuation) {
             return;
         }
         if ((streamingState === StreamingState.Responding ||
@@ -440,51 +532,78 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         if (!prompt_id) {
             prompt_id = config.getSessionId() + '########' + getPromptCount();
         }
-        const { queryToSend, shouldProceed } = await prepareQueryForGemini(query, userMessageTimestamp, abortSignal, prompt_id);
-        if (!shouldProceed || queryToSend === null) {
-            isSubmittingQueryRef.current = false;
-            return;
-        }
-        if (!options?.isContinuation) {
-            startNewPrompt();
-            setThought(null); // Reset thought when starting a new prompt
-        }
-        setIsResponding(true);
-        setInitError(null);
-        // 发送用户输入事件埋点
-        trackUserQueryEvent(config.getSessionId());
-        try {
-            const stream = geminiClient.sendMessageStream(queryToSend, abortSignal, prompt_id);
-            const processingStatus = await processGeminiStreamEvents(stream, userMessageTimestamp, abortSignal, config.getModel(), config.getSessionId());
-            // TODO 用户取消事件
-            if (processingStatus === StreamProcessingStatus.UserCancelled) {
+        return promptIdContext.run(prompt_id, async () => {
+            const { queryToSend, shouldProceed } = await prepareQueryForGemini(query, userMessageTimestamp, abortSignal, prompt_id);
+            if (!shouldProceed || queryToSend === null) {
                 isSubmittingQueryRef.current = false;
                 return;
             }
-            if (pendingHistoryItemRef.current) {
-                addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-                setPendingHistoryItem(null);
+            // Handle vision switch requirement
+            // 是否切换视觉模型处理
+            const visionSwitchResult = await handleVisionSwitch(queryToSend, userMessageTimestamp, options?.isContinuation || false);
+            if (!visionSwitchResult.shouldProceed) {
+                isSubmittingQueryRef.current = false;
+                return;
             }
-            if (loopDetectedRef.current) {
-                loopDetectedRef.current = false;
-                handleLoopDetectedEvent();
+            const finalQueryToSend = queryToSend;
+            if (!options?.isContinuation) {
+                if (typeof queryToSend === 'string') {
+                    // logging the text prompts only for now
+                    const promptText = queryToSend;
+                    logUserPrompt(config, new UserPromptEvent(promptText.length, prompt_id, config.getContentGeneratorConfig()?.authType, promptText));
+                }
+                startNewPrompt();
+                setThought(null); // Reset thought when starting a new prompt
             }
-        }
-        catch (error) {
-            if (error instanceof UnauthorizedError) {
-                onAuthError();
+            setIsResponding(true);
+            setInitError(null);
+            // 发送用户输入事件埋点
+            trackUserQueryEvent(config.getSessionId());
+            try {
+                const stream = geminiClient.sendMessageStream(finalQueryToSend, abortSignal, prompt_id);
+                const processingStatus = await processGeminiStreamEvents(stream, userMessageTimestamp, abortSignal, config.getModel(), config.getSessionId());
+                // 用户取消事件
+                if (processingStatus === StreamProcessingStatus.UserCancelled) {
+                    // Restore original model if it was temporarily overridden
+                    restoreOriginalModel().catch((error) => {
+                        console.error('Failed to restore original model:', error);
+                    });
+                    isSubmittingQueryRef.current = false;
+                    return;
+                }
+                if (pendingHistoryItemRef.current) {
+                    addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+                    setPendingHistoryItem(null);
+                }
+                if (loopDetectedRef.current) {
+                    loopDetectedRef.current = false;
+                    handleLoopDetectedEvent();
+                }
+                // Restore original model if it was temporarily overridden
+                restoreOriginalModel().catch((error) => {
+                    console.error('Failed to restore original model:', error);
+                });
             }
-            else if (!isNodeError(error) || error.name !== 'AbortError') {
-                addItem({
-                    type: MessageType.ERROR,
-                    text: parseAndFormatApiError(getErrorMessage(error) || 'Unknown error', config.getContentGeneratorConfig()?.authType, undefined, config.getModel(), DEFAULT_GEMINI_FLASH_MODEL),
-                }, userMessageTimestamp);
+            catch (error) {
+                // Restore original model if it was temporarily overridden
+                restoreOriginalModel().catch((error) => {
+                    console.error('Failed to restore original model:', error);
+                });
+                if (error instanceof UnauthorizedError) {
+                    onAuthError('Session expired or is unauthorized.');
+                }
+                else if (!isNodeError(error) || error.name !== 'AbortError') {
+                    addItem({
+                        type: MessageType.ERROR,
+                        text: parseAndFormatApiError(getErrorMessage(error) || 'Unknown error', config.getContentGeneratorConfig()?.authType, undefined, config.getModel(), DEFAULT_GEMINI_FLASH_MODEL),
+                    }, userMessageTimestamp);
+                }
             }
-        }
-        finally {
-            setIsResponding(false);
-            isSubmittingQueryRef.current = false;
-        }
+            finally {
+                setIsResponding(false);
+                isSubmittingQueryRef.current = false;
+            }
+        });
     }, [
         streamingState,
         setModelSwitchedFromQuotaError,
@@ -500,7 +619,31 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         startNewPrompt,
         getPromptCount,
         handleLoopDetectedEvent,
+        handleVisionSwitch,
+        restoreOriginalModel,
     ]);
+    const handleApprovalModeChange = useCallback(async (newApprovalMode) => {
+        // Auto-approve pending tool calls when switching to auto-approval modes
+        if (newApprovalMode === ApprovalMode.YOLO ||
+            newApprovalMode === ApprovalMode.AUTO_EDIT) {
+            let awaitingApprovalCalls = toolCalls.filter((call) => call.status === 'awaiting_approval');
+            // For AUTO_EDIT mode, only approve edit tools (replace, write_file)
+            if (newApprovalMode === ApprovalMode.AUTO_EDIT) {
+                awaitingApprovalCalls = awaitingApprovalCalls.filter((call) => EDIT_TOOL_NAMES.has(call.request.name));
+            }
+            // Process pending tool calls sequentially to reduce UI chaos
+            for (const call of awaitingApprovalCalls) {
+                if (call.confirmationDetails?.onConfirm) {
+                    try {
+                        await call.confirmationDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+                    }
+                    catch (error) {
+                        console.error(`Failed to auto-approve tool call ${call.request.callId}:`, error);
+                    }
+                }
+            }
+        }
+    }, [toolCalls]);
     const handleCompletedTools = useCallback(async (completedToolCallsFromScheduler) => {
         if (isResponding) {
             return;
@@ -552,19 +695,7 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
             if (geminiClient) {
                 // We need to manually add the function responses to the history
                 // so the model knows the tools were cancelled.
-                const responsesToAdd = geminiTools.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);
-                    }
-                }
+                const combinedParts = geminiTools.flatMap((toolCall) => toolCall.response.responseParts);
                 geminiClient.addHistory({
                     role: 'user',
                     parts: combinedParts,
@@ -574,7 +705,7 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
             markToolsAsSubmitted(callIdsToMarkAsSubmitted);
             return;
         }
-        const responsesToSend = geminiTools.map((toolCall) => toolCall.response.responseParts);
+        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);
@@ -582,7 +713,7 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         if (modelSwitchedFromQuotaError) {
             return;
         }
-        submitQuery(mergePartListUnions(responsesToSend), {
+        submitQuery(responsesToSend, {
             isContinuation: true,
         }, prompt_ids[0]);
     }, [
@@ -593,22 +724,16 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
         performMemoryRefresh,
         modelSwitchedFromQuotaError,
     ]);
-    const pendingHistoryItems = [
-        pendingHistoryItemRef.current,
-        pendingToolCallGroupDisplay,
-    ].filter((i) => i !== undefined && i !== null);
+    const pendingHistoryItems = useMemo(() => [pendingHistoryItem, pendingToolCallGroupDisplay].filter((i) => i !== undefined && i !== null), [pendingHistoryItem, pendingToolCallGroupDisplay]);
     useEffect(() => {
         const saveRestorableToolCalls = async () => {
             if (!config.getCheckpointingEnabled()) {
                 return;
             }
-            const restorableToolCalls = toolCalls.filter((toolCall) => (toolCall.request.name === 'replace' ||
-                toolCall.request.name === 'write_file') &&
+            const restorableToolCalls = toolCalls.filter((toolCall) => EDIT_TOOL_NAMES.has(toolCall.request.name) &&
                 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;
                 }
@@ -628,12 +753,22 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
                         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()
@@ -657,19 +792,32 @@ export const useGeminiStream = (geminiClient, history, addItem, config, onDebugM
                         }, 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();
-    }, [toolCalls, config, onDebugMessage, gitService, history, geminiClient]);
+    }, [
+        toolCalls,
+        config,
+        onDebugMessage,
+        gitService,
+        history,
+        geminiClient,
+        storage,
+    ]);
     return {
         streamingState,
         submitQuery,
         initError,
         pendingHistoryItems,
         thought,
+        cancelOngoingRequest,
+        pendingToolCalls: toolCalls,
+        handleApprovalModeChange,
+        activePtyId,
+        loopDetectionConfirmationRequest,
     };
 };
 //# sourceMappingURL=useGeminiStream.js.map