@quantum-ai/gemini-cli 0.45.3

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

@@ -0,0 +1,1423 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { GeminiEventType as ServerGeminiEventType, getErrorMessage, isNodeError, MessageSenderType, logUserPrompt, GitService, UnauthorizedError, UserPromptEvent, DEFAULT_GEMINI_FLASH_MODEL, logConversationFinishedEvent, ConversationFinishedEvent, ApprovalMode, parseAndFormatApiError, ToolConfirmationOutcome, MessageBusType, promptIdContext, tokenLimit, debugLogger, runInDevTraceSpan, EDIT_TOOL_NAMES, SHELL_TOOL_NAME, hasRedirection, processRestorableToolCalls, recordToolCallInteractions, ToolErrorType, ValidationRequiredError, coreEvents, CoreEvent, CoreToolCallStatus, buildUserSteeringHintPrompt, GeminiCliOperation, getPlanModeExitMessage, isBackgroundExecutionData, Kind, ACTIVATE_SKILL_TOOL_NAME, isRenderedInHistory, buildToolVisibilityContext, UPDATE_TOPIC_TOOL_NAME, UPDATE_TOPIC_DISPLAY_NAME, } from '@quantum-ai/gemini-cli-core';
+import { FinishReason } from '@google/genai';
+import { StreamingState, MessageType, mapCoreStatusToDisplayStatus, ToolCallStatus, } from '../types.js';
+import { isAtCommand, isSlashCommand } from '../utils/commandUtils.js';
+import { useExecutionLifecycle } from './useExecutionLifecycle.js';
+import { handleAtCommand } from './atCommandProcessor.js';
+import { findLastSafeSplitPoint } from '../utils/markdownUtilities.js';
+import { getInlineThinkingMode } from '../utils/inlineThinkingMode.js';
+import { useStateAndRef } from './useStateAndRef.js';
+import { useLogger } from './useLogger.js';
+import { SHELL_COMMAND_NAME } from '../constants.js';
+import { mapToDisplay as mapTrackedToolCallsToDisplay } from './toolMapping.js';
+import { isCompactTool } from '../components/messages/ToolGroupMessage.js';
+import { useToolScheduler, } from './useToolScheduler.js';
+import { theme } from '../semantic-colors.js';
+import { getToolGroupBorderAppearance } from '../utils/borderStyles.js';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { useSessionStats } from '../contexts/SessionContext.js';
+import { useKeypress } from './useKeypress.js';
+const isTopicTool = (name) => name === UPDATE_TOPIC_TOOL_NAME || name === UPDATE_TOPIC_DISPLAY_NAME;
+var StreamProcessingStatus;
+(function (StreamProcessingStatus) {
+    StreamProcessingStatus[StreamProcessingStatus["Completed"] = 0] = "Completed";
+    StreamProcessingStatus[StreamProcessingStatus["UserCancelled"] = 1] = "UserCancelled";
+    StreamProcessingStatus[StreamProcessingStatus["Error"] = 2] = "Error";
+})(StreamProcessingStatus || (StreamProcessingStatus = {}));
+const SUPPRESSED_TOOL_ERRORS_NOTE = 'Some internal tool attempts failed before this final error. Press F12 for diagnostics, or run /settings and change "Error Verbosity" to full for details.';
+const LOW_VERBOSITY_FAILURE_NOTE = 'This request failed. Press F12 for diagnostics, or run /settings and change "Error Verbosity" to full for full details.';
+function getBackgroundedToolInfo(toolCall) {
+    const response = toolCall.response;
+    const rawData = response?.data;
+    if (!isBackgroundExecutionData(rawData)) {
+        return undefined;
+    }
+    if (rawData.pid === undefined) {
+        return undefined;
+    }
+    return {
+        pid: rawData.pid,
+        command: rawData.command ?? toolCall.request.name,
+        initialOutput: rawData.initialOutput ?? '',
+    };
+}
+function isBackgroundableExecutingToolCall(toolCall) {
+    return (toolCall.status === CoreToolCallStatus.Executing &&
+        typeof toolCall.pid === 'number');
+}
+function showCitations(settings) {
+    const enabled = settings.merged.ui.showCitations;
+    if (enabled !== undefined) {
+        return enabled;
+    }
+    return true;
+}
+/**
+ * Calculates the current streaming state based on tool call status and responding flag.
+ */
+function calculateStreamingState(isResponding, toolCalls) {
+    if (toolCalls.some((tc) => tc.status === CoreToolCallStatus.AwaitingApproval)) {
+        return StreamingState.WaitingForConfirmation;
+    }
+    const isAnyToolActive = toolCalls.some((tc) => {
+        // These statuses indicate active processing
+        if (tc.status === CoreToolCallStatus.Executing ||
+            tc.status === CoreToolCallStatus.Scheduled ||
+            tc.status === CoreToolCallStatus.Validating) {
+            return true;
+        }
+        // Terminal statuses (success, error, cancelled) still count as "Responding"
+        // if the result hasn't been submitted back to Gemini yet.
+        if (tc.status === CoreToolCallStatus.Success ||
+            tc.status === CoreToolCallStatus.Error ||
+            tc.status === CoreToolCallStatus.Cancelled) {
+            return !tc
+                .responseSubmittedToGemini;
+        }
+        return false;
+    });
+    if (isResponding || isAnyToolActive) {
+        return StreamingState.Responding;
+    }
+    return StreamingState.Idle;
+}
+/**
+ * Manages the Gemini stream, including user input, command processing,
+ * API interaction, and tool call lifecycle.
+ */
+export const useGeminiStream = (geminiClient, history, addItem, config, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, _performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, isShellFocused, consumeUserHint) => {
+    const [initError, setInitError] = useState(null);
+    const [retryStatus, setRetryStatus] = useState(null);
+    const isLowErrorVerbosity = settings.merged.ui?.errorVerbosity !== 'full';
+    const suppressedToolErrorCountRef = useRef(0);
+    const suppressedToolErrorNoteShownRef = useRef(false);
+    const lowVerbosityFailureNoteShownRef = useRef(false);
+    const abortControllerRef = useRef(null);
+    const turnCancelledRef = useRef(false);
+    const activeQueryIdRef = useRef(null);
+    const previousApprovalModeRef = useRef(config.getApprovalMode());
+    const [isResponding, isRespondingRef, setIsResponding] = useStateAndRef(false);
+    const [thought, thoughtRef, setThought] = useStateAndRef(null);
+    const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
+    const [lastGeminiActivityTime, setLastGeminiActivityTime] = useState(0);
+    const [pushedToolCallIds, pushedToolCallIdsRef, setPushedToolCallIds] = useStateAndRef(new Set());
+    const [_isFirstToolInGroup, isFirstToolInGroupRef, setIsFirstToolInGroup] = useStateAndRef(true);
+    const { startNewPrompt, getPromptCount } = useSessionStats();
+    const logger = useLogger(config);
+    const gitService = useMemo(() => {
+        if (!config.getProjectRoot()) {
+            return;
+        }
+        return new GitService(config.getProjectRoot(), config.storage);
+    }, [config]);
+    useEffect(() => {
+        const handleRetryAttempt = (payload) => {
+            if (turnCancelledRef.current || !isRespondingRef.current) {
+                return;
+            }
+            setRetryStatus(payload);
+        };
+        coreEvents.on(CoreEvent.RetryAttempt, handleRetryAttempt);
+        return () => {
+            coreEvents.off(CoreEvent.RetryAttempt, handleRetryAttempt);
+        };
+    }, [isRespondingRef]);
+    const [toolCalls, scheduleToolCalls, markToolsAsSubmitted, setToolCallsForDisplay, cancelAllToolCalls, lastToolOutputTime,] = useToolScheduler(async (completedToolCallsFromScheduler) => {
+        // This onComplete is called when ALL scheduled tools for a given batch are done.
+        if (completedToolCallsFromScheduler.length > 0) {
+            // Add only the tools that haven't been pushed to history yet.
+            const toolsToPush = completedToolCallsFromScheduler.filter((tc) => !pushedToolCallIdsRef.current.has(tc.request.callId));
+            if (toolsToPush.length > 0) {
+                const isCompactModeEnabled = settings.merged.ui?.compactToolOutput === true;
+                const firstToolToPush = toolsToPush[0];
+                const tcIndex = toolCalls.indexOf(firstToolToPush);
+                const prevTool = tcIndex > 0 ? toolCalls[tcIndex - 1] : null;
+                let borderTop = isFirstToolInGroupRef.current;
+                if (!borderTop && prevTool) {
+                    // If the first tool in this push is non-compact but follows a compact tool,
+                    // we must start a new border group.
+                    const currentIsCompact = isCompactTool(mapTrackedToolCallsToDisplay(firstToolToPush).tools[0], isCompactModeEnabled);
+                    const prevWasCompact = isCompactTool(mapTrackedToolCallsToDisplay(prevTool).tools[0], isCompactModeEnabled);
+                    if (!currentIsCompact && prevWasCompact) {
+                        borderTop = true;
+                    }
+                }
+                addItem(mapTrackedToolCallsToDisplay(toolsToPush, {
+                    borderTop,
+                    borderBottom: true,
+                    borderColor: theme.border.default,
+                    borderDimColor: false,
+                }));
+            }
+            // Clear the live-updating display now that the final state is in history.
+            setToolCallsForDisplay([]);
+            // Record tool calls with full metadata before sending responses.
+            try {
+                const currentModel = config.getGeminiClient().getCurrentSequenceModel() ??
+                    config.getModel();
+                config
+                    .getGeminiClient()
+                    .getChat()
+                    .recordCompletedToolCalls(currentModel, completedToolCallsFromScheduler);
+                await recordToolCallInteractions(config, completedToolCallsFromScheduler);
+            }
+            catch (error) {
+                debugLogger.warn(`Error recording completed tool call information: ${error}`);
+            }
+            // Handle tool response submission immediately when tools complete
+            await handleCompletedTools(completedToolCallsFromScheduler);
+        }
+    }, config, getPreferredEditor);
+    const activeBackgroundExecutionId = useMemo(() => {
+        const executingBackgroundableTool = toolCalls.find(isBackgroundableExecutingToolCall);
+        return executingBackgroundableTool?.pid;
+    }, [toolCalls]);
+    const onExec = useCallback(async (done) => {
+        setIsResponding(true);
+        await done;
+        setIsResponding(false);
+    }, [setIsResponding]);
+    const { handleShellCommand, activeShellPtyId, lastShellOutputTime, backgroundTaskCount, isBackgroundTaskVisible, toggleBackgroundTasks, backgroundCurrentExecution, registerBackgroundTask, dismissBackgroundTask, backgroundTasks, } = useExecutionLifecycle(addItem, setPendingHistoryItem, onExec, onDebugMessage, config, geminiClient, setShellInputFocused, terminalWidth, terminalHeight, activeBackgroundExecutionId);
+    const streamingState = useMemo(() => calculateStreamingState(isResponding, toolCalls), [isResponding, toolCalls]);
+    // Reset tracking when a new batch of tools starts
+    useEffect(() => {
+        if (toolCalls.length > 0) {
+            const isNewBatch = !toolCalls.some((tc) => pushedToolCallIdsRef.current.has(tc.request.callId));
+            if (isNewBatch) {
+                setPushedToolCallIds(new Set());
+                setIsFirstToolInGroup(true);
+            }
+        }
+        else if (streamingState === StreamingState.Idle) {
+            // Clear when idle to be ready for next turn
+            setPushedToolCallIds(new Set());
+            setIsFirstToolInGroup(true);
+        }
+    }, [
+        toolCalls,
+        pushedToolCallIdsRef,
+        setPushedToolCallIds,
+        setIsFirstToolInGroup,
+        streamingState,
+    ]);
+    // Push completed tools to history as they finish
+    useEffect(() => {
+        const toolsToPush = [];
+        for (let i = 0; i < toolCalls.length; i++) {
+            const tc = toolCalls[i];
+            if (pushedToolCallIdsRef.current.has(tc.request.callId))
+                continue;
+            if (tc.status === 'success' ||
+                tc.status === 'error' ||
+                tc.status === 'cancelled') {
+                // TODO(#22883): This lookahead logic is a tactical UI fix to prevent parallel agents
+                // from tearing visually when they finish at slightly different times.
+                // Architecturally, `useGeminiStream` should not be responsible for stitching
+                // together semantic batches using timing/refs. `packages/core` should be
+                // refactored to emit structured `ToolBatch` or `Turn` objects, and this layer
+                // should simply render those semantic boundaries.
+                // If this is an agent tool, look ahead to ensure all subsequent
+                // contiguous agents in the same batch are also finished before pushing.
+                const isAgent = tc.tool?.kind === Kind.Agent;
+                if (isAgent) {
+                    let contigAgentsComplete = true;
+                    for (let j = i + 1; j < toolCalls.length; j++) {
+                        const nextTc = toolCalls[j];
+                        if (nextTc.tool?.kind === Kind.Agent) {
+                            if (nextTc.status !== 'success' &&
+                                nextTc.status !== 'error' &&
+                                nextTc.status !== 'cancelled') {
+                                contigAgentsComplete = false;
+                                break;
+                            }
+                        }
+                        else {
+                            // End of the contiguous agent block
+                            break;
+                        }
+                    }
+                    if (!contigAgentsComplete) {
+                        // Wait for the entire contiguous block of agents to finish
+                        break;
+                    }
+                }
+                toolsToPush.push(tc);
+            }
+            else {
+                // Stop at first non-terminal tool to preserve order
+                break;
+            }
+        }
+        if (toolsToPush.length > 0) {
+            const newPushed = new Set(pushedToolCallIdsRef.current);
+            const isFirstInThisPush = isFirstToolInGroupRef.current;
+            const isCompactModeEnabled = settings.merged.ui?.compactToolOutput === true;
+            const groups = [];
+            let currentGroup = [];
+            for (const tc of toolsToPush) {
+                newPushed.add(tc.request.callId);
+                if (tc.tool?.kind === Kind.Agent) {
+                    currentGroup.push(tc);
+                }
+                else {
+                    if (currentGroup.length > 0) {
+                        groups.push(currentGroup);
+                        currentGroup = [];
+                    }
+                    groups.push([tc]);
+                }
+            }
+            if (currentGroup.length > 0) {
+                groups.push(currentGroup);
+            }
+            for (let i = 0; i < groups.length; i++) {
+                const group = groups[i];
+                const isFirstInBatch = i === 0 && isFirstInThisPush;
+                const lastTcInGroup = group[group.length - 1];
+                const tcIndexInBatch = toolCalls.indexOf(lastTcInGroup);
+                const isLastInBatch = tcIndexInBatch === toolCalls.length - 1;
+                const nextTcInBatch = tcIndexInBatch < toolCalls.length - 1
+                    ? toolCalls[tcIndexInBatch + 1]
+                    : null;
+                const prevTcInBatch = toolCalls.indexOf(group[0]) > 0
+                    ? toolCalls[toolCalls.indexOf(group[0]) - 1]
+                    : null;
+                const historyItem = mapTrackedToolCallsToDisplay(group, {
+                    ...getToolGroupBorderAppearance({ type: 'tool_group', tools: toolCalls }, activeShellPtyId, !!isShellFocused, [], backgroundTasks),
+                });
+                // Determine if this group starts with a compact tool
+                const currentIsCompact = historyItem.tools.length === 1 &&
+                    isCompactTool(historyItem.tools[0], isCompactModeEnabled);
+                let nextIsCompact = false;
+                if (nextTcInBatch) {
+                    const nextHistoryItem = mapTrackedToolCallsToDisplay(nextTcInBatch);
+                    nextIsCompact =
+                        nextHistoryItem.tools.length === 1 &&
+                            isCompactTool(nextHistoryItem.tools[0], isCompactModeEnabled);
+                }
+                let prevWasCompact = false;
+                if (prevTcInBatch) {
+                    const prevHistoryItem = mapTrackedToolCallsToDisplay(prevTcInBatch);
+                    prevWasCompact =
+                        prevHistoryItem.tools.length === 1 &&
+                            isCompactTool(prevHistoryItem.tools[0], isCompactModeEnabled);
+                }
+                historyItem.borderTop =
+                    isFirstInBatch || (!currentIsCompact && prevWasCompact);
+                historyItem.borderBottom = currentIsCompact
+                    ? isLastInBatch && !nextIsCompact
+                    : isLastInBatch || nextIsCompact;
+                addItem(historyItem);
+            }
+            setPushedToolCallIds(newPushed);
+            // If this batch ONLY contains topics, and we were the first in the group,
+            // the NEXT batch is still effectively the first VISIBLE bordered tool in the group.
+            if (isFirstToolInGroupRef.current &&
+                toolsToPush.every((tc) => isTopicTool(tc.request.name))) {
+                // Keep it true!
+            }
+            else {
+                setIsFirstToolInGroup(false);
+            }
+        }
+    }, [
+        toolCalls,
+        pushedToolCallIdsRef,
+        isFirstToolInGroupRef,
+        setPushedToolCallIds,
+        setIsFirstToolInGroup,
+        addItem,
+        activeShellPtyId,
+        isShellFocused,
+        backgroundTasks,
+        settings.merged.ui?.compactToolOutput,
+    ]);
+    const pendingToolGroupItems = useMemo(() => {
+        const remainingTools = toolCalls.filter((tc) => !pushedToolCallIds.has(tc.request.callId));
+        const items = [];
+        const appearance = getToolGroupBorderAppearance({ type: 'tool_group', tools: toolCalls }, activeShellPtyId, !!isShellFocused, [], backgroundTasks);
+        if (remainingTools.length > 0) {
+            // Should we draw a top border? Yes if NO previous tools were drawn,
+            // OR if ALL previously drawn tools were topics (which don't draw top borders).
+            let needsTopBorder = pushedToolCallIds.size === 0;
+            if (!needsTopBorder) {
+                const allPushedWereTopics = toolCalls
+                    .filter((tc) => pushedToolCallIds.has(tc.request.callId))
+                    .every((tc) => isTopicTool(tc.request.name));
+                if (allPushedWereTopics) {
+                    needsTopBorder = true;
+                }
+            }
+            items.push(mapTrackedToolCallsToDisplay(remainingTools, {
+                borderTop: needsTopBorder,
+                borderBottom: false, // Stay open to connect with the slice below
+                ...appearance,
+            }));
+        }
+        // Always show a bottom border slice if we have ANY tools in the batch
+        // and we haven't finished pushing the whole batch to history yet.
+        // Once all tools are terminal and pushed, the last history item handles the closing border.
+        const allTerminal = toolCalls.length > 0 &&
+            toolCalls.every((tc) => tc.status === 'success' ||
+                tc.status === 'error' ||
+                tc.status === 'cancelled');
+        const allPushed = toolCalls.length > 0 &&
+            toolCalls.every((tc) => pushedToolCallIds.has(tc.request.callId));
+        const isToolVisible = (tc) => {
+            // AskUser tools and Plan Mode write/edit are handled by this logic
+            if (!isRenderedInHistory(buildToolVisibilityContext(tc))) {
+                return false;
+            }
+            // ToolGroupMessage explicitly hides Confirming tools because they are
+            // rendered in the interactive ToolConfirmationQueue instead.
+            const displayStatus = mapCoreStatusToDisplayStatus(tc.status);
+            if (displayStatus === ToolCallStatus.Confirming) {
+                return false;
+            }
+            // ToolGroupMessage now shows all non-canceled tools, so they are visible
+            // in pending and we need to draw the closing border for them.
+            return true;
+        };
+        let lastVisibleIsCompact = false;
+        const isCompactModeEnabled = settings.merged.ui?.compactToolOutput === true;
+        for (let i = toolCalls.length - 1; i >= 0; i--) {
+            if (isToolVisible(toolCalls[i])) {
+                const mapped = mapTrackedToolCallsToDisplay(toolCalls[i]);
+                lastVisibleIsCompact = mapped.tools[0]
+                    ? isCompactTool(mapped.tools[0], isCompactModeEnabled)
+                    : false;
+                break;
+            }
+        }
+        if (toolCalls.length > 0 &&
+            !(allTerminal && allPushed) &&
+            toolCalls.some(isToolVisible) &&
+            !lastVisibleIsCompact) {
+            items.push({
+                type: 'tool_group',
+                tools: [],
+                borderTop: false,
+                borderBottom: true,
+                ...appearance,
+            });
+        }
+        return items;
+    }, [
+        toolCalls,
+        pushedToolCallIds,
+        activeShellPtyId,
+        isShellFocused,
+        backgroundTasks,
+        settings.merged.ui?.compactToolOutput,
+    ]);
+    const lastQueryRef = useRef(null);
+    const lastPromptIdRef = useRef(null);
+    const loopDetectedRef = useRef(false);
+    const [loopDetectionConfirmationRequest, setLoopDetectionConfirmationRequest,] = useState(null);
+    const activePtyId = activeShellPtyId ?? activeBackgroundExecutionId ?? undefined;
+    const prevActiveShellPtyIdRef = useRef(null);
+    useEffect(() => {
+        if (turnCancelledRef.current &&
+            prevActiveShellPtyIdRef.current !== null &&
+            activeShellPtyId === null) {
+            addItem({ type: MessageType.INFO, text: 'Request cancelled.' });
+            setIsResponding(false);
+        }
+        prevActiveShellPtyIdRef.current = activeShellPtyId;
+    }, [activeShellPtyId, addItem, setIsResponding]);
+    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));
+            }
+        }
+    }, [streamingState, config, history]);
+    useEffect(() => {
+        if (!isResponding) {
+            setRetryStatus(null);
+        }
+    }, [isResponding]);
+    const maybeAddSuppressedToolErrorNote = useCallback((userMessageTimestamp) => {
+        if (!isLowErrorVerbosity) {
+            return;
+        }
+        if (suppressedToolErrorCountRef.current === 0) {
+            return;
+        }
+        if (suppressedToolErrorNoteShownRef.current) {
+            return;
+        }
+        addItem({
+            type: MessageType.INFO,
+            text: SUPPRESSED_TOOL_ERRORS_NOTE,
+        }, userMessageTimestamp);
+        suppressedToolErrorNoteShownRef.current = true;
+    }, [addItem, isLowErrorVerbosity]);
+    const maybeAddLowVerbosityFailureNote = useCallback((userMessageTimestamp) => {
+        if (!isLowErrorVerbosity || config.getDebugMode()) {
+            return;
+        }
+        if (lowVerbosityFailureNoteShownRef.current ||
+            suppressedToolErrorNoteShownRef.current) {
+            return;
+        }
+        addItem({
+            type: MessageType.INFO,
+            text: LOW_VERBOSITY_FAILURE_NOTE,
+        }, userMessageTimestamp);
+        lowVerbosityFailureNoteShownRef.current = true;
+    }, [addItem, config, isLowErrorVerbosity]);
+    const cancelOngoingRequest = useCallback((clearBuffer = true) => {
+        // If we are already cancelled, do nothing
+        if (turnCancelledRef.current) {
+            if (clearBuffer) {
+                onCancelSubmit(false, true);
+            }
+            return;
+        }
+        const hasActiveTools = toolCalls.some((tc) => tc.status === CoreToolCallStatus.Executing ||
+            tc.status === CoreToolCallStatus.Scheduled ||
+            tc.status === CoreToolCallStatus.Validating);
+        // If we are not responding, not waiting for confirmation, and have no active tools,
+        // there is nothing to abort.
+        if (streamingState === StreamingState.Idle &&
+            !isRespondingRef.current &&
+            !hasActiveTools) {
+            // Even if we are "idle", if we are called with clearBuffer=true (Ctrl+C),
+            // we still want to clear the buffer.
+            if (clearBuffer) {
+                onCancelSubmit(false, true);
+            }
+            return;
+        }
+        turnCancelledRef.current = true;
+        setRetryStatus(null);
+        // A full cancellation means no tools have produced a final result yet.
+        // This determines if we show a generic "Request cancelled" message.
+        const isFullCancellation = !toolCalls.some((tc) => tc.status === 'success' || tc.status === 'error');
+        // Ensure we have an abort controller, creating one if it doesn't exist.
+        if (!abortControllerRef.current) {
+            abortControllerRef.current = new AbortController();
+        }
+        // The order is important here.
+        // 1. Fire the signal to interrupt any active async operations.
+        abortControllerRef.current.abort();
+        // 2. Call the imperative cancel to clear the queue of pending tools.
+        cancelAllToolCalls(abortControllerRef.current.signal);
+        if (pendingHistoryItemRef.current) {
+            // If it is a shell command, we update the status to Canceled and clear the output
+            // to avoid artifacts, then add it to history immediately.
+            if (pendingHistoryItemRef.current.type === 'tool_group' &&
+                pendingHistoryItemRef.current.tools.some((t) => t.name === SHELL_COMMAND_NAME)) {
+                const toolGroup = pendingHistoryItemRef.current;
+                const updatedTools = toolGroup.tools.map((tool) => {
+                    if (tool.name === SHELL_COMMAND_NAME) {
+                        return {
+                            ...tool,
+                            status: CoreToolCallStatus.Cancelled,
+                            resultDisplay: tool.resultDisplay,
+                        };
+                    }
+                    return tool;
+                });
+                const newToolGroup = {
+                    ...toolGroup,
+                    tools: updatedTools,
+                };
+                addItem(newToolGroup);
+            }
+            else {
+                addItem(pendingHistoryItemRef.current);
+            }
+        }
+        setPendingHistoryItem(null);
+        // If it was a full cancellation, add the info message now.
+        // Otherwise, we let handleCompletedTools figure out the next step,
+        // which might involve sending partial results back to the model.
+        if (isFullCancellation) {
+            // If shell is active, we delay this message to ensure correct ordering
+            // (Shell item first, then Info message).
+            if (!activeShellPtyId) {
+                addItem({
+                    type: MessageType.INFO,
+                    text: 'Request cancelled.',
+                });
+                setIsResponding(false);
+            }
+        }
+        onCancelSubmit(false, clearBuffer);
+        setShellInputFocused(false);
+    }, [
+        streamingState,
+        addItem,
+        setPendingHistoryItem,
+        onCancelSubmit,
+        pendingHistoryItemRef,
+        isRespondingRef,
+        setShellInputFocused,
+        cancelAllToolCalls,
+        toolCalls,
+        activeShellPtyId,
+        setIsResponding,
+    ]);
+    useKeypress((key) => {
+        if (key.name === 'escape' && !isShellFocused) {
+            cancelOngoingRequest(false);
+            return true;
+        }
+        return false;
+    }, {
+        isActive: streamingState === StreamingState.Responding ||
+            streamingState === StreamingState.WaitingForConfirmation,
+    });
+    const prepareQueryForGemini = useCallback(async (query, userMessageTimestamp, abortSignal, prompt_id) => {
+        if (turnCancelledRef.current) {
+            return { queryToSend: null, shouldProceed: false };
+        }
+        if (typeof query === 'string' && query.trim().length === 0) {
+            return { queryToSend: null, shouldProceed: false };
+        }
+        let localQueryToSendToGemini = null;
+        if (typeof query === 'string') {
+            const trimmedQuery = query.trim();
+            await logger?.logMessage(MessageSenderType.USER, trimmedQuery);
+            if (!shellModeActive) {
+                // Handle UI-only commands first
+                const slashCommandResult = isSlashCommand(trimmedQuery)
+                    ? await handleSlashCommand(trimmedQuery)
+                    : false;
+                if (slashCommandResult) {
+                    switch (slashCommandResult.type) {
+                        case 'schedule_tool': {
+                            const { toolName, toolArgs, postSubmitPrompt } = slashCommandResult;
+                            const toolCallRequest = {
+                                callId: `${toolName}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                                name: toolName,
+                                args: toolArgs,
+                                isClientInitiated: true,
+                                prompt_id,
+                            };
+                            await scheduleToolCalls([toolCallRequest], abortSignal);
+                            if (postSubmitPrompt) {
+                                localQueryToSendToGemini = postSubmitPrompt;
+                                return {
+                                    queryToSend: localQueryToSendToGemini,
+                                    shouldProceed: true,
+                                };
+                            }
+                            return { queryToSend: null, shouldProceed: false };
+                        }
+                        case 'submit_prompt': {
+                            localQueryToSendToGemini = slashCommandResult.content;
+                            return {
+                                queryToSend: localQueryToSendToGemini,
+                                shouldProceed: true,
+                            };
+                        }
+                        case 'handled': {
+                            return { queryToSend: null, shouldProceed: false };
+                        }
+                        default: {
+                            const unreachable = slashCommandResult;
+                            throw new Error(`Unhandled slash command result type: ${unreachable}`);
+                        }
+                    }
+                }
+            }
+            if (shellModeActive && handleShellCommand(trimmedQuery, abortSignal)) {
+                return { queryToSend: null, shouldProceed: false };
+            }
+            // Handle @-commands (which might involve tool calls)
+            if (isAtCommand(trimmedQuery)) {
+                // Add user's turn before @ command processing for correct UI ordering.
+                addItem({ type: MessageType.USER, text: trimmedQuery }, userMessageTimestamp);
+                const atCommandResult = await handleAtCommand({
+                    query: trimmedQuery,
+                    config,
+                    addItem,
+                    onDebugMessage,
+                    messageId: userMessageTimestamp,
+                    signal: abortSignal,
+                    escapePastedAtSymbols: settings.merged.ui?.escapePastedAtSymbols,
+                });
+                if (atCommandResult.error) {
+                    onDebugMessage(atCommandResult.error);
+                    return { queryToSend: null, shouldProceed: false };
+                }
+                localQueryToSendToGemini = atCommandResult.processedQuery;
+            }
+            else {
+                // Normal query for Gemini
+                addItem({ type: MessageType.USER, text: trimmedQuery }, userMessageTimestamp);
+                localQueryToSendToGemini = trimmedQuery;
+            }
+        }
+        else {
+            // It's a function response (PartListUnion that isn't a string)
+            localQueryToSendToGemini = query;
+        }
+        if (localQueryToSendToGemini === null) {
+            onDebugMessage('Query processing resulted in null, not sending to Gemini.');
+            return { queryToSend: null, shouldProceed: false };
+        }
+        return { queryToSend: localQueryToSendToGemini, shouldProceed: true };
+    }, [
+        config,
+        addItem,
+        onDebugMessage,
+        handleShellCommand,
+        handleSlashCommand,
+        logger,
+        shellModeActive,
+        scheduleToolCalls,
+        settings,
+    ]);
+    // --- Stream Event Handlers ---
+    const handleContentEvent = useCallback((eventValue, currentGeminiMessageBuffer, userMessageTimestamp) => {
+        setRetryStatus(null);
+        if (turnCancelledRef.current) {
+            // Prevents additional output after a user initiated cancel.
+            return '';
+        }
+        let newGeminiMessageBuffer = currentGeminiMessageBuffer + eventValue;
+        if (pendingHistoryItemRef.current?.type !== 'gemini' &&
+            pendingHistoryItemRef.current?.type !== 'gemini_content') {
+            // Flush any pending item before starting gemini content
+            if (pendingHistoryItemRef.current) {
+                addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            }
+            setPendingHistoryItem({ type: 'gemini', text: '' });
+            newGeminiMessageBuffer = eventValue;
+        }
+        // Split large messages for better rendering performance. Ideally,
+        // we should maximize the amount of output sent to <Static />.
+        const splitPoint = findLastSafeSplitPoint(newGeminiMessageBuffer);
+        if (splitPoint === newGeminiMessageBuffer.length) {
+            // Update the existing message with accumulated content
+            setPendingHistoryItem((item) => ({
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                type: item?.type,
+                text: newGeminiMessageBuffer,
+            }));
+        }
+        else {
+            // This indicates that we need to split up this Gemini Message.
+            // Splitting a message is primarily a performance consideration. There is a
+            // <Static> component at the root of App.tsx which takes care of rendering
+            // content statically or dynamically. Everything but the last message is
+            // treated as static in order to prevent re-rendering an entire message history
+            // multiple times per-second (as streaming occurs). Prior to this change you'd
+            // see heavy flickering of the terminal. This ensures that larger messages get
+            // broken up so that there are more "statically" rendered.
+            const beforeText = newGeminiMessageBuffer.substring(0, splitPoint);
+            const afterText = newGeminiMessageBuffer.substring(splitPoint);
+            if (beforeText.length > 0) {
+                addItem({
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                    type: pendingHistoryItemRef.current?.type,
+                    text: beforeText,
+                }, userMessageTimestamp);
+            }
+            setPendingHistoryItem({ type: 'gemini_content', text: afterText });
+            newGeminiMessageBuffer = afterText;
+        }
+        return newGeminiMessageBuffer;
+    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem]);
+    const handleThoughtEvent = useCallback((eventValue, _userMessageTimestamp) => {
+        setThought(eventValue);
+        if (getInlineThinkingMode(settings) === 'full') {
+            addItem({
+                type: 'thinking',
+                thought: eventValue,
+            });
+        }
+    }, [addItem, settings, setThought]);
+    const handleUserCancelledEvent = useCallback((userMessageTimestamp) => {
+        if (turnCancelledRef.current) {
+            return;
+        }
+        if (pendingHistoryItemRef.current) {
+            if (pendingHistoryItemRef.current.type === 'tool_group') {
+                const updatedTools = pendingHistoryItemRef.current.tools.map((tool) => tool.status === CoreToolCallStatus.Validating ||
+                    tool.status === CoreToolCallStatus.Scheduled ||
+                    tool.status === CoreToolCallStatus.AwaitingApproval ||
+                    tool.status === CoreToolCallStatus.Executing
+                    ? { ...tool, status: CoreToolCallStatus.Cancelled }
+                    : tool);
+                const pendingItem = {
+                    ...pendingHistoryItemRef.current,
+                    tools: updatedTools,
+                };
+                addItem(pendingItem, userMessageTimestamp);
+            }
+            else {
+                addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            }
+            setPendingHistoryItem(null);
+        }
+        addItem({ type: MessageType.INFO, text: 'User cancelled the request.' }, userMessageTimestamp);
+        setIsResponding(false);
+        setThought(null); // Reset thought when user cancels
+    }, [
+        addItem,
+        pendingHistoryItemRef,
+        setPendingHistoryItem,
+        setThought,
+        setIsResponding,
+    ]);
+    const handleErrorEvent = useCallback((eventValue, userMessageTimestamp) => {
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            setPendingHistoryItem(null);
+        }
+        maybeAddSuppressedToolErrorNote(userMessageTimestamp);
+        addItem({
+            type: MessageType.ERROR,
+            text: parseAndFormatApiError(eventValue.error, config.getContentGeneratorConfig()?.authType, undefined, config.getModel(), DEFAULT_GEMINI_FLASH_MODEL),
+        }, userMessageTimestamp);
+        maybeAddLowVerbosityFailureNote(userMessageTimestamp);
+        setThought(null); // Reset thought when there's an error
+    }, [
+        addItem,
+        pendingHistoryItemRef,
+        setPendingHistoryItem,
+        config,
+        setThought,
+        maybeAddSuppressedToolErrorNote,
+        maybeAddLowVerbosityFailureNote,
+    ]);
+    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.reason;
+        if (!finishReason) {
+            return;
+        }
+        const finishReasonMessages = {
+            [FinishReason.FINISH_REASON_UNSPECIFIED]: undefined,
+            [FinishReason.STOP]: undefined,
+            [FinishReason.MAX_TOKENS]: 'Response truncated due to token limits.',
+            [FinishReason.SAFETY]: 'Response stopped due to safety reasons.',
+            [FinishReason.RECITATION]: 'Response stopped due to recitation policy.',
+            [FinishReason.LANGUAGE]: 'Response stopped due to unsupported language.',
+            [FinishReason.BLOCKLIST]: 'Response stopped due to forbidden terms.',
+            [FinishReason.PROHIBITED_CONTENT]: 'Response stopped due to prohibited content.',
+            [FinishReason.SPII]: 'Response stopped due to sensitive personally identifiable information.',
+            [FinishReason.OTHER]: 'Response stopped for other reasons.',
+            [FinishReason.MALFORMED_FUNCTION_CALL]: 'Response stopped due to malformed function call.',
+            [FinishReason.IMAGE_SAFETY]: 'Response stopped due to image safety violations.',
+            [FinishReason.UNEXPECTED_TOOL_CALL]: 'Response stopped due to unexpected tool call.',
+            [FinishReason.IMAGE_PROHIBITED_CONTENT]: 'Response stopped due to prohibited image content.',
+            [FinishReason.NO_IMAGE]: 'Response stopped because no image was generated.',
+        };
+        const message = finishReasonMessages[finishReason];
+        if (message) {
+            addItem({
+                type: 'info',
+                text: `⚠️  ${message}`,
+            }, userMessageTimestamp);
+        }
+    }, [addItem]);
+    const handleChatCompressionEvent = useCallback((eventValue, userMessageTimestamp) => {
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            setPendingHistoryItem(null);
+        }
+        const limit = tokenLimit(config.getModel());
+        const originalPercentage = Math.round(((eventValue?.originalTokenCount ?? 0) / limit) * 100);
+        const newPercentage = Math.round(((eventValue?.newTokenCount ?? 0) / limit) * 100);
+        addItem({
+            type: MessageType.INFO,
+            text: `Context compressed from ${originalPercentage}% to ${newPercentage}%.`,
+            secondaryText: `Change threshold in /settings.`,
+            color: theme.status.warning,
+            marginBottom: 1,
+        }, userMessageTimestamp);
+    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem, config]);
+    const handleMaxSessionTurnsEvent = useCallback(() => addItem({
+        type: 'info',
+        text: `The session has reached the maximum number of turns: ${config.getMaxSessionTurns()}. ` +
+            `Please update this limit in your setting.json file.`,
+    }), [addItem, config]);
+    const handleContextWindowWillOverflowEvent = useCallback((estimatedRequestTokenCount, remainingTokenCount) => {
+        onCancelSubmit(true);
+        const limit = tokenLimit(config.getModel());
+        const isMoreThan25PercentUsed = limit > 0 && remainingTokenCount < limit * 0.75;
+        let text = `Sending this message (${estimatedRequestTokenCount} tokens) might exceed the context window limit (${remainingTokenCount.toLocaleString()} tokens left).`;
+        if (isMoreThan25PercentUsed) {
+            text +=
+                ' Please try reducing the size of your message or use the `/compress` command to compress the chat history.';
+        }
+        addItem({
+            type: 'info',
+            text,
+        });
+    }, [addItem, onCancelSubmit, config]);
+    const handleChatModelEvent = useCallback((eventValue, userMessageTimestamp) => {
+        if (!settings.merged.ui.showModelInfoInChat) {
+            return;
+        }
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            setPendingHistoryItem(null);
+        }
+        addItem({
+            type: 'model',
+            model: eventValue,
+        }, userMessageTimestamp);
+    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem, settings]);
+    const handleAgentExecutionStoppedEvent = useCallback((reason, userMessageTimestamp, systemMessage, contextCleared) => {
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            setPendingHistoryItem(null);
+        }
+        addItem({
+            type: MessageType.INFO,
+            text: `Agent execution stopped: ${systemMessage?.trim() || reason}`,
+        }, userMessageTimestamp);
+        maybeAddLowVerbosityFailureNote(userMessageTimestamp);
+        if (contextCleared) {
+            addItem({
+                type: MessageType.INFO,
+                text: 'Conversation context has been cleared.',
+            }, userMessageTimestamp);
+        }
+        setIsResponding(false);
+    }, [
+        addItem,
+        pendingHistoryItemRef,
+        setPendingHistoryItem,
+        setIsResponding,
+        maybeAddLowVerbosityFailureNote,
+    ]);
+    const handleAgentExecutionBlockedEvent = useCallback((reason, userMessageTimestamp, systemMessage, contextCleared) => {
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+            setPendingHistoryItem(null);
+        }
+        addItem({
+            type: MessageType.WARNING,
+            text: `Agent execution blocked: ${systemMessage?.trim() || reason}`,
+        }, userMessageTimestamp);
+        maybeAddLowVerbosityFailureNote(userMessageTimestamp);
+        if (contextCleared) {
+            addItem({
+                type: MessageType.INFO,
+                text: 'Conversation context has been cleared.',
+            }, userMessageTimestamp);
+        }
+    }, [
+        addItem,
+        pendingHistoryItemRef,
+        setPendingHistoryItem,
+        maybeAddLowVerbosityFailureNote,
+    ]);
+    const processGeminiStreamEvents = useCallback(async (stream, userMessageTimestamp, signal) => {
+        let geminiMessageBuffer = '';
+        const toolCallRequests = [];
+        for await (const event of stream) {
+            if (event.type !== ServerGeminiEventType.Thought &&
+                thoughtRef.current !== null) {
+                setThought(null);
+            }
+            switch (event.type) {
+                case ServerGeminiEventType.Thought:
+                    setLastGeminiActivityTime(Date.now());
+                    handleThoughtEvent(event.value, userMessageTimestamp);
+                    break;
+                case ServerGeminiEventType.Content:
+                    setLastGeminiActivityTime(Date.now());
+                    geminiMessageBuffer = handleContentEvent(event.value, geminiMessageBuffer, userMessageTimestamp);
+                    break;
+                case ServerGeminiEventType.ToolCallRequest:
+                    toolCallRequests.push(event.value);
+                    break;
+                case ServerGeminiEventType.UserCancelled:
+                    handleUserCancelledEvent(userMessageTimestamp);
+                    break;
+                case ServerGeminiEventType.Error:
+                    handleErrorEvent(event.value, userMessageTimestamp);
+                    break;
+                case ServerGeminiEventType.AgentExecutionStopped:
+                    handleAgentExecutionStoppedEvent(event.value.reason, userMessageTimestamp, event.value.systemMessage, event.value.contextCleared);
+                    break;
+                case ServerGeminiEventType.AgentExecutionBlocked:
+                    handleAgentExecutionBlockedEvent(event.value.reason, userMessageTimestamp, event.value.systemMessage, event.value.contextCleared);
+                    break;
+                case ServerGeminiEventType.ChatCompressed:
+                    handleChatCompressionEvent(event.value, userMessageTimestamp);
+                    break;
+                case ServerGeminiEventType.ToolCallConfirmation:
+                case ServerGeminiEventType.ToolCallResponse:
+                    // do nothing
+                    break;
+                case ServerGeminiEventType.MaxSessionTurns:
+                    handleMaxSessionTurnsEvent();
+                    break;
+                case ServerGeminiEventType.ContextWindowWillOverflow:
+                    handleContextWindowWillOverflowEvent(event.value.estimatedRequestTokenCount, event.value.remainingTokenCount);
+                    break;
+                case ServerGeminiEventType.Finished:
+                    handleFinishedEvent(event, userMessageTimestamp);
+                    break;
+                case ServerGeminiEventType.Citation:
+                    handleCitationEvent(event.value, userMessageTimestamp);
+                    break;
+                case ServerGeminiEventType.ModelInfo:
+                    handleChatModelEvent(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
+                    loopDetectedRef.current = true;
+                    break;
+                case ServerGeminiEventType.Retry:
+                case ServerGeminiEventType.InvalidStream:
+                    // Will add the missing logic later
+                    break;
+                default: {
+                    // enforces exhaustive switch-case
+                    const unreachable = event;
+                    return unreachable;
+                }
+            }
+        }
+        if (toolCallRequests.length > 0) {
+            if (pendingHistoryItemRef.current) {
+                addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+                setPendingHistoryItem(null);
+            }
+            await scheduleToolCalls(toolCallRequests, signal);
+        }
+        return StreamProcessingStatus.Completed;
+    }, [
+        handleContentEvent,
+        handleThoughtEvent,
+        thoughtRef,
+        handleUserCancelledEvent,
+        handleErrorEvent,
+        scheduleToolCalls,
+        handleChatCompressionEvent,
+        handleFinishedEvent,
+        handleMaxSessionTurnsEvent,
+        handleContextWindowWillOverflowEvent,
+        handleCitationEvent,
+        handleChatModelEvent,
+        handleAgentExecutionStoppedEvent,
+        handleAgentExecutionBlockedEvent,
+        addItem,
+        pendingHistoryItemRef,
+        setPendingHistoryItem,
+        setThought,
+    ]);
+    const submitQuery = useCallback(async (query, options, prompt_id) => runInDevTraceSpan({
+        operation: options?.isContinuation
+            ? GeminiCliOperation.SystemPrompt
+            : GeminiCliOperation.UserPrompt,
+        sessionId: config.getSessionId(),
+    }, async ({ metadata: spanMetadata }) => {
+        spanMetadata.input = query;
+        if ((isRespondingRef.current ||
+            streamingState === StreamingState.Responding ||
+            streamingState === StreamingState.WaitingForConfirmation) &&
+            !options?.isContinuation)
+            return;
+        const queryId = `${Date.now()}-${Math.random()}`;
+        activeQueryIdRef.current = queryId;
+        const userMessageTimestamp = Date.now();
+        // Reset quota error flag when starting a new query (not a continuation)
+        if (!options?.isContinuation) {
+            setModelSwitchedFromQuotaError(false);
+            config.setQuotaErrorOccurred(false);
+            config.resetBillingTurnState(settings.merged.billing?.overageStrategy);
+            suppressedToolErrorCountRef.current = 0;
+            suppressedToolErrorNoteShownRef.current = false;
+            lowVerbosityFailureNoteShownRef.current = false;
+        }
+        abortControllerRef.current = new AbortController();
+        const abortSignal = abortControllerRef.current.signal;
+        turnCancelledRef.current = false;
+        if (!prompt_id) {
+            prompt_id = config.getSessionId() + '########' + getPromptCount();
+        }
+        return promptIdContext.run(prompt_id, async () => {
+            const { queryToSend, shouldProceed } = await prepareQueryForGemini(query, userMessageTimestamp, abortSignal, prompt_id);
+            if (!shouldProceed || queryToSend === null) {
+                return;
+            }
+            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
+            }
+            setIsResponding(true);
+            setInitError(null);
+            // Store query and prompt_id for potential retry on loop detection
+            lastQueryRef.current = queryToSend;
+            lastPromptIdRef.current = prompt_id;
+            try {
+                const stream = geminiClient.sendMessageStream(queryToSend, abortSignal, prompt_id, undefined, query);
+                const processingStatus = await processGeminiStreamEvents(stream, userMessageTimestamp, abortSignal);
+                if (processingStatus === StreamProcessingStatus.UserCancelled) {
+                    return;
+                }
+                if (pendingHistoryItemRef.current) {
+                    addItem(pendingHistoryItemRef.current, userMessageTimestamp);
+                    setPendingHistoryItem(null);
+                }
+                if (loopDetectedRef.current) {
+                    loopDetectedRef.current = false;
+                    // Show the confirmation dialog to choose whether to disable loop detection
+                    setLoopDetectionConfirmationRequest({
+                        onComplete: async (result) => {
+                            setLoopDetectionConfirmationRequest(null);
+                            if (result.userSelection === 'disable') {
+                                config
+                                    .getGeminiClient()
+                                    .getLoopDetectionService()
+                                    .disableForSession();
+                                addItem({
+                                    type: 'info',
+                                    text: `Loop detection has been disabled for this session. Retrying request...`,
+                                });
+                                if (lastQueryRef.current && lastPromptIdRef.current) {
+                                    await submitQuery(lastQueryRef.current, { isContinuation: true }, lastPromptIdRef.current);
+                                }
+                            }
+                            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.`,
+                                });
+                            }
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                spanMetadata.error = error;
+                if (error instanceof UnauthorizedError) {
+                    onAuthError('Session expired or is unauthorized.');
+                }
+                else if (
+                // Suppress ValidationRequiredError if it was marked as handled (e.g. user clicked change_auth or cancelled)
+                error instanceof ValidationRequiredError &&
+                    error.userHandled) {
+                    // Error was handled by validation dialog, don't display again
+                }
+                else if (!isNodeError(error) || error.name !== 'AbortError') {
+                    maybeAddSuppressedToolErrorNote(userMessageTimestamp);
+                    addItem({
+                        type: MessageType.ERROR,
+                        text: parseAndFormatApiError(getErrorMessage(error) || 'Unknown error', config.getContentGeneratorConfig()?.authType, undefined, config.getModel(), DEFAULT_GEMINI_FLASH_MODEL),
+                    }, userMessageTimestamp);
+                    maybeAddLowVerbosityFailureNote(userMessageTimestamp);
+                }
+            }
+            finally {
+                if (activeQueryIdRef.current === queryId) {
+                    setIsResponding(false);
+                }
+            }
+        });
+    }), [
+        streamingState,
+        setModelSwitchedFromQuotaError,
+        prepareQueryForGemini,
+        processGeminiStreamEvents,
+        pendingHistoryItemRef,
+        addItem,
+        setPendingHistoryItem,
+        setInitError,
+        geminiClient,
+        onAuthError,
+        config,
+        startNewPrompt,
+        getPromptCount,
+        setThought,
+        maybeAddSuppressedToolErrorNote,
+        maybeAddLowVerbosityFailureNote,
+        isRespondingRef,
+        settings.merged.billing?.overageStrategy,
+        setIsResponding,
+    ]);
+    const handleApprovalModeChange = useCallback(async (newApprovalMode) => {
+        if (previousApprovalModeRef.current === ApprovalMode.PLAN &&
+            newApprovalMode !== ApprovalMode.PLAN &&
+            streamingState === StreamingState.Idle) {
+            if (geminiClient) {
+                try {
+                    await geminiClient.addHistory({
+                        role: 'user',
+                        parts: [
+                            {
+                                text: getPlanModeExitMessage(newApprovalMode, true),
+                            },
+                        ],
+                    });
+                }
+                catch (error) {
+                    onDebugMessage(`Failed to notify model of Plan Mode exit: ${getErrorMessage(error)}`);
+                    addItem({
+                        type: MessageType.ERROR,
+                        text: 'Failed to update the model about exiting Plan Mode. The model might be out of sync. Please consider restarting the session if you see unexpected behavior.',
+                    });
+                }
+            }
+        }
+        previousApprovalModeRef.current = 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' && !call.request.forcedAsk);
+            // For AUTO_EDIT mode, only approve edit tools (replace, write_file)
+            // or shell commands with redirection (which act as edits).
+            if (newApprovalMode === ApprovalMode.AUTO_EDIT) {
+                awaitingApprovalCalls = awaitingApprovalCalls.filter((call) => {
+                    if (EDIT_TOOL_NAMES.has(call.request.name)) {
+                        return true;
+                    }
+                    if (call.request.name === SHELL_TOOL_NAME) {
+                        const command = call.request.args
+                            .command;
+                        return command && hasRedirection(command);
+                    }
+                    return false;
+                });
+            }
+            // Process pending tool calls sequentially to reduce UI chaos
+            for (const call of awaitingApprovalCalls) {
+                if (call.correlationId) {
+                    try {
+                        await config.getMessageBus().publish({
+                            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+                            correlationId: call.correlationId,
+                            confirmed: true,
+                            requiresUserConfirmation: false,
+                            outcome: ToolConfirmationOutcome.ProceedOnce,
+                        });
+                    }
+                    catch (error) {
+                        debugLogger.warn(`Failed to auto-approve tool call ${call.request.callId}:`, error);
+                    }
+                }
+            }
+        }
+    }, [config, toolCalls, geminiClient, streamingState, addItem, onDebugMessage]);
+    const handleCompletedTools = useCallback(async (completedToolCallsFromScheduler) => {
+        const completedAndReadyToSubmitTools = completedToolCallsFromScheduler.filter((tc) => {
+            const isTerminalState = tc.status === 'success' ||
+                tc.status === 'error' ||
+                tc.status === 'cancelled';
+            if (isTerminalState) {
+                const completedOrCancelledCall = tc;
+                return (completedOrCancelledCall.response?.responseParts !== undefined);
+            }
+            return false;
+        });
+        // Finalize any client-initiated tools as soon as they are done.
+        const clientTools = completedAndReadyToSubmitTools.filter((t) => t.request.isClientInitiated);
+        if (clientTools.length > 0) {
+            markToolsAsSubmitted(clientTools.map((t) => t.request.callId));
+            if (geminiClient) {
+                for (const tool of clientTools) {
+                    // Only manually record skill activations in the chat history.
+                    // Other client-initiated tools update context and don't strictly
+                    // need to be in the history.
+                    if (tool.request.name !== ACTIVATE_SKILL_TOOL_NAME) {
+                        continue;
+                    }
+                    // Add both the call (model turn) and the result (user turn) to history.
+                    // Client-initiated calls are essentially "synthetic" turns that let
+                    // subsequent model calls understand what just happened in the UI.
+                    await geminiClient.addHistory({
+                        role: 'model',
+                        parts: [
+                            {
+                                functionCall: {
+                                    name: tool.request.name,
+                                    args: tool.request.args,
+                                },
+                            },
+                        ],
+                    });
+                    await geminiClient.addHistory({
+                        role: 'user',
+                        parts: tool.response.responseParts,
+                    });
+                }
+            }
+        }
+        for (const toolCall of completedAndReadyToSubmitTools) {
+            const backgroundedTool = getBackgroundedToolInfo(toolCall);
+            if (backgroundedTool) {
+                registerBackgroundTask(backgroundedTool.pid, backgroundedTool.command, backgroundedTool.initialOutput);
+            }
+        }
+        const geminiTools = completedAndReadyToSubmitTools.filter((t) => !t.request.isClientInitiated);
+        if (isLowErrorVerbosity) {
+            // Low-mode suppression applies only to model-initiated tool failures.
+            suppressedToolErrorCountRef.current += geminiTools.filter((tc) => tc.status === CoreToolCallStatus.Error).length;
+        }
+        if (geminiTools.length === 0) {
+            return;
+        }
+        // Check if any tool requested to stop execution immediately
+        const stopExecutionTool = geminiTools.find((tc) => tc.response.errorType === ToolErrorType.STOP_EXECUTION);
+        if (stopExecutionTool && stopExecutionTool.response.error) {
+            maybeAddSuppressedToolErrorNote();
+            addItem({
+                type: MessageType.INFO,
+                text: `Agent execution stopped: ${stopExecutionTool.response.error.message}`,
+            });
+            maybeAddLowVerbosityFailureNote();
+            setIsResponding(false);
+            const callIdsToMarkAsSubmitted = geminiTools.map((toolCall) => toolCall.request.callId);
+            markToolsAsSubmitted(callIdsToMarkAsSubmitted);
+            return;
+        }
+        // If all the tools were cancelled, don't submit a response to Gemini.
+        // Note: we ignore the topic tool because the user doesn't have a chance to decline it.
+        const declinableTools = geminiTools.filter((tc) => !isTopicTool(tc.request.name));
+        const allDeclinableToolsCancelled = declinableTools.length > 0 &&
+            declinableTools.every((tc) => tc.status === CoreToolCallStatus.Cancelled);
+        const allToolsCancelled = geminiTools.length > 0 &&
+            geminiTools.every((tc) => tc.status === CoreToolCallStatus.Cancelled);
+        if (allDeclinableToolsCancelled || allToolsCancelled) {
+            // If the turn was cancelled via the imperative escape key flow,
+            // the cancellation message is added there. We check the ref to avoid duplication.
+            if (!turnCancelledRef.current) {
+                addItem({
+                    type: MessageType.INFO,
+                    text: 'Request cancelled.',
+                });
+            }
+            setIsResponding(false);
+            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);
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                geminiClient.addHistory({
+                    role: 'user',
+                    parts: combinedParts,
+                });
+            }
+            const callIdsToMarkAsSubmitted = geminiTools.map((toolCall) => toolCall.request.callId);
+            markToolsAsSubmitted(callIdsToMarkAsSubmitted);
+            return;
+        }
+        const responsesToSend = geminiTools.flatMap((toolCall) => toolCall.response.responseParts);
+        if (consumeUserHint) {
+            const userHint = consumeUserHint();
+            if (userHint && userHint.trim().length > 0) {
+                const hintText = userHint.trim();
+                responsesToSend.unshift({
+                    text: buildUserSteeringHintPrompt(hintText),
+                });
+            }
+        }
+        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;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        submitQuery(responsesToSend, {
+            isContinuation: true,
+        }, prompt_ids[0]);
+    }, [
+        submitQuery,
+        markToolsAsSubmitted,
+        geminiClient,
+        modelSwitchedFromQuotaError,
+        addItem,
+        registerBackgroundTask,
+        consumeUserHint,
+        isLowErrorVerbosity,
+        maybeAddSuppressedToolErrorNote,
+        maybeAddLowVerbosityFailureNote,
+        setIsResponding,
+    ]);
+    const pendingHistoryItems = useMemo(() => [pendingHistoryItem, ...pendingToolGroupItems].filter((i) => i !== undefined && i !== null), [pendingHistoryItem, pendingToolGroupItems]);
+    useEffect(() => {
+        const saveRestorableToolCalls = async () => {
+            if (!config.getCheckpointingEnabled()) {
+                return;
+            }
+            const restorableToolCalls = toolCalls.filter((toolCall) => EDIT_TOOL_NAMES.has(toolCall.request.name) &&
+                toolCall.status === CoreToolCallStatus.AwaitingApproval);
+            if (restorableToolCalls.length > 0) {
+                if (!gitService) {
+                    onDebugMessage('Checkpointing is enabled but Git service is not available. Failed to create snapshot. Ensure Git is installed and working properly.');
+                    return;
+                }
+                const { checkpointsToWrite, errors } = await processRestorableToolCalls(restorableToolCalls.map((call) => call.request), gitService, geminiClient, history);
+                if (errors.length > 0) {
+                    errors.forEach(onDebugMessage);
+                }
+                if (checkpointsToWrite.size > 0) {
+                    const checkpointDir = config.storage.getProjectTempCheckpointsDir();
+                    try {
+                        await fs.mkdir(checkpointDir, { recursive: true });
+                        for (const [fileName, content] of checkpointsToWrite) {
+                            const filePath = path.join(checkpointDir, fileName);
+                            await fs.writeFile(filePath, content);
+                        }
+                    }
+                    catch (error) {
+                        onDebugMessage(`Failed to write checkpoint file: ${getErrorMessage(error)}`);
+                    }
+                }
+            }
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        saveRestorableToolCalls();
+    }, [toolCalls, config, onDebugMessage, gitService, history, geminiClient]);
+    const lastOutputTime = Math.max(lastToolOutputTime, lastShellOutputTime, lastGeminiActivityTime);
+    return {
+        streamingState,
+        submitQuery,
+        initError,
+        pendingHistoryItems,
+        thought,
+        cancelOngoingRequest,
+        pendingToolCalls: toolCalls,
+        handleApprovalModeChange,
+        activePtyId,
+        loopDetectionConfirmationRequest,
+        lastOutputTime,
+        backgroundTaskCount,
+        isBackgroundTaskVisible,
+        toggleBackgroundTasks,
+        backgroundCurrentExecution,
+        backgroundTasks,
+        dismissBackgroundTask,
+        retryStatus,
+    };
+};
+//# sourceMappingURL=useGeminiStream.js.map