@google/gemini-cli 0.1.9-nightly.250708.137ffec3 → 0.1.9-nightly.250708.a4097ae6

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

@@ -0,0 +1,838 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { useGeminiStream, mergePartListUnions } from './useGeminiStream.js';
+import { useInput } from 'ink';
+import { useReactToolScheduler, } from './useReactToolScheduler.js';
+import { AuthType } from '@google/gemini-cli-core';
+import { MessageType, StreamingState, } from '../types.js';
+// --- MOCKS ---
+const mockSendMessageStream = vi
+    .fn()
+    .mockReturnValue((async function* () { })());
+const mockStartChat = vi.fn();
+const MockedGeminiClientClass = vi.hoisted(() => vi.fn().mockImplementation(function (_config) {
+    // _config
+    this.startChat = mockStartChat;
+    this.sendMessageStream = mockSendMessageStream;
+    this.addHistory = vi.fn();
+}));
+const MockedUserPromptEvent = vi.hoisted(() => vi.fn().mockImplementation(() => { }));
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+    const actualCoreModule = (await importOriginal());
+    return {
+        ...actualCoreModule,
+        GitService: vi.fn(),
+        GeminiClient: MockedGeminiClientClass,
+        UserPromptEvent: MockedUserPromptEvent,
+    };
+});
+const mockUseReactToolScheduler = useReactToolScheduler;
+vi.mock('./useReactToolScheduler.js', async (importOriginal) => {
+    const actualSchedulerModule = (await importOriginal());
+    return {
+        ...(actualSchedulerModule || {}),
+        useReactToolScheduler: vi.fn(),
+    };
+});
+vi.mock('ink', async (importOriginal) => {
+    const actualInkModule = (await importOriginal());
+    return { ...(actualInkModule || {}), useInput: vi.fn() };
+});
+vi.mock('./shellCommandProcessor.js', () => ({
+    useShellCommandProcessor: vi.fn().mockReturnValue({
+        handleShellCommand: vi.fn(),
+    }),
+}));
+vi.mock('./atCommandProcessor.js', () => ({
+    handleAtCommand: vi
+        .fn()
+        .mockResolvedValue({ shouldProceed: true, processedQuery: 'mocked' }),
+}));
+vi.mock('../utils/markdownUtilities.js', () => ({
+    findLastSafeSplitPoint: vi.fn((s) => s.length),
+}));
+vi.mock('./useStateAndRef.js', () => ({
+    useStateAndRef: vi.fn((initial) => {
+        let val = initial;
+        const ref = { current: val };
+        const setVal = vi.fn((updater) => {
+            if (typeof updater === 'function') {
+                val = updater(val);
+            }
+            else {
+                val = updater;
+            }
+            ref.current = val;
+        });
+        return [ref, setVal];
+    }),
+}));
+vi.mock('./useLogger.js', () => ({
+    useLogger: vi.fn().mockReturnValue({
+        logMessage: vi.fn().mockResolvedValue(undefined),
+    }),
+}));
+const mockStartNewTurn = vi.fn();
+const mockAddUsage = vi.fn();
+vi.mock('../contexts/SessionContext.js', () => ({
+    useSessionStats: vi.fn(() => ({
+        startNewTurn: mockStartNewTurn,
+        addUsage: mockAddUsage,
+    })),
+}));
+vi.mock('./slashCommandProcessor.js', () => ({
+    handleSlashCommand: vi.fn().mockReturnValue(false),
+}));
+const mockParseAndFormatApiError = vi.hoisted(() => vi.fn());
+vi.mock('../utils/errorParsing.js', () => ({
+    parseAndFormatApiError: mockParseAndFormatApiError,
+}));
+// --- END MOCKS ---
+describe('mergePartListUnions', () => {
+    it('should merge multiple PartListUnion arrays', () => {
+        const list1 = [{ text: 'Hello' }];
+        const list2 = [
+            { inlineData: { mimeType: 'image/png', data: 'abc' } },
+        ];
+        const list3 = [{ text: 'World' }, { text: '!' }];
+        const result = mergePartListUnions([list1, list2, list3]);
+        expect(result).toEqual([
+            { text: 'Hello' },
+            { inlineData: { mimeType: 'image/png', data: 'abc' } },
+            { text: 'World' },
+            { text: '!' },
+        ]);
+    });
+    it('should handle empty arrays in the input list', () => {
+        const list1 = [{ text: 'First' }];
+        const list2 = [];
+        const list3 = [{ text: 'Last' }];
+        const result = mergePartListUnions([list1, list2, list3]);
+        expect(result).toEqual([{ text: 'First' }, { text: 'Last' }]);
+    });
+    it('should handle a single PartListUnion array', () => {
+        const list1 = [
+            { text: 'One' },
+            { inlineData: { mimeType: 'image/jpeg', data: 'xyz' } },
+        ];
+        const result = mergePartListUnions([list1]);
+        expect(result).toEqual(list1);
+    });
+    it('should return an empty array if all input arrays are empty', () => {
+        const list1 = [];
+        const list2 = [];
+        const result = mergePartListUnions([list1, list2]);
+        expect(result).toEqual([]);
+    });
+    it('should handle input list being empty', () => {
+        const result = mergePartListUnions([]);
+        expect(result).toEqual([]);
+    });
+    it('should correctly merge when PartListUnion items are single Parts not in arrays', () => {
+        const part1 = { text: 'Single part 1' };
+        const part2 = { inlineData: { mimeType: 'image/gif', data: 'gif' } };
+        const listContainingSingleParts = [
+            part1,
+            [part2],
+            { text: 'Another single part' },
+        ];
+        const result = mergePartListUnions(listContainingSingleParts);
+        expect(result).toEqual([
+            { text: 'Single part 1' },
+            { inlineData: { mimeType: 'image/gif', data: 'gif' } },
+            { text: 'Another single part' },
+        ]);
+    });
+    it('should handle a mix of arrays and single parts, including empty arrays and undefined/null parts if they were possible (though PartListUnion typing restricts this)', () => {
+        const list1 = [{ text: 'A' }];
+        const list2 = [];
+        const part3 = { text: 'B' };
+        const list4 = [
+            { text: 'C' },
+            { inlineData: { mimeType: 'text/plain', data: 'D' } },
+        ];
+        const result = mergePartListUnions([list1, list2, part3, list4]);
+        expect(result).toEqual([
+            { text: 'A' },
+            { text: 'B' },
+            { text: 'C' },
+            { inlineData: { mimeType: 'text/plain', data: 'D' } },
+        ]);
+    });
+    it('should preserve the order of parts from the input arrays', () => {
+        const listA = [{ text: '1' }, { text: '2' }];
+        const listB = [{ text: '3' }];
+        const listC = [{ text: '4' }, { text: '5' }];
+        const result = mergePartListUnions([listA, listB, listC]);
+        expect(result).toEqual([
+            { text: '1' },
+            { text: '2' },
+            { text: '3' },
+            { text: '4' },
+            { text: '5' },
+        ]);
+    });
+    it('should handle cases where some PartListUnion items are single Parts and others are arrays of Parts', () => {
+        const singlePart1 = { text: 'First single' };
+        const arrayPart1 = [
+            { text: 'Array item 1' },
+            { text: 'Array item 2' },
+        ];
+        const singlePart2 = {
+            inlineData: { mimeType: 'application/json', data: 'e30=' },
+        }; // {}
+        const arrayPart2 = [{ text: 'Last array item' }];
+        const result = mergePartListUnions([
+            singlePart1,
+            arrayPart1,
+            singlePart2,
+            arrayPart2,
+        ]);
+        expect(result).toEqual([
+            { text: 'First single' },
+            { text: 'Array item 1' },
+            { text: 'Array item 2' },
+            { inlineData: { mimeType: 'application/json', data: 'e30=' } },
+            { text: 'Last array item' },
+        ]);
+    });
+});
+// --- Tests for useGeminiStream Hook ---
+describe('useGeminiStream', () => {
+    let mockAddItem;
+    let mockSetShowHelp;
+    let mockConfig;
+    let mockOnDebugMessage;
+    let mockHandleSlashCommand;
+    let mockScheduleToolCalls;
+    let mockCancelAllToolCalls;
+    let mockMarkToolsAsSubmitted;
+    beforeEach(() => {
+        vi.clearAllMocks(); // Clear mocks before each test
+        mockAddItem = vi.fn();
+        mockSetShowHelp = vi.fn();
+        // Define the mock for getGeminiClient
+        const mockGetGeminiClient = vi.fn().mockImplementation(() => {
+            // MockedGeminiClientClass is defined in the module scope by the previous change.
+            // It will use the mockStartChat and mockSendMessageStream that are managed within beforeEach.
+            const clientInstance = new MockedGeminiClientClass(mockConfig);
+            return clientInstance;
+        });
+        mockConfig = {
+            apiKey: 'test-api-key',
+            model: 'gemini-pro',
+            sandbox: false,
+            targetDir: '/test/dir',
+            debugMode: false,
+            question: undefined,
+            fullContext: false,
+            coreTools: [],
+            toolDiscoveryCommand: undefined,
+            toolCallCommand: undefined,
+            mcpServerCommand: undefined,
+            mcpServers: undefined,
+            userAgent: 'test-agent',
+            userMemory: '',
+            geminiMdFileCount: 0,
+            alwaysSkipModificationConfirmation: false,
+            vertexai: false,
+            showMemoryUsage: false,
+            contextFileName: undefined,
+            getToolRegistry: vi.fn(() => ({ getToolSchemaList: vi.fn(() => []) })),
+            getProjectRoot: vi.fn(() => '/test/dir'),
+            getCheckpointingEnabled: vi.fn(() => false),
+            getGeminiClient: mockGetGeminiClient,
+            getUsageStatisticsEnabled: () => true,
+            getDebugMode: () => false,
+            addHistory: vi.fn(),
+        };
+        mockOnDebugMessage = vi.fn();
+        mockHandleSlashCommand = vi.fn().mockResolvedValue(false);
+        // Mock return value for useReactToolScheduler
+        mockScheduleToolCalls = vi.fn();
+        mockCancelAllToolCalls = vi.fn();
+        mockMarkToolsAsSubmitted = vi.fn();
+        // Default mock for useReactToolScheduler to prevent toolCalls being undefined initially
+        mockUseReactToolScheduler.mockReturnValue([
+            [], // Default to empty array for toolCalls
+            mockScheduleToolCalls,
+            mockCancelAllToolCalls,
+            mockMarkToolsAsSubmitted,
+        ]);
+        // Reset mocks for GeminiClient instance methods (startChat and sendMessageStream)
+        // The GeminiClient constructor itself is mocked at the module level.
+        mockStartChat.mockClear().mockResolvedValue({
+            sendMessageStream: mockSendMessageStream,
+        }); // GeminiChat -> any
+        mockSendMessageStream
+            .mockClear()
+            .mockReturnValue((async function* () { })());
+    });
+    const mockLoadedSettings = {
+        merged: { preferredEditor: 'vscode' },
+        user: { path: '/user/settings.json', settings: {} },
+        workspace: { path: '/workspace/.gemini/settings.json', settings: {} },
+        errors: [],
+        forScope: vi.fn(),
+        setValue: vi.fn(),
+    };
+    const renderTestHook = (initialToolCalls = [], geminiClient) => {
+        let currentToolCalls = initialToolCalls;
+        const setToolCalls = (newToolCalls) => {
+            currentToolCalls = newToolCalls;
+        };
+        mockUseReactToolScheduler.mockImplementation(() => [
+            currentToolCalls,
+            mockScheduleToolCalls,
+            mockCancelAllToolCalls,
+            mockMarkToolsAsSubmitted,
+        ]);
+        const client = geminiClient || mockConfig.getGeminiClient();
+        const { result, rerender } = renderHook((props) => {
+            // Update the mock's return value if new toolCalls are passed in props
+            if (props.toolCalls) {
+                setToolCalls(props.toolCalls);
+            }
+            return useGeminiStream(props.client, props.history, props.addItem, props.setShowHelp, props.config, props.onDebugMessage, props.handleSlashCommand, props.shellModeActive, () => 'vscode', () => { }, () => Promise.resolve());
+        }, {
+            initialProps: {
+                client,
+                history: [],
+                addItem: mockAddItem,
+                setShowHelp: mockSetShowHelp,
+                config: mockConfig,
+                onDebugMessage: mockOnDebugMessage,
+                handleSlashCommand: mockHandleSlashCommand,
+                shellModeActive: false,
+                loadedSettings: mockLoadedSettings,
+                toolCalls: initialToolCalls,
+            },
+        });
+        return {
+            result,
+            rerender,
+            mockMarkToolsAsSubmitted,
+            mockSendMessageStream,
+            client,
+        };
+    };
+    it('should not submit tool responses if not all tool calls are completed', () => {
+        const toolCalls = [
+            {
+                request: {
+                    callId: 'call1',
+                    name: 'tool1',
+                    args: {},
+                    isClientInitiated: false,
+                },
+                status: 'success',
+                responseSubmittedToGemini: false,
+                response: {
+                    callId: 'call1',
+                    responseParts: [{ text: 'tool 1 response' }],
+                    error: undefined,
+                    resultDisplay: 'Tool 1 success display',
+                },
+                tool: {
+                    name: 'tool1',
+                    description: 'desc1',
+                    getDescription: vi.fn(),
+                },
+                startTime: Date.now(),
+                endTime: Date.now(),
+            },
+            {
+                request: { callId: 'call2', name: 'tool2', args: {} },
+                status: 'executing',
+                responseSubmittedToGemini: false,
+                tool: {
+                    name: 'tool2',
+                    description: 'desc2',
+                    getDescription: vi.fn(),
+                },
+                startTime: Date.now(),
+                liveOutput: '...',
+            },
+        ];
+        const { mockMarkToolsAsSubmitted, mockSendMessageStream } = renderTestHook(toolCalls);
+        // Effect for submitting tool responses depends on toolCalls and isResponding
+        // isResponding is initially false, so the effect should run.
+        expect(mockMarkToolsAsSubmitted).not.toHaveBeenCalled();
+        expect(mockSendMessageStream).not.toHaveBeenCalled(); // submitQuery uses this
+    });
+    it('should submit tool responses when all tool calls are completed and ready', async () => {
+        const toolCall1ResponseParts = [
+            { text: 'tool 1 final response' },
+        ];
+        const toolCall2ResponseParts = [
+            { text: 'tool 2 final response' },
+        ];
+        const completedToolCalls = [
+            {
+                request: {
+                    callId: 'call1',
+                    name: 'tool1',
+                    args: {},
+                    isClientInitiated: false,
+                },
+                status: 'success',
+                responseSubmittedToGemini: false,
+                response: { callId: 'call1', responseParts: toolCall1ResponseParts },
+            },
+            {
+                request: {
+                    callId: 'call2',
+                    name: 'tool2',
+                    args: {},
+                    isClientInitiated: false,
+                },
+                status: 'error',
+                responseSubmittedToGemini: false,
+                response: { callId: 'call2', responseParts: toolCall2ResponseParts },
+            },
+        ];
+        // Capture the onComplete callback
+        let capturedOnComplete = null;
+        mockUseReactToolScheduler.mockImplementation((onComplete) => {
+            capturedOnComplete = onComplete;
+            return [[], mockScheduleToolCalls, mockMarkToolsAsSubmitted];
+        });
+        renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockSetShowHelp, mockConfig, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve()));
+        // Trigger the onComplete callback with completed tools
+        await act(async () => {
+            if (capturedOnComplete) {
+                await capturedOnComplete(completedToolCalls);
+            }
+        });
+        await waitFor(() => {
+            expect(mockMarkToolsAsSubmitted).toHaveBeenCalledTimes(1);
+            expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
+        });
+        const expectedMergedResponse = mergePartListUnions([
+            toolCall1ResponseParts,
+            toolCall2ResponseParts,
+        ]);
+        expect(mockSendMessageStream).toHaveBeenCalledWith(expectedMergedResponse, expect.any(AbortSignal));
+    });
+    it('should handle all tool calls being cancelled', async () => {
+        const cancelledToolCalls = [
+            {
+                request: {
+                    callId: '1',
+                    name: 'testTool',
+                    args: {},
+                    isClientInitiated: false,
+                },
+                status: 'cancelled',
+                response: { callId: '1', responseParts: [{ text: 'cancelled' }] },
+                responseSubmittedToGemini: false,
+            },
+        ];
+        const client = new MockedGeminiClientClass(mockConfig);
+        // Capture the onComplete callback
+        let capturedOnComplete = null;
+        mockUseReactToolScheduler.mockImplementation((onComplete) => {
+            capturedOnComplete = onComplete;
+            return [[], mockScheduleToolCalls, mockMarkToolsAsSubmitted];
+        });
+        renderHook(() => useGeminiStream(client, [], mockAddItem, mockSetShowHelp, mockConfig, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve()));
+        // Trigger the onComplete callback with cancelled tools
+        await act(async () => {
+            if (capturedOnComplete) {
+                await capturedOnComplete(cancelledToolCalls);
+            }
+        });
+        await waitFor(() => {
+            expect(mockMarkToolsAsSubmitted).toHaveBeenCalledWith(['1']);
+            expect(client.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: [{ text: 'cancelled' }],
+            });
+            // Ensure we do NOT call back to the API
+            expect(mockSendMessageStream).not.toHaveBeenCalled();
+        });
+    });
+    it('should group multiple cancelled tool call responses into a single history entry', async () => {
+        const cancelledToolCall1 = {
+            request: {
+                callId: 'cancel-1',
+                name: 'toolA',
+                args: {},
+                isClientInitiated: false,
+            },
+            tool: {
+                name: 'toolA',
+                description: 'descA',
+                getDescription: vi.fn(),
+            },
+            status: 'cancelled',
+            response: {
+                callId: 'cancel-1',
+                responseParts: [
+                    { functionResponse: { name: 'toolA', id: 'cancel-1' } },
+                ],
+                resultDisplay: undefined,
+                error: undefined,
+            },
+            responseSubmittedToGemini: false,
+        };
+        const cancelledToolCall2 = {
+            request: {
+                callId: 'cancel-2',
+                name: 'toolB',
+                args: {},
+                isClientInitiated: false,
+            },
+            tool: {
+                name: 'toolB',
+                description: 'descB',
+                getDescription: vi.fn(),
+            },
+            status: 'cancelled',
+            response: {
+                callId: 'cancel-2',
+                responseParts: [
+                    { functionResponse: { name: 'toolB', id: 'cancel-2' } },
+                ],
+                resultDisplay: undefined,
+                error: undefined,
+            },
+            responseSubmittedToGemini: false,
+        };
+        const allCancelledTools = [cancelledToolCall1, cancelledToolCall2];
+        const client = new MockedGeminiClientClass(mockConfig);
+        let capturedOnComplete = null;
+        mockUseReactToolScheduler.mockImplementation((onComplete) => {
+            capturedOnComplete = onComplete;
+            return [[], mockScheduleToolCalls, mockMarkToolsAsSubmitted];
+        });
+        renderHook(() => useGeminiStream(client, [], mockAddItem, mockSetShowHelp, mockConfig, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve()));
+        // Trigger the onComplete callback with multiple cancelled tools
+        await act(async () => {
+            if (capturedOnComplete) {
+                await capturedOnComplete(allCancelledTools);
+            }
+        });
+        await waitFor(() => {
+            // The tools should be marked as submitted locally
+            expect(mockMarkToolsAsSubmitted).toHaveBeenCalledWith([
+                'cancel-1',
+                'cancel-2',
+            ]);
+            // Crucially, addHistory should be called only ONCE
+            expect(client.addHistory).toHaveBeenCalledTimes(1);
+            // And that single call should contain BOTH function responses
+            expect(client.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: [
+                    ...cancelledToolCall1.response.responseParts,
+                    ...cancelledToolCall2.response.responseParts,
+                ],
+            });
+            // No message should be sent back to the API for a turn with only cancellations
+            expect(mockSendMessageStream).not.toHaveBeenCalled();
+        });
+    });
+    it('should not flicker streaming state to Idle between tool completion and submission', async () => {
+        const toolCallResponseParts = [
+            { text: 'tool 1 final response' },
+        ];
+        const initialToolCalls = [
+            {
+                request: {
+                    callId: 'call1',
+                    name: 'tool1',
+                    args: {},
+                    isClientInitiated: false,
+                },
+                status: 'executing',
+                responseSubmittedToGemini: false,
+                tool: {
+                    name: 'tool1',
+                    description: 'desc',
+                    getDescription: vi.fn(),
+                },
+                startTime: Date.now(),
+            },
+        ];
+        const completedToolCalls = [
+            {
+                ...initialToolCalls[0],
+                status: 'success',
+                response: {
+                    callId: 'call1',
+                    responseParts: toolCallResponseParts,
+                    error: undefined,
+                    resultDisplay: 'Tool 1 success display',
+                },
+                endTime: Date.now(),
+            },
+        ];
+        // Capture the onComplete callback
+        let capturedOnComplete = null;
+        let currentToolCalls = initialToolCalls;
+        mockUseReactToolScheduler.mockImplementation((onComplete) => {
+            capturedOnComplete = onComplete;
+            return [
+                currentToolCalls,
+                mockScheduleToolCalls,
+                mockMarkToolsAsSubmitted,
+            ];
+        });
+        const { result, rerender } = renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockSetShowHelp, mockConfig, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve()));
+        // 1. Initial state should be Responding because a tool is executing.
+        expect(result.current.streamingState).toBe(StreamingState.Responding);
+        // 2. Update the tool calls to completed state and rerender
+        currentToolCalls = completedToolCalls;
+        mockUseReactToolScheduler.mockImplementation((onComplete) => {
+            capturedOnComplete = onComplete;
+            return [
+                completedToolCalls,
+                mockScheduleToolCalls,
+                mockMarkToolsAsSubmitted,
+            ];
+        });
+        act(() => {
+            rerender();
+        });
+        // 3. The state should *still* be Responding, not Idle.
+        // This is because the completed tool's response has not been submitted yet.
+        expect(result.current.streamingState).toBe(StreamingState.Responding);
+        // 4. Trigger the onComplete callback to simulate tool completion
+        await act(async () => {
+            if (capturedOnComplete) {
+                await capturedOnComplete(completedToolCalls);
+            }
+        });
+        // 5. Wait for submitQuery to be called
+        await waitFor(() => {
+            expect(mockSendMessageStream).toHaveBeenCalledWith(toolCallResponseParts, expect.any(AbortSignal));
+        });
+        // 6. After submission, the state should remain Responding until the stream completes.
+        expect(result.current.streamingState).toBe(StreamingState.Responding);
+    });
+    describe('User Cancellation', () => {
+        let useInputCallback;
+        const mockUseInput = useInput;
+        beforeEach(() => {
+            // Capture the callback passed to useInput
+            mockUseInput.mockImplementation((callback) => {
+                useInputCallback = callback;
+            });
+        });
+        const simulateEscapeKeyPress = () => {
+            act(() => {
+                useInputCallback('', { escape: true });
+            });
+        };
+        it('should cancel an in-progress stream when escape is pressed', async () => {
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Part 1' };
+                // Keep the stream open
+                await new Promise(() => { });
+            })();
+            mockSendMessageStream.mockReturnValue(mockStream);
+            const { result } = renderTestHook();
+            // Start a query
+            await act(async () => {
+                result.current.submitQuery('test query');
+            });
+            // Wait for the first part of the response
+            await waitFor(() => {
+                expect(result.current.streamingState).toBe(StreamingState.Responding);
+            });
+            // Simulate escape key press
+            simulateEscapeKeyPress();
+            // Verify cancellation message is added
+            await waitFor(() => {
+                expect(mockAddItem).toHaveBeenCalledWith({
+                    type: MessageType.INFO,
+                    text: 'Request cancelled.',
+                }, expect.any(Number));
+            });
+            // Verify state is reset
+            expect(result.current.streamingState).toBe(StreamingState.Idle);
+        });
+        it('should not do anything if escape is pressed when not responding', () => {
+            const { result } = renderTestHook();
+            expect(result.current.streamingState).toBe(StreamingState.Idle);
+            // Simulate escape key press
+            simulateEscapeKeyPress();
+            // No change should happen, no cancellation message
+            expect(mockAddItem).not.toHaveBeenCalledWith(expect.objectContaining({
+                text: 'Request cancelled.',
+            }), expect.any(Number));
+        });
+        it('should prevent further processing after cancellation', async () => {
+            let continueStream;
+            const streamPromise = new Promise((resolve) => {
+                continueStream = resolve;
+            });
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Initial' };
+                await streamPromise; // Wait until we manually continue
+                yield { type: 'content', value: ' Canceled' };
+            })();
+            mockSendMessageStream.mockReturnValue(mockStream);
+            const { result } = renderTestHook();
+            await act(async () => {
+                result.current.submitQuery('long running query');
+            });
+            await waitFor(() => {
+                expect(result.current.streamingState).toBe(StreamingState.Responding);
+            });
+            // Cancel the request
+            simulateEscapeKeyPress();
+            // Allow the stream to continue
+            act(() => {
+                continueStream();
+            });
+            // Wait a bit to see if the second part is processed
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            // The text should not have been updated with " Canceled"
+            const lastCall = mockAddItem.mock.calls.find((call) => call[0].type === 'gemini');
+            expect(lastCall?.[0].text).toBe('Initial');
+            // The final state should be idle after cancellation
+            expect(result.current.streamingState).toBe(StreamingState.Idle);
+        });
+        it('should not cancel if a tool call is in progress (not just responding)', async () => {
+            const toolCalls = [
+                {
+                    request: { callId: 'call1', name: 'tool1', args: {} },
+                    status: 'executing',
+                    responseSubmittedToGemini: false,
+                    tool: {
+                        name: 'tool1',
+                        description: 'desc1',
+                        getDescription: vi.fn(),
+                    },
+                    startTime: Date.now(),
+                    liveOutput: '...',
+                },
+            ];
+            const abortSpy = vi.spyOn(AbortController.prototype, 'abort');
+            const { result } = renderTestHook(toolCalls);
+            // State is `Responding` because a tool is running
+            expect(result.current.streamingState).toBe(StreamingState.Responding);
+            // Try to cancel
+            simulateEscapeKeyPress();
+            // Nothing should happen because the state is not `Responding`
+            expect(abortSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('Slash Command Handling', () => {
+        it('should schedule a tool call when the command processor returns a schedule_tool action', async () => {
+            const clientToolRequest = {
+                type: 'schedule_tool',
+                toolName: 'save_memory',
+                toolArgs: { fact: 'test fact' },
+            };
+            mockHandleSlashCommand.mockResolvedValue(clientToolRequest);
+            const { result } = renderTestHook();
+            await act(async () => {
+                await result.current.submitQuery('/memory add "test fact"');
+            });
+            await waitFor(() => {
+                expect(mockScheduleToolCalls).toHaveBeenCalledWith([
+                    expect.objectContaining({
+                        name: 'save_memory',
+                        args: { fact: 'test fact' },
+                        isClientInitiated: true,
+                    }),
+                ], expect.any(AbortSignal));
+                expect(mockSendMessageStream).not.toHaveBeenCalled();
+            });
+        });
+        it('should stop processing and not call Gemini when a command is handled without a tool call', async () => {
+            const uiOnlyCommandResult = {
+                type: 'handled',
+            };
+            mockHandleSlashCommand.mockResolvedValue(uiOnlyCommandResult);
+            const { result } = renderTestHook();
+            await act(async () => {
+                await result.current.submitQuery('/help');
+            });
+            await waitFor(() => {
+                expect(mockHandleSlashCommand).toHaveBeenCalledWith('/help');
+                expect(mockScheduleToolCalls).not.toHaveBeenCalled();
+                expect(mockSendMessageStream).not.toHaveBeenCalled(); // No LLM call made
+            });
+        });
+    });
+    describe('Memory Refresh on save_memory', () => {
+        it('should call performMemoryRefresh when a save_memory tool call completes successfully', async () => {
+            const mockPerformMemoryRefresh = vi.fn();
+            const completedToolCall = {
+                request: {
+                    callId: 'save-mem-call-1',
+                    name: 'save_memory',
+                    args: { fact: 'test' },
+                    isClientInitiated: true,
+                },
+                status: 'success',
+                responseSubmittedToGemini: false,
+                response: {
+                    callId: 'save-mem-call-1',
+                    responseParts: [{ text: 'Memory saved' }],
+                    resultDisplay: 'Success: Memory saved',
+                    error: undefined,
+                },
+                tool: {
+                    name: 'save_memory',
+                    description: 'Saves memory',
+                    getDescription: vi.fn(),
+                },
+            };
+            // Capture the onComplete callback
+            let capturedOnComplete = null;
+            mockUseReactToolScheduler.mockImplementation((onComplete) => {
+                capturedOnComplete = onComplete;
+                return [[], mockScheduleToolCalls, mockMarkToolsAsSubmitted];
+            });
+            renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockSetShowHelp, mockConfig, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, mockPerformMemoryRefresh));
+            // Trigger the onComplete callback with the completed save_memory tool
+            await act(async () => {
+                if (capturedOnComplete) {
+                    await capturedOnComplete([completedToolCall]);
+                }
+            });
+            await waitFor(() => {
+                expect(mockPerformMemoryRefresh).toHaveBeenCalledTimes(1);
+            });
+        });
+    });
+    describe('Error Handling', () => {
+        it('should call parseAndFormatApiError with the correct authType on stream initialization failure', async () => {
+            // 1. Setup
+            const mockError = new Error('Rate limit exceeded');
+            const mockAuthType = AuthType.LOGIN_WITH_GOOGLE;
+            mockParseAndFormatApiError.mockClear();
+            mockSendMessageStream.mockReturnValue((async function* () {
+                yield { type: 'content', value: '' };
+                throw mockError;
+            })());
+            const testConfig = {
+                ...mockConfig,
+                getContentGeneratorConfig: vi.fn(() => ({
+                    authType: mockAuthType,
+                })),
+            };
+            const { result } = renderHook(() => useGeminiStream(new MockedGeminiClientClass(testConfig), [], mockAddItem, mockSetShowHelp, testConfig, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve()));
+            // 2. Action
+            await act(async () => {
+                await result.current.submitQuery('test query');
+            });
+            // 3. Assertion
+            await waitFor(() => {
+                expect(mockParseAndFormatApiError).toHaveBeenCalledWith('Rate limit exceeded', mockAuthType);
+            });
+        });
+    });
+});
+//# sourceMappingURL=useGeminiStream.test.js.map