@aetherai/aether 0.0.7 → 0.0.8

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

@@ -1,1197 +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, SendMessageType, createDebugLogger, getErrorMessage, isNodeError, MessageSenderType, logUserPrompt, logUserRetry, GitService, UnauthorizedError, UserPromptEvent, UserRetryEvent, logConversationFinishedEvent, ConversationFinishedEvent, ApprovalMode, parseAndFormatApiError, promptIdContext, ToolConfirmationOutcome, logApiCancel, ApiCancelEvent, isSupportedImageMimeType, getUnsupportedImageFormatWarning, } from '@aetherai/aether-core';
-import { FinishReason } from '@google/genai';
-import { StreamingState, MessageType, ToolCallStatus } from '../types.js';
-import { isAtCommand, isBtwCommand, isSlashCommand, } from '../utils/commandUtils.js';
-import { useShellCommandProcessor } from './shellCommandProcessor.js';
-import { handleAtCommand } from './atCommandProcessor.js';
-import { findLastSafeSplitPoint } from '../utils/markdownUtilities.js';
-import { useStateAndRef } from './useStateAndRef.js';
-import { useLogger } from './useLogger.js';
-import { useReactToolScheduler, mapToDisplay as mapTrackedToolCallsToDisplay, } from './useReactToolScheduler.js';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { useSessionStats } from '../contexts/SessionContext.js';
-import { t } from '../../i18n/index.js';
-const debugLogger = createDebugLogger('GEMINI_STREAM');
-/**
- * Checks if image parts have supported formats and returns unsupported ones
- */
-function checkImageFormatsSupport(parts) {
-    const unsupportedMimeTypes = [];
-    let hasImages = false;
-    if (typeof parts === 'string') {
-        return {
-            hasImages: false,
-            hasUnsupportedFormats: false,
-            unsupportedMimeTypes: [],
-        };
-    }
-    const partsArray = Array.isArray(parts) ? parts : [parts];
-    for (const part of partsArray) {
-        if (typeof part === 'string')
-            continue;
-        let mimeType;
-        // Check inlineData
-        if ('inlineData' in part &&
-            part.inlineData?.mimeType?.startsWith('image/')) {
-            hasImages = true;
-            mimeType = part.inlineData.mimeType;
-        }
-        // Check fileData
-        if ('fileData' in part && part.fileData?.mimeType?.startsWith('image/')) {
-            hasImages = true;
-            mimeType = part.fileData.mimeType;
-        }
-        // Check if the mime type is supported
-        if (mimeType && !isSupportedImageMimeType(mimeType)) {
-            unsupportedMimeTypes.push(mimeType);
-        }
-    }
-    return {
-        hasImages,
-        hasUnsupportedFormats: unsupportedMimeTypes.length > 0,
-        unsupportedMimeTypes,
-    };
-}
-var StreamProcessingStatus;
-(function (StreamProcessingStatus) {
-    StreamProcessingStatus[StreamProcessingStatus["Completed"] = 0] = "Completed";
-    StreamProcessingStatus[StreamProcessingStatus["UserCancelled"] = 1] = "UserCancelled";
-    StreamProcessingStatus[StreamProcessingStatus["Error"] = 2] = "Error";
-})(StreamProcessingStatus || (StreamProcessingStatus = {}));
-const EDIT_TOOL_NAMES = new Set(['replace', 'write_file']);
-function showCitations(settings) {
-    const enabled = settings?.merged?.ui?.showCitations;
-    if (enabled !== undefined) {
-        return enabled;
-    }
-    return true;
-}
-/**
- * Manages the Gemini stream, including user input, command processing,
- * API interaction, and tool call lifecycle.
- */
-export const useGeminiStream = (geminiClient, history, addItem, config, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, midTurnDrainRef) => {
-    const [initError, setInitError] = useState(null);
-    const abortControllerRef = useRef(null);
-    const turnCancelledRef = useRef(false);
-    const isSubmittingQueryRef = useRef(false);
-    const lastPromptRef = useRef(null);
-    const lastPromptErroredRef = useRef(false);
-    const [isResponding, setIsResponding] = useState(false);
-    const [thought, setThought] = useState(null);
-    const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
-    const [pendingRetryErrorItem, pendingRetryErrorItemRef, setPendingRetryErrorItem,] = useStateAndRef(null);
-    const [pendingRetryCountdownItem, pendingRetryCountdownItemRef, setPendingRetryCountdownItem,] = useStateAndRef(null);
-    const retryCountdownTimerRef = useRef(null);
-    const processedMemoryToolsRef = useRef(new Set());
-    const { startNewPrompt, getPromptCount, stats: sessionStates, } = useSessionStats();
-    const storage = config.storage;
-    const logger = useLogger(storage, sessionStates.sessionId);
-    const gitService = useMemo(() => {
-        if (!config.getProjectRoot()) {
-            return;
-        }
-        return new GitService(config.getProjectRoot(), storage);
-    }, [config, storage]);
-    const [toolCalls, scheduleToolCalls, markToolsAsSubmitted] = useReactToolScheduler(async (completedToolCallsFromScheduler) => {
-        // This onComplete is called when ALL scheduled tools for a given batch are done.
-        if (completedToolCallsFromScheduler.length > 0) {
-            // Add the final state of these tools to the history for display.
-            addItem(mapTrackedToolCallsToDisplay(completedToolCallsFromScheduler), Date.now());
-            // Handle tool response submission immediately when tools complete
-            await handleCompletedTools(completedToolCallsFromScheduler);
-        }
-    }, config, getPreferredEditor, onEditorClose);
-    const pendingToolCallGroupDisplay = useMemo(() => toolCalls.length ? mapTrackedToolCallsToDisplay(toolCalls) : undefined, [toolCalls]);
-    const activeToolPtyId = useMemo(() => {
-        const executingShellTool = toolCalls?.find((tc) => tc.status === 'executing' && tc.request.name === 'run_shell_command');
-        if (executingShellTool) {
-            return executingShellTool.pid;
-        }
-        return undefined;
-    }, [toolCalls]);
-    const loopDetectedRef = useRef(false);
-    const [loopDetectionConfirmationRequest, setLoopDetectionConfirmationRequest,] = useState(null);
-    const stopRetryCountdownTimer = useCallback(() => {
-        if (retryCountdownTimerRef.current) {
-            clearInterval(retryCountdownTimerRef.current);
-            retryCountdownTimerRef.current = null;
-        }
-    }, []);
-    /**
-     * Clears the retry countdown timer and pending retry items.
-     */
-    const clearRetryCountdown = useCallback(() => {
-        stopRetryCountdownTimer();
-        skipRetryDelayRef.current = null;
-        setPendingRetryErrorItem(null);
-        setPendingRetryCountdownItem(null);
-    }, [
-        setPendingRetryErrorItem,
-        setPendingRetryCountdownItem,
-        stopRetryCountdownTimer,
-    ]);
-    // Holds the skipDelay callback from the current rate-limit RetryInfo.
-    // Managed symmetrically: set in startRetryCountdown, cleared in clearRetryCountdown.
-    const skipRetryDelayRef = useRef(null);
-    const startRetryCountdown = useCallback((retryInfo) => {
-        stopRetryCountdownTimer();
-        skipRetryDelayRef.current = retryInfo.skipDelay;
-        const startTime = Date.now();
-        const { message, attempt, maxRetries, delayMs } = retryInfo;
-        const retryReasonText = message ?? t('Rate limit exceeded. Please wait and try again.');
-        // Countdown line updates every second (dim/secondary color)
-        const updateCountdown = () => {
-            const elapsedMs = Date.now() - startTime;
-            const remainingMs = Math.max(0, delayMs - elapsedMs);
-            const remainingSec = Math.ceil(remainingMs / 1000);
-            // Update error item with hint containing countdown info (short format)
-            const hintText = `Retrying in ${remainingSec}s… (attempt ${attempt}/${maxRetries})`;
-            setPendingRetryErrorItem({
-                type: MessageType.ERROR,
-                text: retryReasonText,
-                hint: hintText,
-            });
-            setPendingRetryCountdownItem({
-                type: 'retry_countdown',
-                text: t('Retrying in {{seconds}} seconds… (attempt {{attempt}}/{{maxRetries}})', {
-                    seconds: String(remainingSec),
-                    attempt: String(attempt),
-                    maxRetries: String(maxRetries),
-                }),
-            });
-            if (remainingMs <= 0) {
-                stopRetryCountdownTimer();
-            }
-        };
-        updateCountdown();
-        retryCountdownTimerRef.current = setInterval(updateCountdown, 1000);
-    }, [
-        setPendingRetryErrorItem,
-        setPendingRetryCountdownItem,
-        stopRetryCountdownTimer,
-    ]);
-    useEffect(() => () => stopRetryCountdownTimer(), [stopRetryCountdownTimer]);
-    const onExec = useCallback(async (done) => {
-        setIsResponding(true);
-        await done;
-        setIsResponding(false);
-    }, []);
-    const { handleShellCommand, activeShellPtyId } = useShellCommandProcessor(addItem, setPendingHistoryItem, onExec, onDebugMessage, config, geminiClient, setShellInputFocused, terminalWidth, terminalHeight);
-    const activePtyId = activeShellPtyId || activeToolPtyId;
-    useEffect(() => {
-        if (!activePtyId) {
-            setShellInputFocused(false);
-        }
-    }, [activePtyId, setShellInputFocused]);
-    const streamingState = useMemo(() => {
-        if (toolCalls.some((tc) => tc.status === 'awaiting_approval')) {
-            return StreamingState.WaitingForConfirmation;
-        }
-        // Check if any executing subagent task has a pending confirmation
-        if (toolCalls.some((tc) => {
-            if (tc.status !== 'executing')
-                return false;
-            const liveOutput = tc.liveOutput;
-            return (typeof liveOutput === 'object' &&
-                liveOutput !== null &&
-                'type' in liveOutput &&
-                liveOutput.type === 'task_execution' &&
-                'pendingConfirmation' in liveOutput &&
-                liveOutput.pendingConfirmation != null);
-        })) {
-            return StreamingState.WaitingForConfirmation;
-        }
-        if (isResponding ||
-            toolCalls.some((tc) => tc.status === 'executing' ||
-                tc.status === 'scheduled' ||
-                tc.status === 'validating' ||
-                ((tc.status === 'success' ||
-                    tc.status === 'error' ||
-                    tc.status === 'cancelled') &&
-                    !tc
-                        .responseSubmittedToGemini))) {
-            return StreamingState.Responding;
-        }
-        return StreamingState.Idle;
-    }, [isResponding, toolCalls]);
-    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]);
-    const cancelOngoingRequest = useCallback(() => {
-        if (streamingState !== StreamingState.Responding) {
-            return;
-        }
-        if (turnCancelledRef.current) {
-            return;
-        }
-        turnCancelledRef.current = true;
-        isSubmittingQueryRef.current = false;
-        abortControllerRef.current?.abort();
-        // Report cancellation to arena status reporter (if in arena mode).
-        // This is needed because cancellation during tool execution won't
-        // flow through sendMessageStream where the inline reportCancelled()
-        // lives — tools get cancelled and handleCompletedTools returns early.
-        config.getArenaAgentClient()?.reportCancelled();
-        // Log API cancellation
-        const prompt_id = config.getSessionId() + '########' + getPromptCount();
-        const cancellationEvent = new ApiCancelEvent(config.getModel(), prompt_id, config.getContentGeneratorConfig()?.authType);
-        logApiCancel(config, cancellationEvent);
-        if (pendingHistoryItemRef.current) {
-            addItem(pendingHistoryItemRef.current, Date.now());
-        }
-        addItem({
-            type: MessageType.INFO,
-            text: 'Request cancelled.',
-        }, Date.now());
-        setPendingHistoryItem(null);
-        clearRetryCountdown();
-        onCancelSubmit();
-        setIsResponding(false);
-        setShellInputFocused(false);
-    }, [
-        streamingState,
-        addItem,
-        setPendingHistoryItem,
-        onCancelSubmit,
-        pendingHistoryItemRef,
-        setShellInputFocused,
-        clearRetryCountdown,
-        config,
-        getPromptCount,
-    ]);
-    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();
-            onDebugMessage(`Received user query (${trimmedQuery.length} chars)`);
-            await logger?.logMessage(MessageSenderType.USER, trimmedQuery);
-            // Handle UI-only commands first
-            const slashCommandResult = isSlashCommand(trimmedQuery)
-                ? await handleSlashCommand(trimmedQuery)
-                : false;
-            if (slashCommandResult) {
-                switch (slashCommandResult.type) {
-                    case 'schedule_tool': {
-                        const { toolName, toolArgs } = slashCommandResult;
-                        const toolCallRequest = {
-                            callId: `${toolName}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
-                            name: toolName,
-                            args: toolArgs,
-                            isClientInitiated: true,
-                            prompt_id,
-                        };
-                        scheduleToolCalls([toolCallRequest], abortSignal);
-                        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 };
-            }
-            localQueryToSendToGemini = trimmedQuery;
-            addItem({ type: MessageType.USER, text: trimmedQuery }, userMessageTimestamp);
-            // Handle @-commands (which might involve tool calls)
-            if (isAtCommand(trimmedQuery)) {
-                const atCommandResult = await handleAtCommand({
-                    query: trimmedQuery,
-                    config,
-                    onDebugMessage,
-                    messageId: userMessageTimestamp,
-                    signal: abortSignal,
-                    addItem,
-                });
-                if (!atCommandResult.shouldProceed) {
-                    return { queryToSend: null, shouldProceed: false };
-                }
-                localQueryToSendToGemini = atCommandResult.processedQuery;
-            }
-        }
-        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,
-    ]);
-    // --- Stream Event Handlers ---
-    const handleContentEvent = useCallback((eventValue, currentGeminiMessageBuffer, userMessageTimestamp) => {
-        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') {
-            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) => ({
-                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);
-            addItem({
-                type: pendingHistoryItemRef.current?.type,
-                text: beforeText,
-            }, userMessageTimestamp);
-            setPendingHistoryItem({ type: 'gemini_content', text: afterText });
-            newGeminiMessageBuffer = afterText;
-        }
-        return newGeminiMessageBuffer;
-    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem]);
-    const mergeThought = useCallback((incoming) => {
-        setThought((prev) => {
-            if (!prev) {
-                return incoming;
-            }
-            const subject = incoming.subject || prev.subject;
-            const description = `${prev.description ?? ''}${incoming.description ?? ''}`;
-            return { subject, description };
-        });
-    }, [setThought]);
-    const handleThoughtEvent = useCallback((eventValue, currentThoughtBuffer, userMessageTimestamp) => {
-        if (turnCancelledRef.current) {
-            return '';
-        }
-        // Extract the description text from the thought summary
-        const thoughtText = eventValue.description ?? '';
-        if (!thoughtText) {
-            return currentThoughtBuffer;
-        }
-        let newThoughtBuffer = currentThoughtBuffer + thoughtText;
-        const pendingType = pendingHistoryItemRef.current?.type;
-        const isPendingThought = pendingType === 'gemini_thought' ||
-            pendingType === 'gemini_thought_content';
-        // If we're not already showing a thought, start a new one
-        if (!isPendingThought) {
-            // If there's a pending non-thought item, finalize it first
-            if (pendingHistoryItemRef.current) {
-                addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-            }
-            setPendingHistoryItem({ type: 'gemini_thought', text: '' });
-        }
-        // Split large thought messages for better rendering performance (same rationale
-        // as regular content streaming). This helps avoid terminal flicker caused by
-        // constantly re-rendering an ever-growing "pending" block.
-        const splitPoint = findLastSafeSplitPoint(newThoughtBuffer);
-        const nextPendingType = isPendingThought && pendingType === 'gemini_thought_content'
-            ? 'gemini_thought_content'
-            : 'gemini_thought';
-        if (splitPoint === newThoughtBuffer.length) {
-            // Update the existing thought message with accumulated content
-            setPendingHistoryItem({
-                type: nextPendingType,
-                text: newThoughtBuffer,
-            });
-        }
-        else {
-            const beforeText = newThoughtBuffer.substring(0, splitPoint);
-            const afterText = newThoughtBuffer.substring(splitPoint);
-            addItem({
-                type: nextPendingType,
-                text: beforeText,
-            }, userMessageTimestamp);
-            setPendingHistoryItem({
-                type: 'gemini_thought_content',
-                text: afterText,
-            });
-            newThoughtBuffer = afterText;
-        }
-        // Also update the thought state for the loading indicator
-        mergeThought(eventValue);
-        return newThoughtBuffer;
-    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem, mergeThought]);
-    const handleUserCancelledEvent = useCallback((userMessageTimestamp) => {
-        if (turnCancelledRef.current) {
-            return;
-        }
-        lastPromptErroredRef.current = false;
-        if (pendingHistoryItemRef.current) {
-            if (pendingHistoryItemRef.current.type === 'tool_group') {
-                const updatedTools = pendingHistoryItemRef.current.tools.map((tool) => tool.status === ToolCallStatus.Pending ||
-                    tool.status === ToolCallStatus.Confirming ||
-                    tool.status === ToolCallStatus.Executing
-                    ? { ...tool, status: ToolCallStatus.Canceled }
-                    : tool);
-                const pendingItem = {
-                    ...pendingHistoryItemRef.current,
-                    tools: updatedTools,
-                };
-                addItem(pendingItem, userMessageTimestamp);
-            }
-            else {
-                addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-            }
-            setPendingHistoryItem(null);
-        }
-        addItem({ type: MessageType.INFO, text: 'User cancelled the request.' }, userMessageTimestamp);
-        clearRetryCountdown();
-        setIsResponding(false);
-        setThought(null); // Reset thought when user cancels
-    }, [
-        addItem,
-        pendingHistoryItemRef,
-        setPendingHistoryItem,
-        setThought,
-        clearRetryCountdown,
-    ]);
-    const handleErrorEvent = useCallback((eventValue, userMessageTimestamp) => {
-        lastPromptErroredRef.current = true;
-        if (pendingHistoryItemRef.current) {
-            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-            setPendingHistoryItem(null);
-        }
-        // Only show Ctrl+Y hint if not already showing an auto-retry countdown
-        // (auto-retry countdown is shown when retryCountdownTimerRef is active)
-        const isShowingAutoRetry = retryCountdownTimerRef.current !== null;
-        clearRetryCountdown();
-        if (!isShowingAutoRetry) {
-            const retryHint = t('Press Ctrl+Y to retry');
-            // Store error with hint as a pending item (not in history).
-            // This allows the hint to be removed when the user retries with Ctrl+Y,
-            // since pending items are in the dynamic rendering area (not <Static>).
-            setPendingRetryErrorItem({
-                type: 'error',
-                text: parseAndFormatApiError(eventValue.error, config.getContentGeneratorConfig()?.authType),
-                hint: retryHint,
-            });
-        }
-        setThought(null); // Reset thought when there's an error
-    }, [
-        addItem,
-        pendingHistoryItemRef,
-        setPendingHistoryItem,
-        setPendingRetryErrorItem,
-        config,
-        setThought,
-        clearRetryCountdown,
-    ]);
-    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 image prohibited content.',
-            [FinishReason.NO_IMAGE]: 'Response stopped due to no image.',
-        };
-        const message = finishReasonMessages[finishReason];
-        if (message) {
-            addItem({
-                type: 'info',
-                text: `⚠️  ${message}`,
-            }, userMessageTimestamp);
-        }
-        // Only clear auto-retry countdown errors (those with active timer)
-        if (retryCountdownTimerRef.current) {
-            clearRetryCountdown();
-        }
-    }, [addItem, clearRetryCountdown]);
-    const handleChatCompressionEvent = useCallback((eventValue, userMessageTimestamp) => {
-        if (pendingHistoryItemRef.current) {
-            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-            setPendingHistoryItem(null);
-        }
-        return addItem({
-            type: 'info',
-            text: `IMPORTANT: This conversation approached the input token limit for ${config.getModel()}. ` +
-                `A compressed context will be sent for future messages (compressed from: ` +
-                `${eventValue?.originalTokenCount ?? 'unknown'} to ` +
-                `${eventValue?.newTokenCount ?? 'unknown'} tokens).`,
-        }, Date.now());
-    }, [addItem, config, pendingHistoryItemRef, setPendingHistoryItem]);
-    const handleMaxSessionTurnsEvent = useCallback(() => addItem({
-        type: 'info',
-        text: `The session has reached the maximum number of turns: ${config.getMaxSessionTurns()}. ` +
-            `Please update this limit in your setting.json file.`,
-    }, Date.now()), [addItem, config]);
-    const handleSessionTokenLimitExceededEvent = useCallback((value) => addItem({
-        type: 'error',
-        text: `🚫 Session token limit exceeded: ${value.currentTokens.toLocaleString()} tokens > ${value.limit.toLocaleString()} limit.\n\n` +
-            `💡 Solutions:\n` +
-            `   • Start a new session: Use /clear command\n` +
-            `   • Increase limit: Add "sessionTokenLimit": (e.g., 128000) to your settings.json\n` +
-            `   • Compress history: Use /compress command to compress history`,
-    }, Date.now()), [addItem]);
-    const handleLoopDetectionConfirmation = useCallback((result) => {
-        setLoopDetectionConfirmationRequest(null);
-        if (result.userSelection === 'disable') {
-            config.getGeminiClient().getLoopDetectionService().disableForSession();
-            addItem({
-                type: 'info',
-                text: `Loop detection has been disabled for this session. Please try your request again.`,
-            }, Date.now());
-        }
-        else {
-            addItem({
-                type: 'info',
-                text: `A potential loop was detected. This can happen due to repetitive tool calls or other model behavior. The request has been halted.`,
-            }, Date.now());
-        }
-    }, [config, addItem]);
-    const handleLoopDetectedEvent = useCallback(() => {
-        // Show the confirmation dialog to choose whether to disable loop detection
-        setLoopDetectionConfirmationRequest({
-            onComplete: handleLoopDetectionConfirmation,
-        });
-    }, [handleLoopDetectionConfirmation]);
-    const handleUserPromptSubmitBlockedEvent = useCallback((value, userMessageTimestamp) => {
-        if (pendingHistoryItemRef.current) {
-            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-            setPendingHistoryItem(null);
-        }
-        addItem({
-            type: 'user_prompt_submit_blocked',
-            reason: value.reason,
-            originalPrompt: value.originalPrompt,
-        }, userMessageTimestamp);
-    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem]);
-    const handleStopHookLoopEvent = useCallback((value, userMessageTimestamp) => {
-        if (pendingHistoryItemRef.current) {
-            addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-            setPendingHistoryItem(null);
-        }
-        addItem({
-            type: 'stop_hook_loop',
-            iterationCount: value.iterationCount,
-            reasons: value.reasons,
-            stopHookCount: value.stopHookCount,
-        }, userMessageTimestamp);
-    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem]);
-    const processGeminiStreamEvents = useCallback(async (stream, userMessageTimestamp, signal) => {
-        let geminiMessageBuffer = '';
-        let thoughtBuffer = '';
-        const toolCallRequests = [];
-        for await (const event of stream) {
-            switch (event.type) {
-                case ServerGeminiEventType.Thought:
-                    // If the thought has a subject, it's a discrete status update rather than
-                    // a streamed textual thought, so we update the thought state directly.
-                    if (event.value.subject) {
-                        setThought(event.value);
-                    }
-                    else {
-                        thoughtBuffer = handleThoughtEvent(event.value, thoughtBuffer, userMessageTimestamp);
-                    }
-                    break;
-                case ServerGeminiEventType.Content:
-                    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.ChatCompressed:
-                    handleChatCompressionEvent(event.value, userMessageTimestamp);
-                    break;
-                case ServerGeminiEventType.ToolCallConfirmation:
-                case ServerGeminiEventType.ToolCallResponse:
-                    // do nothing
-                    break;
-                case ServerGeminiEventType.MaxSessionTurns:
-                    handleMaxSessionTurnsEvent();
-                    break;
-                case ServerGeminiEventType.SessionTokenLimitExceeded:
-                    handleSessionTokenLimitExceededEvent(event.value);
-                    break;
-                case ServerGeminiEventType.Finished:
-                    handleFinishedEvent(event, userMessageTimestamp);
-                    break;
-                case ServerGeminiEventType.Citation:
-                    handleCitationEvent(event.value, userMessageTimestamp);
-                    break;
-                case ServerGeminiEventType.LoopDetected:
-                    // handle later because we want to move pending history to history
-                    // before we add loop detected message to history
-                    loopDetectedRef.current = true;
-                    break;
-                case ServerGeminiEventType.Retry:
-                    // Clear any pending partial content from the failed attempt
-                    if (pendingHistoryItemRef.current) {
-                        setPendingHistoryItem(null);
-                    }
-                    // Show retry info if available (rate-limit / throttling errors)
-                    if (event.retryInfo) {
-                        startRetryCountdown(event.retryInfo);
-                    }
-                    else {
-                        // The retry attempt is starting now, so any prior retry UI is stale.
-                        clearRetryCountdown();
-                    }
-                    break;
-                case ServerGeminiEventType.HookSystemMessage:
-                    // Display system message from Stop hooks with "Stop says:" prefix
-                    // First commit any pending AI response to ensure correct ordering
-                    if (pendingHistoryItemRef.current) {
-                        addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-                        setPendingHistoryItem(null);
-                    }
-                    addItem({
-                        type: 'stop_hook_system_message',
-                        message: event.value,
-                    }, userMessageTimestamp);
-                    break;
-                case ServerGeminiEventType.UserPromptSubmitBlocked:
-                    handleUserPromptSubmitBlockedEvent(event.value, userMessageTimestamp);
-                    break;
-                case ServerGeminiEventType.StopHookLoop:
-                    handleStopHookLoopEvent(event.value, userMessageTimestamp);
-                    break;
-                default: {
-                    // enforces exhaustive switch-case
-                    const unreachable = event;
-                    return unreachable;
-                }
-            }
-        }
-        if (toolCallRequests.length > 0) {
-            scheduleToolCalls(toolCallRequests, signal);
-        }
-        return StreamProcessingStatus.Completed;
-    }, [
-        handleContentEvent,
-        handleThoughtEvent,
-        handleUserCancelledEvent,
-        handleErrorEvent,
-        scheduleToolCalls,
-        handleChatCompressionEvent,
-        handleFinishedEvent,
-        handleMaxSessionTurnsEvent,
-        handleSessionTokenLimitExceededEvent,
-        handleCitationEvent,
-        startRetryCountdown,
-        clearRetryCountdown,
-        setThought,
-        pendingHistoryItemRef,
-        setPendingHistoryItem,
-        handleUserPromptSubmitBlockedEvent,
-        handleStopHookLoopEvent,
-        addItem,
-    ]);
-    const submitQuery = useCallback(async (query, submitType = SendMessageType.UserQuery, prompt_id) => {
-        const allowConcurrentBtwDuringResponse = submitType === SendMessageType.UserQuery &&
-            streamingState === StreamingState.Responding &&
-            typeof query === 'string' &&
-            isBtwCommand(query);
-        // Prevent concurrent executions of submitQuery, but allow continuations
-        // which are part of the same logical flow (tool responses)
-        if (isSubmittingQueryRef.current &&
-            submitType !== SendMessageType.ToolResult &&
-            !allowConcurrentBtwDuringResponse) {
-            return;
-        }
-        if ((streamingState === StreamingState.Responding ||
-            streamingState === StreamingState.WaitingForConfirmation) &&
-            submitType !== SendMessageType.ToolResult &&
-            !allowConcurrentBtwDuringResponse)
-            return;
-        // Set the flag to indicate we're now executing
-        isSubmittingQueryRef.current = true;
-        const userMessageTimestamp = Date.now();
-        // Reset quota error flag when starting a new query (not a continuation)
-        if (submitType !== SendMessageType.ToolResult &&
-            !allowConcurrentBtwDuringResponse) {
-            setModelSwitchedFromQuotaError(false);
-            // Commit any pending retry error to history (without hint) since the
-            // user is starting a new conversation turn.
-            // Clear both countdown-based errors AND static errors (those without
-            // an active countdown timer, e.g. "Press Ctrl+Y to retry").
-            if (pendingRetryCountdownItemRef.current ||
-                pendingRetryErrorItemRef.current) {
-                clearRetryCountdown();
-            }
-        }
-        const abortController = new AbortController();
-        const abortSignal = abortController.signal;
-        // Keep the main stream's cancellation state intact while /btw is handled
-        // in parallel. The side-question can use its own local abort signal.
-        if (!allowConcurrentBtwDuringResponse) {
-            abortControllerRef.current = abortController;
-            turnCancelledRef.current = false;
-        }
-        if (!prompt_id) {
-            prompt_id = config.getSessionId() + '########' + getPromptCount();
-        }
-        return promptIdContext.run(prompt_id, async () => {
-            const { queryToSend, shouldProceed } = submitType === SendMessageType.Retry
-                ? { queryToSend: query, shouldProceed: true }
-                : await prepareQueryForGemini(query, userMessageTimestamp, abortSignal, prompt_id);
-            if (!shouldProceed || queryToSend === null) {
-                isSubmittingQueryRef.current = false;
-                return;
-            }
-            // Check image format support for non-continuations
-            if (submitType === SendMessageType.UserQuery ||
-                submitType === SendMessageType.Cron) {
-                const formatCheck = checkImageFormatsSupport(queryToSend);
-                if (formatCheck.hasUnsupportedFormats) {
-                    addItem({
-                        type: MessageType.INFO,
-                        text: getUnsupportedImageFormatWarning(),
-                    }, userMessageTimestamp);
-                }
-            }
-            const finalQueryToSend = queryToSend;
-            lastPromptRef.current = finalQueryToSend;
-            lastPromptErroredRef.current = false;
-            if (submitType === SendMessageType.UserQuery ||
-                submitType === SendMessageType.Cron) {
-                // trigger new prompt event for session stats in CLI
-                startNewPrompt();
-                // log user prompt event for telemetry, only text prompts for now
-                if (typeof queryToSend === 'string') {
-                    logUserPrompt(config, new UserPromptEvent(queryToSend.length, prompt_id, config.getContentGeneratorConfig()?.authType, queryToSend));
-                }
-                // Reset thought when starting a new prompt
-                setThought(null);
-            }
-            if (submitType === SendMessageType.Retry) {
-                logUserRetry(config, new UserRetryEvent(prompt_id));
-            }
-            setIsResponding(true);
-            setInitError(null);
-            try {
-                const stream = geminiClient.sendMessageStream(finalQueryToSend, abortSignal, prompt_id, { type: submitType });
-                const processingStatus = await processGeminiStreamEvents(stream, userMessageTimestamp, abortSignal);
-                if (processingStatus === StreamProcessingStatus.UserCancelled) {
-                    isSubmittingQueryRef.current = false;
-                    return;
-                }
-                if (pendingHistoryItemRef.current) {
-                    addItem(pendingHistoryItemRef.current, userMessageTimestamp);
-                    setPendingHistoryItem(null);
-                }
-                // Only clear auto-retry countdown errors (those with an active timer).
-                // Do NOT clear static error+hint from handleErrorEvent — those should
-                // remain visible until the user presses Ctrl+Y to retry or starts
-                // a new conversation turn (cleared in submitQuery).
-                if (retryCountdownTimerRef.current) {
-                    clearRetryCountdown();
-                }
-                if (loopDetectedRef.current) {
-                    loopDetectedRef.current = false;
-                    handleLoopDetectedEvent();
-                }
-            }
-            catch (error) {
-                if (error instanceof UnauthorizedError) {
-                    onAuthError('Session expired or is unauthorized.');
-                }
-                else if (!isNodeError(error) || error.name !== 'AbortError') {
-                    lastPromptErroredRef.current = true;
-                    const retryHint = t('Press Ctrl+Y to retry');
-                    // Store error with hint as a pending item (same as handleErrorEvent)
-                    setPendingRetryErrorItem({
-                        type: 'error',
-                        text: parseAndFormatApiError(getErrorMessage(error) || 'Unknown error', config.getContentGeneratorConfig()?.authType),
-                        hint: retryHint,
-                    });
-                }
-            }
-            finally {
-                setIsResponding(false);
-                isSubmittingQueryRef.current = false;
-            }
-        });
-    }, [
-        streamingState,
-        setModelSwitchedFromQuotaError,
-        prepareQueryForGemini,
-        processGeminiStreamEvents,
-        pendingHistoryItemRef,
-        addItem,
-        setPendingHistoryItem,
-        setInitError,
-        geminiClient,
-        onAuthError,
-        config,
-        startNewPrompt,
-        getPromptCount,
-        handleLoopDetectedEvent,
-        clearRetryCountdown,
-        pendingRetryCountdownItemRef,
-        pendingRetryErrorItemRef,
-        setPendingRetryErrorItem,
-    ]);
-    /**
-     * Retries the last failed prompt when the user presses Ctrl+Y.
-     *
-     * Activation conditions for Ctrl+Y shortcut:
-     * 1. ✅ The last request must have failed (lastPromptErroredRef.current === true)
-     * 2. ✅ Current streaming state must NOT be "Responding" (avoid interrupting ongoing stream)
-     * 3. ✅ Current streaming state must NOT be "WaitingForConfirmation" (avoid conflicting with tool confirmation flow)
-     * 4. ✅ There must be a stored lastPrompt in lastPromptRef.current
-     *
-     * When conditions are not met:
-     * - If streaming is active (Responding/WaitingForConfirmation): silently return without action
-     * - If no failed request exists: display "No failed request to retry." info message
-     *
-     * When conditions are met:
-     * - Clears any pending auto-retry countdown to avoid duplicate retries
-     * - Re-submits the last query with isRetry: true, reusing the same prompt_id
-     *
-     * This function is exposed via UIActionsContext and triggered by InputPrompt
-     * when the user presses Ctrl+Y (bound to Command.RETRY_LAST in keyBindings.ts).
-     */
-    const retryLastPrompt = useCallback(async () => {
-        // During a rate-limit retry countdown, skip the delay so the generator
-        // retries immediately — no abort/re-submit needed.
-        if (skipRetryDelayRef.current) {
-            skipRetryDelayRef.current();
-            skipRetryDelayRef.current = null;
-            clearRetryCountdown();
-            return;
-        }
-        if (streamingState === StreamingState.Responding ||
-            streamingState === StreamingState.WaitingForConfirmation) {
-            return;
-        }
-        const lastPrompt = lastPromptRef.current;
-        if (!lastPrompt || !lastPromptErroredRef.current) {
-            addItem({
-                type: MessageType.INFO,
-                text: t('No failed request to retry.'),
-            }, Date.now());
-            return;
-        }
-        clearRetryCountdown();
-        await submitQuery(lastPrompt, SendMessageType.Retry);
-    }, [streamingState, addItem, clearRetryCountdown, submitQuery]);
-    const handleApprovalModeChange = useCallback(async (newApprovalMode) => {
-        // Auto-approve pending tool calls when switching to auto-approval modes
-        if (newApprovalMode === ApprovalMode.YOLO ||
-            newApprovalMode === ApprovalMode.AUTO_EDIT) {
-            let awaitingApprovalCalls = toolCalls.filter((call) => call.status === 'awaiting_approval');
-            // For AUTO_EDIT mode, only approve edit tools (replace, write_file)
-            if (newApprovalMode === ApprovalMode.AUTO_EDIT) {
-                awaitingApprovalCalls = awaitingApprovalCalls.filter((call) => EDIT_TOOL_NAMES.has(call.request.name));
-            }
-            // Process pending tool calls sequentially to reduce UI chaos
-            for (const call of awaitingApprovalCalls) {
-                if (call.confirmationDetails?.onConfirm) {
-                    try {
-                        await call.confirmationDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-                    }
-                    catch (error) {
-                        debugLogger.error(`Failed to auto-approve tool call ${call.request.callId}:`, error);
-                    }
-                }
-            }
-        }
-    }, [toolCalls]);
-    const handleCompletedTools = useCallback(async (completedToolCallsFromScheduler) => {
-        if (isResponding) {
-            return;
-        }
-        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));
-        }
-        // Identify new, successful save_memory calls that we haven't processed yet.
-        const newSuccessfulMemorySaves = completedAndReadyToSubmitTools.filter((t) => t.request.name === 'save_memory' &&
-            t.status === 'success' &&
-            !processedMemoryToolsRef.current.has(t.request.callId));
-        if (newSuccessfulMemorySaves.length > 0) {
-            // Perform the refresh only if there are new ones.
-            void performMemoryRefresh();
-            // Mark them as processed so we don't do this again on the next render.
-            newSuccessfulMemorySaves.forEach((t) => processedMemoryToolsRef.current.add(t.request.callId));
-        }
-        const geminiTools = completedAndReadyToSubmitTools.filter((t) => !t.request.isClientInitiated);
-        if (geminiTools.length === 0) {
-            return;
-        }
-        // If all the tools were cancelled, don't submit a response to Gemini.
-        const allToolsCancelled = geminiTools.every((tc) => tc.status === 'cancelled');
-        if (allToolsCancelled) {
-            if (geminiClient) {
-                // We need to manually add the function responses to the history
-                // so the model knows the tools were cancelled.
-                const combinedParts = geminiTools.flatMap((toolCall) => toolCall.response.responseParts);
-                geminiClient.addHistory({
-                    role: 'user',
-                    parts: combinedParts,
-                });
-                // Report cancellation to arena (safety net — cancelOngoingRequest
-                config.getArenaAgentClient()?.reportCancelled();
-            }
-            const callIdsToMarkAsSubmitted = geminiTools.map((toolCall) => toolCall.request.callId);
-            markToolsAsSubmitted(callIdsToMarkAsSubmitted);
-            return;
-        }
-        const responsesToSend = geminiTools.flatMap((toolCall) => toolCall.response.responseParts);
-        const callIdsToMarkAsSubmitted = geminiTools.map((toolCall) => toolCall.request.callId);
-        const prompt_ids = geminiTools.map((toolCall) => toolCall.request.prompt_id);
-        markToolsAsSubmitted(callIdsToMarkAsSubmitted);
-        // Don't continue if model was switched due to quota error
-        if (modelSwitchedFromQuotaError) {
-            return;
-        }
-        // Mid-turn queue drain: inject queued user messages alongside tool
-        // results so the model sees them in the next API call.
-        // Skip if the turn was cancelled — messages stay in queue for next turn.
-        const drained = turnCancelledRef.current || abortControllerRef.current?.signal.aborted
-            ? []
-            : (midTurnDrainRef?.current?.() ?? []);
-        if (drained.length > 0) {
-            for (const msg of drained) {
-                responsesToSend.push({
-                    text: `\n[User message received during tool execution]: ${msg}`,
-                });
-                // Record in UI history so the transcript stays complete.
-                addItem({ type: MessageType.USER, text: msg }, Date.now());
-            }
-        }
-        submitQuery(responsesToSend, SendMessageType.ToolResult, prompt_ids[0]);
-    }, [
-        isResponding,
-        submitQuery,
-        markToolsAsSubmitted,
-        geminiClient,
-        performMemoryRefresh,
-        modelSwitchedFromQuotaError,
-        config,
-        midTurnDrainRef,
-        addItem,
-    ]);
-    const pendingHistoryItems = useMemo(() => [
-        pendingHistoryItem,
-        pendingRetryErrorItem,
-        pendingRetryCountdownItem,
-        pendingToolCallGroupDisplay,
-    ].filter((i) => i !== undefined && i !== null), [
-        pendingHistoryItem,
-        pendingRetryErrorItem,
-        pendingRetryCountdownItem,
-        pendingToolCallGroupDisplay,
-    ]);
-    useEffect(() => {
-        const saveRestorableToolCalls = async () => {
-            if (!config.getCheckpointingEnabled()) {
-                return;
-            }
-            const restorableToolCalls = toolCalls.filter((toolCall) => EDIT_TOOL_NAMES.has(toolCall.request.name) &&
-                toolCall.status === 'awaiting_approval');
-            if (restorableToolCalls.length > 0) {
-                const checkpointDir = storage.getProjectTempCheckpointsDir();
-                if (!checkpointDir) {
-                    return;
-                }
-                try {
-                    await fs.mkdir(checkpointDir, { recursive: true });
-                }
-                catch (error) {
-                    if (!isNodeError(error) || error.code !== 'EEXIST') {
-                        onDebugMessage(`Failed to create checkpoint directory: ${getErrorMessage(error)}`);
-                        return;
-                    }
-                }
-                for (const toolCall of restorableToolCalls) {
-                    const filePath = toolCall.request.args['file_path'];
-                    if (!filePath) {
-                        onDebugMessage(`Skipping restorable tool call due to missing file_path: ${toolCall.request.name}`);
-                        continue;
-                    }
-                    try {
-                        if (!gitService) {
-                            onDebugMessage(`Checkpointing is enabled but Git service is not available. Failed to create snapshot for ${filePath}. Ensure Git is installed and working properly.`);
-                            continue;
-                        }
-                        let commitHash;
-                        try {
-                            commitHash = await gitService.createFileSnapshot(`Snapshot for ${toolCall.request.name}`);
-                        }
-                        catch (error) {
-                            onDebugMessage(`Failed to create new snapshot: ${getErrorMessage(error)}. Attempting to use current commit.`);
-                        }
-                        if (!commitHash) {
-                            commitHash = await gitService.getCurrentCommitHash();
-                        }
-                        if (!commitHash) {
-                            onDebugMessage(`Failed to create snapshot for ${filePath}. Checkpointing may not be working properly. Ensure Git is installed and the project directory is accessible.`);
-                            continue;
-                        }
-                        const timestamp = new Date()
-                            .toISOString()
-                            .replace(/:/g, '-')
-                            .replace(/\./g, '_');
-                        const toolName = toolCall.request.name;
-                        const fileName = path.basename(filePath);
-                        const toolCallWithSnapshotFileName = `${timestamp}-${fileName}-${toolName}.json`;
-                        const clientHistory = await geminiClient?.getHistory();
-                        const toolCallWithSnapshotFilePath = path.join(checkpointDir, toolCallWithSnapshotFileName);
-                        await fs.writeFile(toolCallWithSnapshotFilePath, JSON.stringify({
-                            history,
-                            clientHistory,
-                            toolCall: {
-                                name: toolCall.request.name,
-                                args: toolCall.request.args,
-                            },
-                            commitHash,
-                            filePath,
-                        }, null, 2));
-                    }
-                    catch (error) {
-                        onDebugMessage(`Failed to create checkpoint for ${filePath}: ${getErrorMessage(error)}. This may indicate a problem with Git or file system permissions.`);
-                    }
-                }
-            }
-        };
-        saveRestorableToolCalls();
-    }, [
-        toolCalls,
-        config,
-        onDebugMessage,
-        gitService,
-        history,
-        geminiClient,
-        storage,
-    ]);
-    // ─── Cron scheduler integration ─────────────────────────
-    const cronQueueRef = useRef([]);
-    const [cronTrigger, setCronTrigger] = useState(0);
-    // Start the scheduler on mount, stop on unmount
-    useEffect(() => {
-        if (!config.isCronEnabled())
-            return;
-        const scheduler = config.getCronScheduler();
-        scheduler.start((job) => {
-            cronQueueRef.current.push(job.prompt);
-            setCronTrigger((n) => n + 1);
-        });
-        return () => {
-            const summary = scheduler.getExitSummary();
-            scheduler.stop();
-            if (summary) {
-                process.stderr.write(summary + '\n');
-            }
-        };
-    }, [config]);
-    // When idle, drain the cron queue one prompt at a time
-    useEffect(() => {
-        if (streamingState === StreamingState.Idle &&
-            cronQueueRef.current.length > 0) {
-            const prompt = cronQueueRef.current.shift();
-            submitQuery(prompt, SendMessageType.Cron);
-        }
-    }, [streamingState, submitQuery, cronTrigger]);
-    return {
-        streamingState,
-        submitQuery,
-        initError,
-        pendingHistoryItems,
-        thought,
-        cancelOngoingRequest,
-        retryLastPrompt,
-        pendingToolCalls: toolCalls,
-        handleApprovalModeChange,
-        activePtyId,
-        loopDetectionConfirmationRequest,
-    };
-};
-//# sourceMappingURL=useGeminiStream.js.map