@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/hooks/useRepeatedKeyPress.js

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useRef, useCallback, useEffect, useState } from 'react';
+export function useRepeatedKeyPress(options) {
+    const [pressCount, setPressCount] = useState(0);
+    const pressCountRef = useRef(0);
+    const timerRef = useRef(null);
+    // To avoid stale closures
+    const optionsRef = useRef(options);
+    useEffect(() => {
+        optionsRef.current = options;
+    }, [options]);
+    const resetCount = useCallback(() => {
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+            timerRef.current = null;
+        }
+        if (pressCountRef.current > 0) {
+            pressCountRef.current = 0;
+            setPressCount(0);
+            optionsRef.current.onReset?.();
+        }
+    }, []);
+    const handlePress = useCallback(() => {
+        const newCount = pressCountRef.current + 1;
+        pressCountRef.current = newCount;
+        setPressCount(newCount);
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+        }
+        timerRef.current = setTimeout(() => {
+            pressCountRef.current = 0;
+            setPressCount(0);
+            timerRef.current = null;
+            optionsRef.current.onReset?.();
+        }, optionsRef.current.windowMs);
+        optionsRef.current.onRepeat?.(newCount);
+        return newCount;
+    }, []);
+    useEffect(() => () => {
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+        }
+    }, []);
+    return { pressCount, handlePress, resetCount };
+}

package/dist/ui/hooks/useReverseSearchCompletion.js

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useMemo, useCallback, useRef } from 'react';
+import { useCompletion } from './useCompletion.js';
+function useDebouncedValue(value, delay = 200) {
+    const [debounced, setDebounced] = useState(value);
+    useEffect(() => {
+        const handle = setTimeout(() => setDebounced(value), delay);
+        return () => clearTimeout(handle);
+    }, [value, delay]);
+    return debounced;
+}
+export function useReverseSearchCompletion(buffer, history, reverseSearchActive) {
+    const { suggestions, activeSuggestionIndex, visibleStartIndex, isLoadingSuggestions, setSuggestions, setActiveSuggestionIndex, resetCompletionState, navigateUp, navigateDown, setVisibleStartIndex, } = useCompletion();
+    const debouncedQuery = useDebouncedValue(buffer.text, 100);
+    // incremental search
+    const prevQueryRef = useRef('');
+    const prevMatchesRef = useRef([]);
+    // Clear incremental cache when activating reverse search
+    useEffect(() => {
+        if (reverseSearchActive) {
+            prevQueryRef.current = '';
+            prevMatchesRef.current = [];
+        }
+    }, [reverseSearchActive]);
+    // Also clear cache when history changes so new items are considered
+    useEffect(() => {
+        prevQueryRef.current = '';
+        prevMatchesRef.current = [];
+    }, [history]);
+    const searchHistory = useCallback((query, items) => {
+        const out = [];
+        for (let i = 0; i < items.length; i++) {
+            const cmd = items[i];
+            const idx = cmd.toLowerCase().indexOf(query);
+            if (idx !== -1) {
+                out.push({ label: cmd, value: cmd, matchedIndex: idx });
+            }
+        }
+        return out;
+    }, []);
+    const matches = useMemo(() => {
+        if (!reverseSearchActive)
+            return [];
+        if (debouncedQuery.length === 0)
+            return history.map((cmd) => ({
+                label: cmd,
+                value: cmd,
+                matchedIndex: -1,
+            }));
+        const query = debouncedQuery.toLowerCase();
+        const canUseCache = prevQueryRef.current &&
+            query.startsWith(prevQueryRef.current) &&
+            prevMatchesRef.current.length > 0;
+        const source = canUseCache
+            ? prevMatchesRef.current.map((m) => m.value)
+            : history;
+        return searchHistory(query, source);
+    }, [debouncedQuery, history, reverseSearchActive, searchHistory]);
+    useEffect(() => {
+        if (!reverseSearchActive) {
+            resetCompletionState();
+            return;
+        }
+        setSuggestions(matches);
+        const hasAny = matches.length > 0;
+        setActiveSuggestionIndex(hasAny ? 0 : -1);
+        setVisibleStartIndex(0);
+        prevQueryRef.current = debouncedQuery.toLowerCase();
+        prevMatchesRef.current = matches;
+    }, [
+        debouncedQuery,
+        matches,
+        reverseSearchActive,
+        setSuggestions,
+        setActiveSuggestionIndex,
+        setVisibleStartIndex,
+        resetCompletionState,
+    ]);
+    const showSuggestions = reverseSearchActive && (isLoadingSuggestions || suggestions.length > 0);
+    const handleAutocomplete = useCallback((i) => {
+        if (i < 0 || i >= suggestions.length)
+            return;
+        buffer.setText(suggestions[i].value);
+        resetCompletionState();
+    }, [buffer, suggestions, resetCompletionState]);
+    return {
+        suggestions,
+        activeSuggestionIndex,
+        visibleStartIndex,
+        showSuggestions,
+        isLoadingSuggestions,
+        navigateUp,
+        navigateDown,
+        handleAutocomplete,
+        resetCompletionState,
+    };
+}

package/dist/ui/hooks/useRewind.js

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useCallback } from 'react';
+import { calculateTurnStats, calculateRewindImpact, } from '../utils/rewindFileOps.js';
+export function useRewind(conversation) {
+    const [selectedMessageId, setSelectedMessageId] = useState(null);
+    const [confirmationStats, setConfirmationStats] = useState(null);
+    const getStats = useCallback((userMessage) => calculateTurnStats(conversation, userMessage), [conversation]);
+    const selectMessage = useCallback((messageId) => {
+        const msg = conversation.messages.find((m) => m.id === messageId);
+        if (msg) {
+            setSelectedMessageId(messageId);
+            setConfirmationStats(calculateRewindImpact(conversation, msg));
+        }
+    }, [conversation]);
+    const clearSelection = useCallback(() => {
+        setSelectedMessageId(null);
+        setConfirmationStats(null);
+    }, []);
+    return {
+        selectedMessageId,
+        getStats,
+        confirmationStats,
+        selectMessage,
+        clearSelection,
+    };
+}

package/dist/ui/hooks/useRunEventNotifications.js

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect, useMemo, useRef } from 'react';
+import { StreamingState, } from '../types.js';
+import { getPendingAttentionNotification } from '../utils/pendingAttentionNotification.js';
+import { buildRunEventNotificationContent, notifyViaTerminal, } from '../../utils/terminalNotifications.js';
+const ATTENTION_NOTIFICATION_COOLDOWN_MS = 20_000;
+export function useRunEventNotifications({ notificationsEnabled, notificationMethod, isFocused, hasReceivedFocusEvent, streamingState, hasPendingActionRequired, pendingHistoryItems, commandConfirmationRequest, authConsentRequest, permissionConfirmationRequest, hasConfirmUpdateExtensionRequests, hasLoopDetectionConfirmationRequest, }) {
+    const pendingAttentionNotification = useMemo(() => getPendingAttentionNotification(pendingHistoryItems, commandConfirmationRequest, authConsentRequest, permissionConfirmationRequest, hasConfirmUpdateExtensionRequests, hasLoopDetectionConfirmationRequest), [
+        pendingHistoryItems,
+        commandConfirmationRequest,
+        authConsentRequest,
+        permissionConfirmationRequest,
+        hasConfirmUpdateExtensionRequests,
+        hasLoopDetectionConfirmationRequest,
+    ]);
+    const hadPendingAttentionRef = useRef(false);
+    const previousFocusedRef = useRef(isFocused);
+    const previousStreamingStateRef = useRef(streamingState);
+    const lastSentAttentionNotificationRef = useRef(null);
+    useEffect(() => {
+        if (!notificationsEnabled) {
+            return;
+        }
+        const wasFocused = previousFocusedRef.current;
+        previousFocusedRef.current = isFocused;
+        const hasPendingAttention = pendingAttentionNotification !== null;
+        const hadPendingAttention = hadPendingAttentionRef.current;
+        hadPendingAttentionRef.current = hasPendingAttention;
+        if (!hasPendingAttention) {
+            lastSentAttentionNotificationRef.current = null;
+            return;
+        }
+        const shouldSuppressForFocus = hasReceivedFocusEvent && isFocused;
+        if (shouldSuppressForFocus) {
+            return;
+        }
+        const justEnteredAttentionState = !hadPendingAttention;
+        const justLostFocus = wasFocused && !isFocused;
+        const now = Date.now();
+        const currentKey = pendingAttentionNotification.key;
+        const lastSent = lastSentAttentionNotificationRef.current;
+        const keyChanged = !lastSent || lastSent.key !== currentKey;
+        const onCooldown = !!lastSent &&
+            lastSent.key === currentKey &&
+            now - lastSent.sentAt < ATTENTION_NOTIFICATION_COOLDOWN_MS;
+        const shouldNotifyByStateChange = hasReceivedFocusEvent
+            ? justEnteredAttentionState || justLostFocus || keyChanged
+            : justEnteredAttentionState || keyChanged;
+        if (!shouldNotifyByStateChange || onCooldown) {
+            return;
+        }
+        lastSentAttentionNotificationRef.current = {
+            key: currentKey,
+            sentAt: now,
+        };
+        void notifyViaTerminal(notificationsEnabled, buildRunEventNotificationContent(pendingAttentionNotification.event), notificationMethod);
+    }, [
+        isFocused,
+        hasReceivedFocusEvent,
+        notificationsEnabled,
+        notificationMethod,
+        pendingAttentionNotification,
+    ]);
+    useEffect(() => {
+        if (!notificationsEnabled) {
+            return;
+        }
+        const previousStreamingState = previousStreamingStateRef.current;
+        previousStreamingStateRef.current = streamingState;
+        const justCompletedTurn = previousStreamingState === StreamingState.Responding &&
+            streamingState === StreamingState.Idle;
+        const shouldSuppressForFocus = hasReceivedFocusEvent && isFocused;
+        if (!justCompletedTurn ||
+            shouldSuppressForFocus ||
+            hasPendingActionRequired) {
+            return;
+        }
+        void notifyViaTerminal(notificationsEnabled, buildRunEventNotificationContent({
+            type: 'session_complete',
+            detail: 'Gemini CLI finished responding.',
+        }), notificationMethod);
+    }, [
+        streamingState,
+        isFocused,
+        hasReceivedFocusEvent,
+        notificationsEnabled,
+        notificationMethod,
+        hasPendingActionRequired,
+    ]);
+}

package/dist/ui/hooks/useSearchBuffer.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useTextBuffer, } from '../components/shared/text-buffer.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+const MIN_VIEWPORT_WIDTH = 20;
+const VIEWPORT_WIDTH_OFFSET = 8;
+export function useSearchBuffer({ initialText = '', onChange, }) {
+    const { mainAreaWidth } = useUIState();
+    const viewportWidth = Math.max(MIN_VIEWPORT_WIDTH, mainAreaWidth - VIEWPORT_WIDTH_OFFSET);
+    return useTextBuffer({
+        initialText,
+        initialCursorOffset: initialText.length,
+        viewport: {
+            width: viewportWidth,
+            height: 1,
+        },
+        singleLine: true,
+        onChange,
+    });
+}

package/dist/ui/hooks/useSelectionList.js

@@ -0,0 +1,317 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useReducer, useRef, useEffect, useCallback } from 'react';
+import { useKeypress } from './useKeypress.js';
+import { Command } from '../key/keyMatchers.js';
+import { debugLogger } from '@google/gemini-cli-core';
+import { useKeyMatchers } from './useKeyMatchers.js';
+const NUMBER_INPUT_TIMEOUT_MS = 1000;
+/**
+ * Helper function to find the next enabled index in a given direction, supporting wrapping.
+ */
+const findNextValidIndex = (currentIndex, direction, items, wrapAround = true) => {
+    const len = items.length;
+    if (len === 0)
+        return currentIndex;
+    let nextIndex = currentIndex;
+    const step = direction === 'down' ? 1 : -1;
+    for (let i = 0; i < len; i++) {
+        const candidateIndex = nextIndex + step;
+        if (wrapAround) {
+            // Calculate the next index, wrapping around if necessary.
+            // We add `len` before the modulo to ensure a positive result in JS for negative steps.
+            nextIndex = (candidateIndex + len) % len;
+        }
+        else {
+            if (candidateIndex < 0 || candidateIndex >= len) {
+                // Out of bounds and wrapping is disabled
+                return currentIndex;
+            }
+            nextIndex = candidateIndex;
+        }
+        if (!items[nextIndex]?.disabled) {
+            return nextIndex;
+        }
+        if (!wrapAround) {
+            // If the item is disabled and we're not wrapping, we continue searching
+            // in the same direction, but we must stop if we hit the bounds.
+            if ((direction === 'down' && nextIndex === len - 1) ||
+                (direction === 'up' && nextIndex === 0)) {
+                return currentIndex;
+            }
+        }
+    }
+    // If all items are disabled, return the original index
+    return currentIndex;
+};
+const computeInitialIndex = (initialIndex, items, initialKey) => {
+    if (items.length === 0) {
+        return 0;
+    }
+    if (initialKey !== undefined) {
+        for (let i = 0; i < items.length; i++) {
+            if (items[i].key === initialKey && !items[i].disabled) {
+                return i;
+            }
+        }
+    }
+    let targetIndex = initialIndex;
+    if (targetIndex < 0 || targetIndex >= items.length) {
+        targetIndex = 0;
+    }
+    if (items[targetIndex]?.disabled) {
+        const nextValid = findNextValidIndex(targetIndex, 'down', items, true);
+        targetIndex = nextValid;
+    }
+    return targetIndex;
+};
+function selectionListReducer(state, action) {
+    switch (action.type) {
+        case 'SET_ACTIVE_INDEX': {
+            const { index } = action.payload;
+            const { items } = state;
+            // Only update if index actually changed and is valid
+            if (index === state.activeIndex) {
+                return state;
+            }
+            if (index >= 0 && index < items.length) {
+                return { ...state, activeIndex: index, pendingHighlight: true };
+            }
+            return state;
+        }
+        case 'MOVE_UP': {
+            const { items, wrapAround } = state;
+            const newIndex = findNextValidIndex(state.activeIndex, 'up', items, wrapAround);
+            if (newIndex !== state.activeIndex) {
+                return { ...state, activeIndex: newIndex, pendingHighlight: true };
+            }
+            return state;
+        }
+        case 'MOVE_DOWN': {
+            const { items, wrapAround } = state;
+            const newIndex = findNextValidIndex(state.activeIndex, 'down', items, wrapAround);
+            if (newIndex !== state.activeIndex) {
+                return { ...state, activeIndex: newIndex, pendingHighlight: true };
+            }
+            return state;
+        }
+        case 'SELECT_CURRENT': {
+            return { ...state, pendingSelect: true };
+        }
+        case 'INITIALIZE': {
+            const { initialIndex, items, wrapAround } = action.payload;
+            const activeKey = initialIndex === state.initialIndex
+                ? state.items[state.activeIndex]?.key
+                : undefined;
+            // We don't need to check for equality here anymore as it is handled in the effect
+            const targetIndex = computeInitialIndex(initialIndex, items, activeKey);
+            return {
+                ...state,
+                items,
+                initialIndex,
+                activeIndex: targetIndex,
+                pendingHighlight: false,
+                wrapAround,
+            };
+        }
+        case 'CLEAR_PENDING_FLAGS': {
+            return {
+                ...state,
+                pendingHighlight: false,
+                pendingSelect: false,
+            };
+        }
+        default: {
+            const exhaustiveCheck = action;
+            debugLogger.warn(`Unknown selection list action: ${exhaustiveCheck}`);
+            return state;
+        }
+    }
+}
+function areBaseItemsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].key !== b[i].key || a[i].disabled !== b[i].disabled) {
+            return false;
+        }
+    }
+    return true;
+}
+function toBaseItems(items) {
+    return items.map(({ key, disabled }) => ({ key, disabled }));
+}
+/**
+ * A headless hook that provides keyboard navigation and selection logic
+ * for list-based selection components like radio buttons and menus.
+ *
+ * Features:
+ * - Keyboard navigation with j/k and arrow keys
+ * - Selection with Enter key
+ * - Numeric quick selection (when showNumbers is true)
+ * - Handles disabled items (skips them during navigation)
+ * - Wrapping navigation (last to first, first to last)
+ */
+export function useSelectionList({ items, initialIndex = 0, onSelect, onHighlight, isFocused = true, showNumbers = false, wrapAround = true, focusKey, priority, }) {
+    const keyMatchers = useKeyMatchers();
+    const baseItems = toBaseItems(items);
+    const [state, dispatch] = useReducer(selectionListReducer, {
+        activeIndex: computeInitialIndex(initialIndex, baseItems),
+        initialIndex,
+        pendingHighlight: false,
+        pendingSelect: false,
+        items: baseItems,
+        wrapAround,
+    });
+    const numberInputRef = useRef('');
+    const numberInputTimer = useRef(null);
+    const prevBaseItemsRef = useRef(baseItems);
+    const prevInitialIndexRef = useRef(initialIndex);
+    const prevWrapAroundRef = useRef(wrapAround);
+    const lastProcessedFocusKeyRef = useRef(undefined);
+    // Handle programmatic focus changes via focusKey
+    useEffect(() => {
+        if (focusKey === undefined) {
+            lastProcessedFocusKeyRef.current = undefined;
+            return;
+        }
+        if (focusKey === lastProcessedFocusKeyRef.current)
+            return;
+        const index = items.findIndex((item) => item.key === focusKey && !item.disabled);
+        if (index !== -1) {
+            lastProcessedFocusKeyRef.current = focusKey;
+            dispatch({ type: 'SET_ACTIVE_INDEX', payload: { index } });
+        }
+    }, [focusKey, items]);
+    // Initialize/synchronize state when initialIndex or items change
+    useEffect(() => {
+        const baseItemsChanged = !areBaseItemsEqual(prevBaseItemsRef.current, baseItems);
+        const initialIndexChanged = prevInitialIndexRef.current !== initialIndex;
+        const wrapAroundChanged = prevWrapAroundRef.current !== wrapAround;
+        if (baseItemsChanged || initialIndexChanged || wrapAroundChanged) {
+            dispatch({
+                type: 'INITIALIZE',
+                payload: { initialIndex, items: baseItems, wrapAround },
+            });
+            prevBaseItemsRef.current = baseItems;
+            prevInitialIndexRef.current = initialIndex;
+            prevWrapAroundRef.current = wrapAround;
+        }
+    });
+    // Handle side effects based on state changes
+    useEffect(() => {
+        let needsClear = false;
+        if (state.pendingHighlight && items[state.activeIndex]) {
+            onHighlight?.(items[state.activeIndex].value);
+            needsClear = true;
+        }
+        if (state.pendingSelect && items[state.activeIndex]) {
+            const currentItem = items[state.activeIndex];
+            if (currentItem && !currentItem.disabled) {
+                onSelect(currentItem.value);
+            }
+            needsClear = true;
+        }
+        if (needsClear) {
+            dispatch({ type: 'CLEAR_PENDING_FLAGS' });
+        }
+    }, [
+        state.pendingHighlight,
+        state.pendingSelect,
+        state.activeIndex,
+        items,
+        onHighlight,
+        onSelect,
+    ]);
+    useEffect(() => () => {
+        if (numberInputTimer.current) {
+            clearTimeout(numberInputTimer.current);
+        }
+    }, []);
+    const itemsLength = items.length;
+    const handleKeypress = useCallback((key) => {
+        const { sequence } = key;
+        const isNumeric = showNumbers && /^[0-9]$/.test(sequence);
+        // Clear number input buffer on non-numeric key press
+        if (!isNumeric && numberInputTimer.current) {
+            clearTimeout(numberInputTimer.current);
+            numberInputRef.current = '';
+        }
+        if (keyMatchers[Command.DIALOG_NAVIGATION_UP](key)) {
+            dispatch({ type: 'MOVE_UP' });
+            return true;
+        }
+        if (keyMatchers[Command.DIALOG_NAVIGATION_DOWN](key)) {
+            dispatch({ type: 'MOVE_DOWN' });
+            return true;
+        }
+        if (keyMatchers[Command.RETURN](key)) {
+            dispatch({ type: 'SELECT_CURRENT' });
+            return true;
+        }
+        // Handle numeric input for quick selection
+        if (isNumeric) {
+            if (numberInputTimer.current) {
+                clearTimeout(numberInputTimer.current);
+            }
+            const newNumberInput = numberInputRef.current + sequence;
+            numberInputRef.current = newNumberInput;
+            const targetIndex = Number.parseInt(newNumberInput, 10) - 1;
+            // Single '0' is invalid (1-indexed)
+            if (newNumberInput === '0') {
+                numberInputTimer.current = setTimeout(() => {
+                    numberInputRef.current = '';
+                }, NUMBER_INPUT_TIMEOUT_MS);
+                return true;
+            }
+            if (targetIndex >= 0 && targetIndex < itemsLength) {
+                dispatch({
+                    type: 'SET_ACTIVE_INDEX',
+                    payload: { index: targetIndex },
+                });
+                // If the number can't be a prefix for another valid number, select immediately
+                const potentialNextNumber = Number.parseInt(newNumberInput + '0', 10);
+                if (potentialNextNumber > itemsLength) {
+                    dispatch({
+                        type: 'SELECT_CURRENT',
+                    });
+                    numberInputRef.current = '';
+                }
+                else {
+                    // Otherwise wait for more input or timeout
+                    numberInputTimer.current = setTimeout(() => {
+                        dispatch({
+                            type: 'SELECT_CURRENT',
+                        });
+                        numberInputRef.current = '';
+                    }, NUMBER_INPUT_TIMEOUT_MS);
+                }
+            }
+            else {
+                // Number is out of bounds
+                numberInputRef.current = '';
+            }
+            return true;
+        }
+        return false;
+    }, [dispatch, itemsLength, showNumbers, keyMatchers]);
+    useKeypress(handleKeypress, {
+        isActive: !!(isFocused && itemsLength > 0),
+        priority,
+    });
+    const setActiveIndex = (index) => {
+        dispatch({
+            type: 'SET_ACTIVE_INDEX',
+            payload: { index },
+        });
+    };
+    return {
+        activeIndex: state.activeIndex,
+        setActiveIndex,
+    };
+}

package/dist/ui/hooks/useSessionBrowser.js

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useCallback } from 'react';
+import path from 'node:path';
+import { coreEvents, convertSessionToClientHistory, uiTelemetryService, loadConversationRecord, } from '@google/gemini-cli-core';
+import { convertSessionToHistoryFormats, } from '../../utils/sessionUtils.js';
+export { convertSessionToHistoryFormats };
+export const useSessionBrowser = (config, onLoadHistory) => {
+    const [isSessionBrowserOpen, setIsSessionBrowserOpen] = useState(false);
+    return {
+        isSessionBrowserOpen,
+        openSessionBrowser: useCallback(() => {
+            setIsSessionBrowserOpen(true);
+        }, []),
+        closeSessionBrowser: useCallback(() => {
+            setIsSessionBrowserOpen(false);
+        }, []),
+        /**
+         * Loads a conversation by ID, and reinitializes the chat recording service with it.
+         */
+        handleResumeSession: useCallback(async (session) => {
+            try {
+                const chatsDir = path.join(config.storage.getProjectTempDir(), 'chats');
+                const fileName = session.fileName;
+                const originalFilePath = path.join(chatsDir, fileName);
+                // Load up the conversation.
+                const conversation = await loadConversationRecord(originalFilePath);
+                if (!conversation) {
+                    throw new Error(`Failed to parse conversation from ${originalFilePath}`);
+                }
+                // Use the old session's ID to continue it.
+                const existingSessionId = conversation.sessionId;
+                config.setSessionId(existingSessionId);
+                uiTelemetryService.hydrate(conversation);
+                const resumedSessionData = {
+                    conversation,
+                    filePath: originalFilePath,
+                };
+                // We've loaded it; tell the UI about it.
+                setIsSessionBrowserOpen(false);
+                const historyData = convertSessionToHistoryFormats(conversation.messages);
+                await onLoadHistory(historyData.uiHistory, convertSessionToClientHistory(conversation.messages), resumedSessionData);
+            }
+            catch (error) {
+                coreEvents.emitFeedback('error', 'Error resuming session:', error);
+                setIsSessionBrowserOpen(false);
+            }
+        }, [config, onLoadHistory]),
+        /**
+         * Deletes a session by ID using the ChatRecordingService.
+         */
+        handleDeleteSession: useCallback(async (session) => {
+            // Note: Chat sessions are stored on disk using a filename derived from
+            // the session, e.g. "session-<timestamp>-<sessionIdPrefix>.json".
+            // The ChatRecordingService.deleteSession API expects this file basename
+            // (without the ".json" extension), not the full session UUID.
+            try {
+                const chatRecordingService = config
+                    .getGeminiClient()
+                    ?.getChatRecordingService();
+                if (chatRecordingService) {
+                    await chatRecordingService.deleteSession(session.file);
+                }
+            }
+            catch (error) {
+                coreEvents.emitFeedback('error', 'Error deleting session:', error);
+                throw error;
+            }
+        }, [config]),
+    };
+};