@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/hooks/useAgentStream.js

@@ -0,0 +1,407 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { getErrorMessage, MessageSenderType, debugLogger, geminiPartsToContentParts, displayContentToString, parseThought, CoreToolCallStatus, Kind, } from '@google/gemini-cli-core';
+import { StreamingState, MessageType } from '../types.js';
+import { findLastSafeSplitPoint } from '../utils/markdownUtilities.js';
+import { getToolGroupBorderAppearance } from '../utils/borderStyles.js';
+import { useSessionStats } from '../contexts/SessionContext.js';
+import { useStateAndRef } from './useStateAndRef.js';
+import { useKeypress } from './useKeypress.js';
+/**
+ * useAgentStream implements the interactive agent loop using an AgentProtocol.
+ * It is completely agnostic to the specific agent implementation.
+ */
+export const useAgentStream = ({ agent, addItem, onCancelSubmit, isShellFocused, logger, }) => {
+    const [initError] = useState(null);
+    const [retryStatus] = useState(null);
+    const [streamingState, setStreamingState] = useState(StreamingState.Idle);
+    const [thought, setThought] = useState(null);
+    const [lastOutputTime, setLastOutputTime] = useState(Date.now());
+    const currentStreamIdRef = useRef(null);
+    const userMessageTimestampRef = useRef(0);
+    const geminiMessageBufferRef = useRef('');
+    const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
+    const [trackedTools, , setTrackedTools] = useStateAndRef([]);
+    const [pushedToolCallIds, pushedToolCallIdsRef, setPushedToolCallIds] = useStateAndRef(new Set());
+    const [_isFirstToolInGroup, isFirstToolInGroupRef, setIsFirstToolInGroup] = useStateAndRef(true);
+    const [_hasEmittedBoxInTurn, hasEmittedBoxInTurnRef, setHasEmittedBoxInTurn] = useStateAndRef(false);
+    const { startNewPrompt } = useSessionStats();
+    // TODO: Implement dynamic shell-related state derivation from trackedTools or dedicated refs.
+    // This includes activePtyId, backgroundTasks, and related visibility states to restore
+    // parity with legacy terminal focus detection and background task tracking.
+    // Note: Avoid checking ITERM_SESSION_ID for terminal detection and ensure context is sanitized.
+    const activePtyId = undefined;
+    const backgroundTaskCount = 0;
+    const isBackgroundTaskVisible = false;
+    const toggleBackgroundTasks = useCallback(() => { }, []);
+    const backgroundCurrentExecution = undefined;
+    const backgroundTasks = useMemo(() => new Map(), []);
+    const dismissBackgroundTask = useCallback(async (_pid) => { }, []);
+    // Use the trackedTools to mock pendingToolCalls for inactivity monitors
+    const pendingToolCalls = useMemo(() => trackedTools.map((t) => ({
+        request: {
+            name: t.originalRequestName || t.name,
+            args: { command: t.description },
+            callId: t.callId,
+            isClientInitiated: t.isClientInitiated ?? false,
+            prompt_id: '',
+        },
+        status: t.status,
+    })), [trackedTools]);
+    // TODO: Support LoopDetection confirmation requests
+    const [loopDetectionConfirmationRequest] = useState(null);
+    const flushPendingText = useCallback(() => {
+        if (pendingHistoryItemRef.current) {
+            addItem(pendingHistoryItemRef.current, userMessageTimestampRef.current);
+            setPendingHistoryItem(null);
+            geminiMessageBufferRef.current = '';
+        }
+    }, [addItem, pendingHistoryItemRef, setPendingHistoryItem]);
+    const cancelOngoingRequest = useCallback(async (clearBuffer = true) => {
+        if (agent) {
+            await agent.abort();
+            setStreamingState(StreamingState.Idle);
+            onCancelSubmit(false, clearBuffer);
+        }
+    }, [agent, onCancelSubmit]);
+    // TODO: Support native handleApprovalModeChange for Plan Mode
+    const handleApprovalModeChange = useCallback(async (newApprovalMode) => {
+        debugLogger.debug(`Approval mode changed to ${newApprovalMode} (stub)`);
+    }, []);
+    const handleEvent = useCallback((event) => {
+        setLastOutputTime(Date.now());
+        switch (event.type) {
+            case 'agent_start':
+                setStreamingState(StreamingState.Responding);
+                break;
+            case 'agent_end':
+                setStreamingState(StreamingState.Idle);
+                flushPendingText();
+                break;
+            case 'message':
+                if (event.role === 'agent') {
+                    for (const part of event.content) {
+                        if (part.type === 'text') {
+                            geminiMessageBufferRef.current += part.text;
+                            // Update pending history item with incremental text
+                            const splitPoint = findLastSafeSplitPoint(geminiMessageBufferRef.current);
+                            if (splitPoint === geminiMessageBufferRef.current.length) {
+                                setPendingHistoryItem({
+                                    type: 'gemini',
+                                    text: geminiMessageBufferRef.current,
+                                });
+                            }
+                            else {
+                                const before = geminiMessageBufferRef.current.substring(0, splitPoint);
+                                const after = geminiMessageBufferRef.current.substring(splitPoint);
+                                addItem({ type: 'gemini', text: before }, userMessageTimestampRef.current);
+                                geminiMessageBufferRef.current = after;
+                                setPendingHistoryItem({
+                                    type: 'gemini_content',
+                                    text: after,
+                                });
+                            }
+                        }
+                        else if (part.type === 'thought') {
+                            setThought(parseThought(part.thought));
+                        }
+                    }
+                }
+                break;
+            case 'tool_request': {
+                flushPendingText();
+                const legacyState = event._meta?.legacyState;
+                const displayName = legacyState?.displayName ?? event.name;
+                const isOutputMarkdown = legacyState?.isOutputMarkdown ?? false;
+                const desc = legacyState?.description ?? '';
+                const fallbackKind = Kind.Other;
+                const newCall = {
+                    callId: event.requestId,
+                    name: displayName,
+                    originalRequestName: event.name,
+                    description: desc,
+                    display: event.display,
+                    status: CoreToolCallStatus.Scheduled,
+                    isClientInitiated: false,
+                    renderOutputAsMarkdown: isOutputMarkdown,
+                    kind: legacyState?.kind ?? fallbackKind,
+                    confirmationDetails: undefined,
+                    resultDisplay: undefined,
+                };
+                setTrackedTools((prev) => [...prev, newCall]);
+                break;
+            }
+            case 'tool_update': {
+                setTrackedTools((prev) => prev.map((tc) => {
+                    if (tc.callId !== event.requestId)
+                        return tc;
+                    const legacyState = event._meta?.legacyState;
+                    const evtStatus = legacyState?.status;
+                    let status = tc.status;
+                    if (evtStatus === 'executing')
+                        status = CoreToolCallStatus.Executing;
+                    else if (evtStatus === 'error')
+                        status = CoreToolCallStatus.Error;
+                    else if (evtStatus === 'success')
+                        status = CoreToolCallStatus.Success;
+                    const display = event.display?.result;
+                    const liveOutput = displayContentToString(display) ?? tc.resultDisplay;
+                    const progressMessage = legacyState?.progressMessage ?? tc.progressMessage;
+                    const progress = legacyState?.progress ?? tc.progress;
+                    const progressTotal = legacyState?.progressTotal ?? tc.progressTotal;
+                    const ptyId = legacyState?.pid ?? tc.ptyId;
+                    const description = legacyState?.description ?? tc.description;
+                    return {
+                        ...tc,
+                        status,
+                        display: event.display
+                            ? { ...tc.display, ...event.display }
+                            : tc.display,
+                        resultDisplay: liveOutput,
+                        progressMessage,
+                        progress,
+                        progressTotal,
+                        ptyId,
+                        description,
+                    };
+                }));
+                break;
+            }
+            case 'tool_response': {
+                setTrackedTools((prev) => prev.map((tc) => {
+                    if (tc.callId !== event.requestId)
+                        return tc;
+                    const legacyState = event._meta?.legacyState;
+                    const outputFile = legacyState?.outputFile;
+                    const display = event.display?.result;
+                    const resultDisplay = displayContentToString(display) ?? tc.resultDisplay;
+                    return {
+                        ...tc,
+                        status: event.isError
+                            ? CoreToolCallStatus.Error
+                            : CoreToolCallStatus.Success,
+                        display: event.display
+                            ? { ...tc.display, ...event.display }
+                            : tc.display,
+                        resultDisplay,
+                        outputFile,
+                    };
+                }));
+                break;
+            }
+            case 'error': {
+                const message = event._meta?.['code'] === 'AGENT_EXECUTION_BLOCKED'
+                    ? `Agent execution blocked: ${event.message}`
+                    : event.message;
+                addItem({ type: MessageType.ERROR, text: message }, userMessageTimestampRef.current);
+                break;
+            }
+            case 'initialize':
+            case 'session_update':
+            case 'elicitation_request':
+            case 'elicitation_response':
+            case 'usage':
+            case 'custom':
+                // These events are currently not handled in the UI
+                break;
+            default:
+                debugLogger.error('Unknown agent event type:', event);
+                event;
+                break;
+        }
+    }, [
+        addItem,
+        flushPendingText,
+        setPendingHistoryItem,
+        setTrackedTools,
+        setStreamingState,
+        setThought,
+        setLastOutputTime,
+    ]);
+    useEffect(() => {
+        const unsubscribe = agent?.subscribe(handleEvent);
+        return () => unsubscribe?.();
+    }, [agent, handleEvent]);
+    useKeypress((key) => {
+        if (key.name === 'escape' && !isShellFocused) {
+            void cancelOngoingRequest(false);
+            return true;
+        }
+        return false;
+    }, {
+        isActive: streamingState === StreamingState.Responding ||
+            streamingState === StreamingState.WaitingForConfirmation,
+    });
+    const submitQuery = useCallback(async (query, options, _prompt_id) => {
+        if (!agent)
+            return;
+        const timestamp = Date.now();
+        setLastOutputTime(timestamp);
+        userMessageTimestampRef.current = timestamp;
+        geminiMessageBufferRef.current = '';
+        if (!options?.isContinuation) {
+            if (typeof query === 'string') {
+                addItem({ type: MessageType.USER, text: query }, timestamp);
+                void logger?.logMessage(MessageSenderType.USER, query);
+            }
+            startNewPrompt();
+        }
+        const parts = geminiPartsToContentParts(typeof query === 'string' ? [{ text: query }] : query);
+        try {
+            const { streamId } = await agent.send({
+                message: { content: parts },
+            });
+            currentStreamIdRef.current = streamId;
+        }
+        catch (err) {
+            addItem({ type: MessageType.ERROR, text: getErrorMessage(err) }, timestamp);
+        }
+    }, [agent, addItem, logger, startNewPrompt]);
+    useEffect(() => {
+        if (trackedTools.length > 0) {
+            const isNewBatch = !trackedTools.some((tc) => pushedToolCallIdsRef.current.has(tc.callId));
+            if (isNewBatch) {
+                setPushedToolCallIds(new Set());
+                setIsFirstToolInGroup(true);
+            }
+        }
+        else if (streamingState === StreamingState.Idle) {
+            setPushedToolCallIds(new Set());
+            setIsFirstToolInGroup(true);
+        }
+    }, [
+        trackedTools,
+        pushedToolCallIdsRef,
+        setPushedToolCallIds,
+        setIsFirstToolInGroup,
+        streamingState,
+    ]);
+    // Push completed tools to history
+    useEffect(() => {
+        if (trackedTools.length === 0)
+            return;
+        // We only push to history once all currently known tools in the turn are terminal.
+        // This allows ToolGroupDisplay to correctly hoist ALL notices (topics) for the turn.
+        const allTerminal = trackedTools.every((tc) => tc.status === 'success' ||
+            tc.status === 'error' ||
+            tc.status === 'cancelled');
+        const toolsToPush = trackedTools.filter((tc) => !pushedToolCallIdsRef.current.has(tc.callId));
+        if (allTerminal && toolsToPush.length > 0) {
+            const newPushed = new Set(pushedToolCallIdsRef.current);
+            for (const tc of toolsToPush) {
+                newPushed.add(tc.callId);
+            }
+            const appearance = getToolGroupBorderAppearance({ type: 'tool_group', tools: trackedTools }, activePtyId, !!isShellFocused, [], backgroundTasks);
+            const hasBoxInBatch = toolsToPush.some((tc) => tc.display?.format !== 'notice');
+            const shouldStartNewBlock = isFirstToolInGroupRef.current ||
+                (!hasEmittedBoxInTurnRef.current && hasBoxInBatch);
+            const historyItem = {
+                type: 'tool_display_group',
+                tools: toolsToPush.map((tc) => ({
+                    name: tc.name,
+                    description: tc.description,
+                    ...tc.display,
+                    status: tc.status,
+                    originalRequestName: tc.originalRequestName,
+                })),
+                borderTop: shouldStartNewBlock,
+                borderBottom: true,
+                ...appearance,
+            };
+            addItem(historyItem);
+            setPushedToolCallIds(newPushed);
+            if (hasBoxInBatch) {
+                setHasEmittedBoxInTurn(true);
+            }
+            setIsFirstToolInGroup(false);
+        }
+    }, [
+        trackedTools,
+        pushedToolCallIdsRef,
+        isFirstToolInGroupRef,
+        hasEmittedBoxInTurnRef,
+        setPushedToolCallIds,
+        setIsFirstToolInGroup,
+        setHasEmittedBoxInTurn,
+        addItem,
+        activePtyId,
+        isShellFocused,
+        backgroundTasks,
+    ]);
+    const pendingToolGroupItems = useMemo(() => {
+        const remainingTools = trackedTools.filter((tc) => !pushedToolCallIdsRef.current.has(tc.callId));
+        const items = [];
+        const appearance = getToolGroupBorderAppearance({ type: 'tool_group', tools: trackedTools }, activePtyId, !!isShellFocused, [], backgroundTasks);
+        if (remainingTools.length > 0) {
+            const hasBoxInPending = remainingTools.some((tc) => tc.display?.format !== 'notice');
+            const shouldStartNewBlock = pushedToolCallIds.size === 0 ||
+                (!hasEmittedBoxInTurnRef.current && hasBoxInPending);
+            items.push({
+                type: 'tool_display_group',
+                tools: remainingTools.map((tc) => ({
+                    name: tc.name,
+                    description: tc.description,
+                    ...tc.display,
+                    status: tc.status,
+                    originalRequestName: tc.originalRequestName,
+                })),
+                borderTop: shouldStartNewBlock,
+                borderBottom: false,
+                ...appearance,
+            });
+        }
+        const allTerminal = trackedTools.length > 0 &&
+            trackedTools.every((tc) => tc.status === 'success' ||
+                tc.status === 'error' ||
+                tc.status === 'cancelled');
+        const allPushed = trackedTools.length > 0 &&
+            trackedTools.every((tc) => pushedToolCallIds.has(tc.callId));
+        const anyVisibleInHistory = pushedToolCallIds.size > 0;
+        const anyVisibleInPending = remainingTools.length > 0;
+        if (trackedTools.length > 0 &&
+            !(allTerminal && allPushed) &&
+            (anyVisibleInHistory || anyVisibleInPending)) {
+            items.push({
+                type: 'tool_display_group',
+                tools: [],
+                borderTop: false,
+                borderBottom: true,
+                ...appearance,
+            });
+        }
+        return items;
+    }, [
+        trackedTools,
+        pushedToolCallIds,
+        pushedToolCallIdsRef,
+        hasEmittedBoxInTurnRef,
+        activePtyId,
+        isShellFocused,
+        backgroundTasks,
+    ]);
+    const pendingHistoryItems = useMemo(() => [pendingHistoryItem, ...pendingToolGroupItems].filter((i) => i !== undefined && i !== null), [pendingHistoryItem, pendingToolGroupItems]);
+    return {
+        streamingState,
+        submitQuery,
+        initError,
+        pendingHistoryItems,
+        thought,
+        cancelOngoingRequest,
+        pendingToolCalls,
+        handleApprovalModeChange,
+        activePtyId,
+        loopDetectionConfirmationRequest,
+        lastOutputTime,
+        backgroundTaskCount,
+        isBackgroundTaskVisible,
+        toggleBackgroundTasks,
+        backgroundCurrentExecution,
+        backgroundTasks,
+        retryStatus,
+        dismissBackgroundTask,
+    };
+};

package/dist/ui/hooks/useAlternateBuffer.js

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useConfig } from '../contexts/ConfigContext.js';
+// This method is intentionally misleading while we migrate.
+// Once getUseTerminalBuffer() is always enabled we will refactor to remove
+// all instances of this method making it the only path.
+// Right now this is convenient as it allows us to special case terminalBuffer
+// rendering like we special case alternateBuffer rendering.
+export const isAlternateBufferEnabled = (config) => config.getUseAlternateBuffer() || config.getUseTerminalBuffer();
+// This is read from Config so that the UI reads the same value per application session
+export const useAlternateBuffer = () => {
+    const config = useConfig();
+    return isAlternateBufferEnabled(config);
+};

package/dist/ui/hooks/useAnimatedScrollbar.js

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useLayoutEffect, useRef, useCallback } from 'react';
+import { theme } from '../semantic-colors.js';
+import { interpolateColor } from '../themes/color-utils.js';
+import { debugState } from '../debug.js';
+export function useAnimatedScrollbar(isFocused, scrollBy) {
+    const [scrollbarColor, setScrollbarColor] = useState(theme.ui.dark);
+    const colorRef = useRef(scrollbarColor);
+    colorRef.current = scrollbarColor;
+    const animationFrame = useRef(null);
+    const timeout = useRef(null);
+    const isAnimatingRef = useRef(false);
+    const cleanup = useCallback(() => {
+        if (isAnimatingRef.current) {
+            debugState.debugNumAnimatedComponents--;
+            isAnimatingRef.current = false;
+        }
+        if (animationFrame.current) {
+            clearInterval(animationFrame.current);
+            animationFrame.current = null;
+        }
+        if (timeout.current) {
+            clearTimeout(timeout.current);
+            timeout.current = null;
+        }
+    }, []);
+    const flashScrollbar = useCallback(() => {
+        cleanup();
+        debugState.debugNumAnimatedComponents++;
+        isAnimatingRef.current = true;
+        const isTest = typeof process !== 'undefined' && process.env['NODE_ENV'] === 'test';
+        const fadeInDuration = isTest ? 0 : 200;
+        const visibleDuration = isTest ? 0 : 1000;
+        const fadeOutDuration = isTest ? 0 : 300;
+        const focusedColor = theme.text.secondary;
+        const unfocusedColor = theme.ui.dark;
+        const startColor = colorRef.current;
+        if (!focusedColor || !unfocusedColor) {
+            return;
+        }
+        if (isTest) {
+            setScrollbarColor(unfocusedColor);
+            cleanup();
+            return;
+        }
+        // Phase 1: Fade In
+        let start = Date.now();
+        const animateFadeIn = () => {
+            if (!isAnimatingRef.current)
+                return;
+            const elapsed = Date.now() - start;
+            const progress = Math.max(0, Math.min(elapsed / fadeInDuration, 1));
+            setScrollbarColor(interpolateColor(startColor, focusedColor, progress));
+            if (progress === 1) {
+                if (animationFrame.current) {
+                    clearInterval(animationFrame.current);
+                    animationFrame.current = null;
+                }
+                // Phase 2: Wait
+                timeout.current = setTimeout(() => {
+                    // Phase 3: Fade Out
+                    start = Date.now();
+                    const animateFadeOut = () => {
+                        if (!isAnimatingRef.current)
+                            return;
+                        const elapsed = Date.now() - start;
+                        const progress = Math.max(0, Math.min(elapsed / fadeOutDuration, 1));
+                        setScrollbarColor(interpolateColor(focusedColor, unfocusedColor, progress));
+                        if (progress === 1) {
+                            cleanup();
+                        }
+                    };
+                    animationFrame.current = setInterval(animateFadeOut, 33);
+                }, visibleDuration);
+            }
+        };
+        animationFrame.current = setInterval(animateFadeIn, 33);
+    }, [cleanup]);
+    const wasFocused = useRef(isFocused);
+    useLayoutEffect(() => {
+        if (isFocused && !wasFocused.current) {
+            flashScrollbar();
+        }
+        else if (!isFocused && wasFocused.current) {
+            cleanup();
+            setScrollbarColor(theme.ui.dark);
+        }
+        wasFocused.current = isFocused;
+        return cleanup;
+    }, [isFocused, flashScrollbar, cleanup]);
+    const scrollByWithAnimation = useCallback((delta) => {
+        scrollBy(delta);
+        flashScrollbar();
+    }, [scrollBy, flashScrollbar]);
+    return { scrollbarColor, flashScrollbar, scrollByWithAnimation };
+}

package/dist/ui/hooks/useApprovalModeIndicator.js

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect } from 'react';
+import { ApprovalMode, getAdminErrorMessage, } from '@google/gemini-cli-core';
+import { useKeypress } from './useKeypress.js';
+import { Command } from '../key/keyMatchers.js';
+import { useKeyMatchers } from './useKeyMatchers.js';
+import { MessageType } from '../types.js';
+export function useApprovalModeIndicator({ config, addItem, onApprovalModeChange, isActive = true, allowPlanMode = false, }) {
+    const keyMatchers = useKeyMatchers();
+    const currentConfigValue = config.getApprovalMode();
+    const [showApprovalMode, setApprovalMode] = useState(currentConfigValue);
+    useEffect(() => {
+        setApprovalMode(currentConfigValue);
+    }, [currentConfigValue]);
+    useKeypress((key) => {
+        let nextApprovalMode;
+        if (keyMatchers[Command.TOGGLE_YOLO](key)) {
+            if (config.isYoloModeDisabled() &&
+                config.getApprovalMode() !== ApprovalMode.YOLO) {
+                if (addItem) {
+                    let text = 'You cannot enter YOLO mode since it is disabled in your settings.';
+                    const adminSettings = config.getRemoteAdminSettings();
+                    const hasSettings = adminSettings && Object.keys(adminSettings).length > 0;
+                    if (hasSettings && !adminSettings.strictModeDisabled) {
+                        text = getAdminErrorMessage('YOLO mode', config);
+                    }
+                    addItem({
+                        type: MessageType.WARNING,
+                        text,
+                    }, Date.now());
+                }
+                return;
+            }
+            nextApprovalMode =
+                config.getApprovalMode() === ApprovalMode.YOLO
+                    ? ApprovalMode.DEFAULT
+                    : ApprovalMode.YOLO;
+        }
+        else if (keyMatchers[Command.CYCLE_APPROVAL_MODE](key)) {
+            const currentMode = config.getApprovalMode();
+            switch (currentMode) {
+                case ApprovalMode.DEFAULT:
+                    nextApprovalMode = ApprovalMode.AUTO_EDIT;
+                    break;
+                case ApprovalMode.AUTO_EDIT:
+                    nextApprovalMode = allowPlanMode
+                        ? ApprovalMode.PLAN
+                        : ApprovalMode.DEFAULT;
+                    break;
+                case ApprovalMode.PLAN:
+                    nextApprovalMode = ApprovalMode.DEFAULT;
+                    break;
+                case ApprovalMode.YOLO:
+                    nextApprovalMode = ApprovalMode.AUTO_EDIT;
+                    break;
+                default:
+            }
+        }
+        if (nextApprovalMode) {
+            try {
+                config.setApprovalMode(nextApprovalMode);
+                // Update local state immediately for responsiveness
+                setApprovalMode(nextApprovalMode);
+                // Notify the central handler about the approval mode change
+                onApprovalModeChange?.(nextApprovalMode);
+            }
+            catch (e) {
+                if (addItem) {
+                    addItem({
+                        type: MessageType.INFO,
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                        text: e.message,
+                    }, Date.now());
+                }
+            }
+        }
+    }, { isActive });
+    return showApprovalMode;
+}