@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/components/ListeningIndicator.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+;
+const WAVE_CHARS = [' ', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+const ANIMATION_SPEED = 0.4;
+const BAR_PHASE_OFFSET = 1.2;
+const MAX_HEIGHT_MULTIPLIER = 3.5;
+const FRAME_INTERVAL_MS = 40; // ~33 FPS
+export const ListeningIndicator = ({ color, }) => {
+    const [tick, setTick] = useState(0);
+    const isScreenReaderEnabled = false;
+    useEffect(() => {
+        if (isScreenReaderEnabled)
+            return;
+        const timer = setInterval(() => setTick((t) => t + 1), FRAME_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [isScreenReaderEnabled]);
+    if (isScreenReaderEnabled) {
+        return _jsx(Text, { color: color, children: "Listening... " });
+    }
+    // Generate 3 bars for the wave
+    const bars = Array.from({ length: 3 }).map((_, i) => {
+        // Sine wave calculation to map to our 8 block characters (0-7)
+        const phase = tick * ANIMATION_SPEED + i * BAR_PHASE_OFFSET;
+        const height = Math.floor((Math.sin(phase) + 1) * MAX_HEIGHT_MULTIPLIER);
+        return WAVE_CHARS[Math.max(0, Math.min(7, height))] ?? ' ';
+    });
+    return _jsxs(Text, { color: color, children: [bars.join(''), " "] });
+};

package/dist/ui/components/LoadingIndicator.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { useStreamingContext } from '../contexts/StreamingContext.js';
+import { StreamingState } from '../types.js';
+import { GeminiRespondingSpinner } from './GeminiRespondingSpinner.js';
+import { formatDuration } from '../utils/formatters.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { isNarrowWidth } from '../utils/isNarrowWidth.js';
+import { INTERACTIVE_SHELL_WAITING_PHRASE } from '../hooks/usePhraseCycler.js';
+export const LoadingIndicator = ({ currentLoadingPhrase, wittyPhrase, showWit = false, elapsedTime, inline = false, rightContent, thought, thoughtLabel, showCancelAndTimer = true, forceRealStatusOnly = false, spinnerIcon, isHookActive = false, }) => {
+    const streamingState = useStreamingContext();
+    const { columns: terminalWidth } = useTerminalSize();
+    const isNarrow = isNarrowWidth(terminalWidth);
+    if (streamingState === StreamingState.Idle &&
+        !currentLoadingPhrase &&
+        !thought) {
+        return null;
+    }
+    // Prioritize the interactive shell waiting phrase over the thought subject
+    // because it conveys an actionable state for the user (waiting for input).
+    const primaryText = currentLoadingPhrase === INTERACTIVE_SHELL_WAITING_PHRASE
+        ? currentLoadingPhrase
+        : thought?.subject
+            ? (thoughtLabel ?? thought.subject)
+            : currentLoadingPhrase ||
+                (streamingState === StreamingState.Responding
+                    ? 'Thinking...'
+                    : undefined);
+    const cancelAndTimerContent = showCancelAndTimer && streamingState === StreamingState.Responding
+        ? `(esc to cancel, ${elapsedTime < 60 ? `${elapsedTime}s` : formatDuration(elapsedTime * 1000)})`
+        : null;
+    const wittyPhraseNode = !forceRealStatusOnly &&
+        showWit &&
+        wittyPhrase &&
+        primaryText === 'Thinking...' ? (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: theme.text.secondary, dimColor: true, italic: true, children: wittyPhrase }) })) : null;
+    if (inline) {
+        return (_jsxs(Box, { children: [_jsx(Box, { marginRight: 1, children: _jsx(GeminiRespondingSpinner, { nonRespondingDisplay: spinnerIcon ??
+                            (streamingState === StreamingState.WaitingForConfirmation
+                                ? '⠏'
+                                : ''), isHookActive: isHookActive }) }), primaryText && (_jsxs(Box, { flexShrink: 1, children: [_jsx(Text, { color: theme.text.primary, italic: true, wrap: "truncate-end", children: primaryText }), primaryText === INTERACTIVE_SHELL_WAITING_PHRASE && (_jsxs(Text, { color: theme.ui.active, italic: true, children: [' ', "(press tab to focus)"] }))] })), cancelAndTimerContent && (_jsxs(_Fragment, { children: [_jsx(Box, { flexShrink: 0, width: 1 }), _jsx(Text, { color: theme.text.secondary, children: cancelAndTimerContent })] })), wittyPhraseNode] }));
+    }
+    return (_jsxs(Box, { paddingLeft: 0, flexDirection: "column", children: [_jsxs(Box, { width: "100%", flexDirection: isNarrow ? 'column' : 'row', alignItems: isNarrow ? 'flex-start' : 'center', children: [_jsxs(Box, { children: [_jsx(Box, { marginRight: 1, children: _jsx(GeminiRespondingSpinner, { nonRespondingDisplay: spinnerIcon ??
+                                        (streamingState === StreamingState.WaitingForConfirmation
+                                            ? '⠏'
+                                            : ''), isHookActive: isHookActive }) }), primaryText && (_jsxs(Box, { flexShrink: 1, children: [_jsx(Text, { color: theme.text.primary, italic: true, wrap: "truncate-end", children: primaryText }), primaryText === INTERACTIVE_SHELL_WAITING_PHRASE && (_jsxs(Text, { color: theme.ui.active, italic: true, children: [' ', "(press tab to focus)"] }))] })), !isNarrow && cancelAndTimerContent && (_jsxs(_Fragment, { children: [_jsx(Box, { flexShrink: 0, width: 1 }), _jsx(Text, { color: theme.text.secondary, children: cancelAndTimerContent })] })), !isNarrow && wittyPhraseNode] }), !isNarrow && _jsx(Box, { flexGrow: 1 }), !isNarrow && rightContent && _jsx(Box, { children: rightContent })] }), isNarrow && cancelAndTimerContent && (_jsx(Box, { children: _jsx(Text, { color: theme.text.secondary, children: cancelAndTimerContent }) })), isNarrow && wittyPhraseNode, isNarrow && rightContent && _jsx(Box, { children: rightContent })] }));
+};

package/dist/ui/components/LogoutConfirmationDialog.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Text } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import { RadioButtonSelect, } from './shared/RadioButtonSelect.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+export var LogoutChoice;
+(function (LogoutChoice) {
+    LogoutChoice["LOGIN"] = "login";
+    LogoutChoice["EXIT"] = "exit";
+})(LogoutChoice || (LogoutChoice = {}));
+export const LogoutConfirmationDialog = ({ onSelect }) => {
+    // Handle escape key to exit (consistent with other dialogs)
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            onSelect(LogoutChoice.EXIT);
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const options = [
+        {
+            label: 'Sign in',
+            value: LogoutChoice.LOGIN,
+            key: 'login',
+        },
+        {
+            label: 'Exit',
+            value: LogoutChoice.EXIT,
+            key: 'exit',
+        },
+    ];
+    return (_jsx(Box, { flexDirection: "row", width: "100%", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.ui.focus, padding: 1, flexGrow: 1, marginLeft: 1, marginRight: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, color: theme.text.primary, children: "You are now signed out" }), _jsx(Text, { color: theme.text.secondary, children: "Sign in again to continue using Gemini CLI, or exit the application." })] }), _jsx(RadioButtonSelect, { items: options, onSelect: onSelect, isFocused: true }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text.secondary, children: "(Use Enter to select, Esc to close)" }) })] }) }));
+};

package/dist/ui/components/LoopDetectionConfirmation.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Text } from 'ink';
+;
+import { RadioButtonSelect, } from './shared/RadioButtonSelect.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { theme } from '../semantic-colors.js';
+export function LoopDetectionConfirmation({ onComplete, }) {
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            onComplete({
+                userSelection: 'keep',
+            });
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const OPTIONS = [
+        {
+            label: 'Keep loop detection enabled (esc)',
+            value: {
+                userSelection: 'keep',
+            },
+            key: 'Keep loop detection enabled (esc)',
+        },
+        {
+            label: 'Disable loop detection for this session',
+            value: {
+                userSelection: 'disable',
+            },
+            key: 'Disable loop detection for this session',
+        },
+    ];
+    return (_jsx(Box, { width: "100%", flexDirection: "row", children: _jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.status.warning, flexGrow: 1, marginLeft: 1, children: _jsxs(Box, { paddingX: 1, paddingY: 0, flexDirection: "column", children: [_jsxs(Box, { minHeight: 1, children: [_jsx(Box, { minWidth: 3, children: _jsx(Text, { color: theme.status.warning, "aria-label": "Loop detected:", children: "?" }) }), _jsx(Box, { children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: theme.text.primary, bold: true, children: "A potential loop was detected" }), ' '] }) })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.text.secondary, children: "This can happen due to repetitive tool calls or other model behavior. Do you want to keep loop detection enabled or disable it for this session?" }), _jsx(Box, { marginTop: 1, children: _jsx(RadioButtonSelect, { items: OPTIONS, onSelect: onComplete }) })] }) })] }) }) }));
+}

package/dist/ui/components/MainContent.js

@@ -0,0 +1,176 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Box, Static } from 'ink';
+;
+import { HistoryItemDisplay } from './HistoryItemDisplay.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { useAppContext } from '../contexts/AppContext.js';
+import { AppHeader } from './AppHeader.js';
+import { useAlternateBuffer } from '../hooks/useAlternateBuffer.js';
+import { useConfig } from '../contexts/ConfigContext.js';
+import { SCROLL_TO_ITEM_END, } from './shared/VirtualizedList.js';
+import { ScrollableList } from './shared/ScrollableList.js';
+import { useMemo, memo, useCallback, useEffect, useRef } from 'react';
+import { MAX_GEMINI_MESSAGE_LINES } from '../constants.js';
+import { useConfirmingTool } from '../hooks/useConfirmingTool.js';
+import { ToolConfirmationQueue } from './ToolConfirmationQueue.js';
+import { appEvents, AppEvent } from '../../utils/events.js';
+const MemoizedHistoryItemDisplay = memo(HistoryItemDisplay);
+const MemoizedAppHeader = memo(AppHeader);
+// Limit Gemini messages to a very high number of lines to mitigate performance
+// issues in the worst case if we somehow get an enormous response from Gemini.
+// This threshold is arbitrary but should be high enough to never impact normal
+// usage.
+export const MainContent = () => {
+    const { version } = useAppContext();
+    const uiState = useUIState();
+    const isAlternateBufferOrTerminalBuffer = useAlternateBuffer();
+    const config = useConfig();
+    const useTerminalBuffer = config.getUseTerminalBuffer();
+    const isAlternateBuffer = config.getUseAlternateBuffer();
+    const confirmingTool = useConfirmingTool();
+    const showConfirmationQueue = confirmingTool !== null;
+    const confirmingToolCallId = confirmingTool?.tool.callId;
+    const scrollableListRef = useRef(null);
+    useEffect(() => {
+        if (showConfirmationQueue) {
+            scrollableListRef.current?.scrollToEnd();
+        }
+    }, [showConfirmationQueue, confirmingToolCallId]);
+    useEffect(() => {
+        const handleScroll = () => {
+            scrollableListRef.current?.scrollToEnd();
+        };
+        appEvents.on(AppEvent.ScrollToBottom, handleScroll);
+        return () => {
+            appEvents.off(AppEvent.ScrollToBottom, handleScroll);
+        };
+    }, []);
+    const { pendingHistoryItems, mainAreaWidth, staticAreaMaxItemHeight, availableTerminalHeight, cleanUiDetailsVisible, mouseMode, } = uiState;
+    const showHeaderDetails = cleanUiDetailsVisible;
+    const lastUserPromptIndex = useMemo(() => {
+        for (let i = uiState.history.length - 1; i >= 0; i--) {
+            const type = uiState.history[i].type;
+            if (type === 'user' || type === 'user_shell') {
+                return i;
+            }
+        }
+        return -1;
+    }, [uiState.history]);
+    const augmentedHistory = useMemo(() => uiState.history.map((item, i) => {
+        const prevType = i > 0 ? uiState.history[i - 1]?.type : undefined;
+        const isFirstThinking = item.type === 'thinking' && prevType !== 'thinking';
+        const isFirstAfterThinking = item.type !== 'thinking' && prevType === 'thinking';
+        const isToolGroupBoundary = (item.type !== 'tool_group' && prevType === 'tool_group') ||
+            (item.type === 'tool_group' && prevType !== 'tool_group');
+        return {
+            item,
+            isExpandable: i > lastUserPromptIndex,
+            isFirstThinking,
+            isFirstAfterThinking,
+            isToolGroupBoundary,
+        };
+    }), [uiState.history, lastUserPromptIndex]);
+    const historyItems = useMemo(() => augmentedHistory.map(({ item, isExpandable, isFirstThinking, isFirstAfterThinking, isToolGroupBoundary, }) => (_jsx(MemoizedHistoryItemDisplay, { terminalWidth: mainAreaWidth, availableTerminalHeight: uiState.constrainHeight || !isExpandable
+            ? staticAreaMaxItemHeight
+            : undefined, availableTerminalHeightGemini: MAX_GEMINI_MESSAGE_LINES, item: item, isPending: false, commands: uiState.slashCommands, isExpandable: isExpandable, isFirstThinking: isFirstThinking, isFirstAfterThinking: isFirstAfterThinking, isToolGroupBoundary: isToolGroupBoundary }, item.id))), [
+        augmentedHistory,
+        mainAreaWidth,
+        staticAreaMaxItemHeight,
+        uiState.slashCommands,
+        uiState.constrainHeight,
+    ]);
+    const staticHistoryItems = useMemo(() => historyItems.slice(0, lastUserPromptIndex + 1), [historyItems, lastUserPromptIndex]);
+    const lastResponseHistoryItems = useMemo(() => historyItems.slice(lastUserPromptIndex + 1), [historyItems, lastUserPromptIndex]);
+    const pendingItems = useMemo(() => (_jsxs(Box, { flexDirection: "column", children: [pendingHistoryItems.map((item, i) => {
+                const prevType = i === 0
+                    ? uiState.history.at(-1)?.type
+                    : pendingHistoryItems[i - 1]?.type;
+                const isFirstThinking = item.type === 'thinking' && prevType !== 'thinking';
+                const isFirstAfterThinking = item.type !== 'thinking' && prevType === 'thinking';
+                const isToolGroupBoundary = (item.type !== 'tool_group' && prevType === 'tool_group') ||
+                    (item.type === 'tool_group' && prevType !== 'tool_group');
+                return (_jsx(HistoryItemDisplay, { availableTerminalHeight: uiState.constrainHeight ? availableTerminalHeight : undefined, terminalWidth: mainAreaWidth, item: { ...item, id: -(i + 1) }, isPending: true, isExpandable: true, isFirstThinking: isFirstThinking, isFirstAfterThinking: isFirstAfterThinking, isToolGroupBoundary: isToolGroupBoundary }, `pending-${i}`));
+            }), showConfirmationQueue && confirmingTool && (_jsx(ToolConfirmationQueue, { confirmingTool: confirmingTool }, "confirmation-queue"))] }, "pending-items-group")), [
+        pendingHistoryItems,
+        uiState.constrainHeight,
+        availableTerminalHeight,
+        mainAreaWidth,
+        showConfirmationQueue,
+        confirmingTool,
+        uiState.history,
+    ]);
+    const virtualizedData = useMemo(() => [
+        { type: 'header' },
+        ...augmentedHistory.map((data, index) => ({
+            type: 'history',
+            item: data.item,
+            element: historyItems[index],
+        })),
+        { type: 'pending' },
+    ], [augmentedHistory, historyItems]);
+    const renderItem = useCallback(({ item }) => {
+        if (item.type === 'header') {
+            return (_jsx(MemoizedAppHeader, { version: version, showDetails: showHeaderDetails }, "app-header"));
+        }
+        else if (item.type === 'history') {
+            return item.element;
+        }
+        else {
+            return pendingItems;
+        }
+    }, [showHeaderDetails, version, pendingItems]);
+    const estimatedItemHeight = useCallback(() => 100, []);
+    const keyExtractor = useCallback((item, _index) => {
+        if (item.type === 'header')
+            return 'header';
+        if (item.type === 'history')
+            return item.item.id.toString();
+        return 'pending';
+    }, []);
+    // TODO(jacobr): we should return true for all messages that are not
+    // interactive. Gemini messages and Tool results that are not scrollable,
+    // collapsible, or clickable should also be tagged as static in the future.
+    const isStaticItem = useCallback((item) => item.type === 'header', []);
+    const scrollableList = useMemo(() => {
+        if (isAlternateBufferOrTerminalBuffer) {
+            return (_jsx(ScrollableList, { ref: scrollableListRef, hasFocus: !uiState.isEditorDialogOpen && !uiState.embeddedShellFocused, width: uiState.terminalWidth, data: virtualizedData, renderItem: renderItem, estimatedItemHeight: estimatedItemHeight, keyExtractor: keyExtractor, initialScrollIndex: SCROLL_TO_ITEM_END, initialScrollOffsetInIndex: SCROLL_TO_ITEM_END, renderStatic: useTerminalBuffer, isStaticItem: useTerminalBuffer ? isStaticItem : undefined, overflowToBackbuffer: useTerminalBuffer && !isAlternateBuffer, scrollbar: mouseMode })
+            // TODO(jacobr): consider adding stableScrollback={!config.getUseAlternateBuffer()}
+            // as that will reduce the # of cases where we will have to clear the
+            // scrollback buffer due to the scrollback size changing but we need to
+            // work out ensuring we only attempt it within a smaller range of
+            // scrollback vals. Right now it sometimes triggers adding more white
+            // space than it should.
+            );
+        }
+        return null;
+    }, [
+        isAlternateBufferOrTerminalBuffer,
+        uiState.isEditorDialogOpen,
+        uiState.embeddedShellFocused,
+        uiState.terminalWidth,
+        virtualizedData,
+        renderItem,
+        estimatedItemHeight,
+        keyExtractor,
+        useTerminalBuffer,
+        isStaticItem,
+        mouseMode,
+        isAlternateBuffer,
+    ]);
+    if (!uiState.isConfigInitialized) {
+        return null;
+    }
+    if (isAlternateBufferOrTerminalBuffer) {
+        return scrollableList;
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(Static, { items: [
+                    _jsx(AppHeader, { version: version }, "app-header"),
+                    ...staticHistoryItems,
+                    ...lastResponseHistoryItems,
+                ], children: (item) => item }, uiState.historyRemountKey), pendingItems] }));
+};

package/dist/ui/components/MemoryUsageDisplay.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Text, Box } from 'ink';
+;
+import { theme } from '../semantic-colors.js';
+import process from 'node:process';
+import { formatBytes } from '../utils/formatters.js';
+export const MemoryUsageDisplay = ({ color = theme.text.primary, isActive = true }) => {
+    const [memoryUsage, setMemoryUsage] = useState('');
+    const [memoryUsageColor, setMemoryUsageColor] = useState(color);
+    useEffect(() => {
+        if (!isActive) {
+            return;
+        }
+        const updateMemory = () => {
+            const usage = process.memoryUsage().rss;
+            setMemoryUsage(formatBytes(usage));
+            setMemoryUsageColor(usage >= 2 * 1024 * 1024 * 1024 ? theme.status.error : color);
+        };
+        const intervalId = setInterval(updateMemory, 2000);
+        updateMemory(); // Initial update
+        return () => clearInterval(intervalId);
+    }, [color, isActive]);
+    return (_jsx(Box, { children: _jsx(Text, { color: memoryUsageColor, children: memoryUsage }) }));
+};

package/dist/ui/components/ModelDialog.js

@@ -0,0 +1,268 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useContext, useMemo, useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+;
+import { ModelQuotaDisplay } from './ModelQuotaDisplay.js';
+import { useUIState } from '../contexts/UIStateContext.js';
+import { PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_3_1_MODEL, PREVIEW_GEMINI_FLASH_MODEL, PREVIEW_GEMINI_FLASH_LITE_MODEL, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_FLASH_LITE_MODEL, GEMINI_MODEL_ALIAS_AUTO, GEMMA_4_31B_IT_MODEL, GEMMA_4_26B_A4B_IT_MODEL, ModelSlashCommandEvent, logModelSlashCommand, getDisplayString, AuthType, PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL, isProModel, getAutoModelDescription, } from '@google/gemini-cli-core';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { theme } from '../semantic-colors.js';
+import { DescriptiveRadioButtonSelect } from './shared/DescriptiveRadioButtonSelect.js';
+import { ConfigContext } from '../contexts/ConfigContext.js';
+import { useSettings } from '../contexts/SettingsContext.js';
+export function ModelDialog({ onClose }) {
+    const config = useContext(ConfigContext);
+    const settings = useSettings();
+    const { terminalWidth } = useUIState();
+    const [hasAccessToProModel, setHasAccessToProModel] = useState(() => !(config?.getProModelNoAccessSync() ?? false));
+    const [view, setView] = useState(() => config?.getProModelNoAccessSync() ? 'manual' : 'main');
+    const [persistMode, setPersistMode] = useState(false);
+    useEffect(() => {
+        async function checkAccess() {
+            if (!config)
+                return;
+            const noAccess = await config.getProModelNoAccess();
+            setHasAccessToProModel(!noAccess);
+            if (noAccess) {
+                setView('manual');
+            }
+        }
+        void checkAccess();
+    }, [config]);
+    // Determine the Preferred Model (read once when the dialog opens).
+    const preferredModel = config?.getModel() || GEMINI_MODEL_ALIAS_AUTO;
+    const shouldShowPreviewModels = config?.getHasAccessToPreviewModel() ?? false;
+    const useGemini31 = config?.getGemini31LaunchedSync?.() ?? false;
+    const useGemini3_5Flash = config?.hasGemini35FlashGAAccess?.() ?? false;
+    const selectedAuthType = settings.merged.security.auth.selectedType;
+    const useCustomToolModel = useGemini31 && selectedAuthType === AuthType.USE_GEMINI;
+    const manualModelSelected = useMemo(() => {
+        if (config?.getExperimentalDynamicModelConfiguration?.() === true &&
+            config.getModelConfigService) {
+            const def = config
+                .getModelConfigService()
+                .getModelDefinition(preferredModel);
+            // Only treat as manual selection if it's a visible, non-auto model.
+            return def && def.tier !== 'auto' && def.isVisible === true
+                ? preferredModel
+                : '';
+        }
+        const manualModels = [
+            DEFAULT_GEMINI_MODEL,
+            DEFAULT_GEMINI_FLASH_MODEL,
+            DEFAULT_GEMINI_FLASH_LITE_MODEL,
+            PREVIEW_GEMINI_MODEL,
+            PREVIEW_GEMINI_3_1_MODEL,
+            PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL,
+            PREVIEW_GEMINI_FLASH_LITE_MODEL,
+            PREVIEW_GEMINI_FLASH_MODEL,
+        ].filter((m) => m !== 'none');
+        if (manualModels.includes(preferredModel)) {
+            return preferredModel;
+        }
+        return '';
+    }, [preferredModel, config]);
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            if (view === 'manual' && hasAccessToProModel) {
+                setView('main');
+            }
+            else {
+                onClose();
+            }
+            return true;
+        }
+        if (key.name === 'tab') {
+            setPersistMode((prev) => !prev);
+            return true;
+        }
+        return false;
+    }, { isActive: true });
+    const mainOptions = useMemo(() => {
+        // --- DYNAMIC PATH ---
+        if (config?.getExperimentalDynamicModelConfiguration?.() === true &&
+            config.getModelConfigService) {
+            const allOptions = config
+                .getModelConfigService()
+                .getAvailableModelOptions({
+                useGemini3_1: useGemini31,
+                useGemini3_5Flash,
+                useCustomTools: useCustomToolModel,
+                hasAccessToPreview: shouldShowPreviewModels,
+                hasAccessToProModel,
+            });
+            const list = allOptions
+                .filter((o) => o.tier === 'auto')
+                .map((o) => ({
+                value: o.modelId,
+                title: o.name,
+                description: o.description,
+                key: o.modelId,
+            }));
+            list.push({
+                value: 'Manual',
+                title: manualModelSelected
+                    ? `Manual (${getDisplayString(manualModelSelected, config ?? undefined)})`
+                    : 'Manual',
+                description: 'Manually select a model',
+                key: 'Manual',
+            });
+            return list;
+        }
+        // --- LEGACY PATH ---
+        const list = [
+            {
+                value: GEMINI_MODEL_ALIAS_AUTO,
+                title: getDisplayString(GEMINI_MODEL_ALIAS_AUTO),
+                description: getAutoModelDescription(shouldShowPreviewModels, useGemini31, useGemini3_5Flash),
+                key: GEMINI_MODEL_ALIAS_AUTO,
+            },
+            {
+                value: 'Manual',
+                title: manualModelSelected
+                    ? `Manual (${getDisplayString(manualModelSelected)})`
+                    : 'Manual',
+                description: 'Manually select a model',
+                key: 'Manual',
+            },
+        ];
+        return list;
+    }, [
+        config,
+        shouldShowPreviewModels,
+        manualModelSelected,
+        useGemini31,
+        useGemini3_5Flash,
+        useCustomToolModel,
+        hasAccessToProModel,
+    ]);
+    const manualOptions = useMemo(() => {
+        // --- DYNAMIC PATH ---
+        if (config?.getExperimentalDynamicModelConfiguration?.() === true &&
+            config.getModelConfigService) {
+            const allOptions = config
+                .getModelConfigService()
+                .getAvailableModelOptions({
+                useGemini3_1: useGemini31,
+                useGemini3_5Flash,
+                useCustomTools: useCustomToolModel,
+                hasAccessToPreview: shouldShowPreviewModels,
+                hasAccessToProModel,
+            });
+            return allOptions
+                .filter((o) => o.tier !== 'auto')
+                .map((o) => ({
+                value: o.modelId,
+                title: o.name,
+                key: o.modelId,
+            }));
+        }
+        // --- LEGACY PATH ---
+        const showGemmaModels = config?.getExperimentalGemma() ?? false;
+        const options = [
+            {
+                value: DEFAULT_GEMINI_MODEL,
+                title: getDisplayString(DEFAULT_GEMINI_MODEL),
+                key: DEFAULT_GEMINI_MODEL,
+            },
+            {
+                value: DEFAULT_GEMINI_FLASH_LITE_MODEL,
+                title: getDisplayString(DEFAULT_GEMINI_FLASH_LITE_MODEL),
+                key: DEFAULT_GEMINI_FLASH_LITE_MODEL,
+            },
+            {
+                value: DEFAULT_GEMINI_FLASH_MODEL,
+                title: getDisplayString(DEFAULT_GEMINI_FLASH_MODEL),
+                key: DEFAULT_GEMINI_FLASH_MODEL,
+            },
+        ];
+        if (showGemmaModels) {
+            options.push({
+                value: GEMMA_4_31B_IT_MODEL,
+                title: getDisplayString(GEMMA_4_31B_IT_MODEL),
+                key: GEMMA_4_31B_IT_MODEL,
+            }, {
+                value: GEMMA_4_26B_A4B_IT_MODEL,
+                title: getDisplayString(GEMMA_4_26B_A4B_IT_MODEL),
+                key: GEMMA_4_26B_A4B_IT_MODEL,
+            });
+        }
+        if (shouldShowPreviewModels) {
+            const previewProModel = useGemini31
+                ? PREVIEW_GEMINI_3_1_MODEL
+                : PREVIEW_GEMINI_MODEL;
+            const previewProValue = useCustomToolModel
+                ? PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL
+                : previewProModel;
+            const previewOptions = [
+                {
+                    value: previewProValue,
+                    title: getDisplayString(previewProModel),
+                    key: previewProModel,
+                },
+                {
+                    value: PREVIEW_GEMINI_FLASH_MODEL,
+                    title: getDisplayString(PREVIEW_GEMINI_FLASH_MODEL),
+                    key: PREVIEW_GEMINI_FLASH_MODEL,
+                },
+            ];
+            if (PREVIEW_GEMINI_FLASH_LITE_MODEL !== 'none') {
+                previewOptions.push({
+                    value: PREVIEW_GEMINI_FLASH_LITE_MODEL,
+                    title: getDisplayString(PREVIEW_GEMINI_FLASH_LITE_MODEL),
+                    key: PREVIEW_GEMINI_FLASH_LITE_MODEL,
+                });
+            }
+            options.unshift(...previewOptions);
+        }
+        if (!hasAccessToProModel) {
+            // Filter out all Pro models for free tier
+            return options.filter((option) => !isProModel(option.value));
+        }
+        return options;
+    }, [
+        shouldShowPreviewModels,
+        useGemini31,
+        useGemini3_5Flash,
+        useCustomToolModel,
+        hasAccessToProModel,
+        config,
+    ]);
+    const options = useMemo(() => {
+        const rawOptions = view === 'main' ? mainOptions : manualOptions;
+        const seen = new Set();
+        return rawOptions.filter((option) => {
+            if (seen.has(option.value)) {
+                return false;
+            }
+            seen.add(option.value);
+            return true;
+        });
+    }, [view, mainOptions, manualOptions]);
+    // Calculate the initial index based on the preferred model.
+    const initialIndex = useMemo(() => {
+        const idx = options.findIndex((option) => option.value === preferredModel);
+        if (idx !== -1) {
+            return idx;
+        }
+        if (view === 'main') {
+            const manualIdx = options.findIndex((o) => o.value === 'Manual');
+            return manualIdx !== -1 ? manualIdx : 0;
+        }
+        return 0;
+    }, [preferredModel, options, view]);
+    // Handle selection internally (Autonomous Dialog).
+    const handleSelect = useCallback((model) => {
+        if (model === 'Manual') {
+            setView('manual');
+            return;
+        }
+        if (config) {
+            config.setModel(model, persistMode ? false : true);
+            const event = new ModelSlashCommandEvent(model);
+            logModelSlashCommand(config, event);
+        }
+        onClose();
+    }, [config, onClose, persistMode]);
+    return (_jsxs(Box, { borderStyle: "round", borderColor: theme.border.default, flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Text, { bold: true, children: "Select Model" }), _jsx(Box, { marginTop: 1, children: _jsx(DescriptiveRadioButtonSelect, { items: options, onSelect: handleSelect, initialIndex: initialIndex, showNumbers: true }) }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Box, { children: [_jsxs(Text, { bold: true, color: theme.text.primary, children: ["Remember model for future sessions:", ' '] }), _jsx(Text, { color: theme.status.success, children: persistMode ? 'true' : 'false' }), _jsx(Text, { color: theme.text.secondary, children: " (Press Tab to toggle)" })] }) }), _jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: theme.text.secondary, children: '> To use a specific Gemini model on startup, use the --model flag.' }) }), _jsx(ModelQuotaDisplay, { buckets: config?.getLastRetrievedQuota()?.buckets, availableWidth: terminalWidth - 2 }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Text, { color: theme.text.secondary, children: "(Press Esc to close)" }) })] }));
+}