@quantum-ai/gemini-cli 0.45.8 → 0.45.9

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

@@ -1,1423 +0,0 @@
-/**
- * @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 '@google/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,
-                ...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