@google/gemini-cli 0.13.0-nightly.20251102.d7243fb8 → 0.13.0-preview.0

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

@@ -265,6 +265,49 @@ describe('useGeminiStream', () => {
             client,
         };
     };
+    // Helper to create mock tool calls - reduces boilerplate
+    const createMockToolCall = (toolName, callId, confirmationType, mockOnConfirm, status = 'awaiting_approval') => ({
+        request: {
+            callId,
+            name: toolName,
+            args: {},
+            isClientInitiated: false,
+            prompt_id: 'prompt-id-1',
+        },
+        status: status,
+        responseSubmittedToGemini: false,
+        confirmationDetails: confirmationType === 'edit'
+            ? {
+                type: 'edit',
+                title: 'Confirm Edit',
+                onConfirm: mockOnConfirm,
+                fileName: 'file.txt',
+                filePath: '/test/file.txt',
+                fileDiff: 'fake diff',
+                originalContent: 'old',
+                newContent: 'new',
+            }
+            : {
+                type: 'info',
+                title: `${toolName} confirmation`,
+                onConfirm: mockOnConfirm,
+                prompt: `Execute ${toolName}?`,
+            },
+        tool: {
+            name: toolName,
+            displayName: toolName,
+            description: `${toolName} description`,
+            build: vi.fn(),
+        },
+        invocation: {
+            getDescription: () => 'Mock description',
+        },
+    });
+    // Helper to render hook with default parameters - reduces boilerplate
+    const renderHookWithDefaults = (options = {}) => {
+        const { shellModeActive = false, onCancelSubmit = () => { }, setShellInputFocused = () => { }, performMemoryRefresh = () => Promise.resolve(), onAuthError = () => { }, onEditorClose = () => { }, setModelSwitched = vi.fn(), modelSwitched = false, } = options;
+        return renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockConfig, mockLoadedSettings, mockOnDebugMessage, mockHandleSlashCommand, shellModeActive, () => 'vscode', onAuthError, performMemoryRefresh, modelSwitched, setModelSwitched, onEditorClose, onCancelSubmit, setShellInputFocused, 80, 24));
+    };
     it('should not submit tool responses if not all tool calls are completed', () => {
         const toolCalls = [
             {
@@ -999,62 +1042,8 @@ describe('useGeminiStream', () => {
         it('should auto-approve all pending tool calls when switching to YOLO mode', async () => {
             const mockOnConfirm = vi.fn().mockResolvedValue(undefined);
             const awaitingApprovalToolCalls = [
-                {
-                    request: {
-                        callId: 'call1',
-                        name: 'replace',
-                        args: { old_string: 'old', new_string: 'new' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'edit',
-                        title: 'Confirm Edit',
-                        onConfirm: mockOnConfirm,
-                        fileName: 'file.txt',
-                        filePath: '/test/file.txt',
-                        fileDiff: 'fake diff',
-                        originalContent: 'old',
-                        newContent: 'new',
-                    },
-                    tool: {
-                        name: 'replace',
-                        displayName: 'replace',
-                        description: 'Replace text',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
-                {
-                    request: {
-                        callId: 'call2',
-                        name: 'read_file',
-                        args: { path: '/test/file.txt' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'info',
-                        title: 'Read File',
-                        onConfirm: mockOnConfirm,
-                        prompt: 'Read /test/file.txt?',
-                    },
-                    tool: {
-                        name: 'read_file',
-                        displayName: 'read_file',
-                        description: 'Read file',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
+                createMockToolCall('replace', 'call1', 'edit', mockOnConfirm),
+                createMockToolCall('read_file', 'call2', 'info', mockOnConfirm),
             ];
             const { result } = renderTestHook(awaitingApprovalToolCalls);
             await act(async () => {
@@ -1062,109 +1051,23 @@ describe('useGeminiStream', () => {
             });
             // Both tool calls should be auto-approved
             expect(mockOnConfirm).toHaveBeenCalledTimes(2);
-            expect(mockOnConfirm).toHaveBeenNthCalledWith(1, ToolConfirmationOutcome.ProceedOnce);
-            expect(mockOnConfirm).toHaveBeenNthCalledWith(2, ToolConfirmationOutcome.ProceedOnce);
+            expect(mockOnConfirm).toHaveBeenCalledWith(ToolConfirmationOutcome.ProceedOnce);
         });
         it('should only auto-approve edit tools when switching to AUTO_EDIT mode', async () => {
             const mockOnConfirmReplace = vi.fn().mockResolvedValue(undefined);
             const mockOnConfirmWrite = vi.fn().mockResolvedValue(undefined);
             const mockOnConfirmRead = vi.fn().mockResolvedValue(undefined);
             const awaitingApprovalToolCalls = [
-                {
-                    request: {
-                        callId: 'call1',
-                        name: 'replace',
-                        args: { old_string: 'old', new_string: 'new' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'edit',
-                        title: 'Confirm Edit',
-                        onConfirm: mockOnConfirmReplace,
-                        fileName: 'file.txt',
-                        filePath: '/test/file.txt',
-                        fileDiff: 'fake diff',
-                        originalContent: 'old',
-                        newContent: 'new',
-                    },
-                    tool: {
-                        name: 'replace',
-                        displayName: 'replace',
-                        description: 'Replace text',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
-                {
-                    request: {
-                        callId: 'call2',
-                        name: 'write_file',
-                        args: { path: '/test/new.txt', content: 'content' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'edit',
-                        title: 'Confirm Edit',
-                        onConfirm: mockOnConfirmWrite,
-                        fileName: 'new.txt',
-                        filePath: '/test/new.txt',
-                        fileDiff: 'fake diff',
-                        originalContent: null,
-                        newContent: 'content',
-                    },
-                    tool: {
-                        name: 'write_file',
-                        displayName: 'write_file',
-                        description: 'Write file',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
-                {
-                    request: {
-                        callId: 'call3',
-                        name: 'read_file',
-                        args: { path: '/test/file.txt' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'info',
-                        title: 'Read File',
-                        onConfirm: mockOnConfirmRead,
-                        prompt: 'Read /test/file.txt?',
-                    },
-                    tool: {
-                        name: 'read_file',
-                        displayName: 'read_file',
-                        description: 'Read file',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
+                createMockToolCall('replace', 'call1', 'edit', mockOnConfirmReplace),
+                createMockToolCall('write_file', 'call2', 'edit', mockOnConfirmWrite),
+                createMockToolCall('read_file', 'call3', 'info', mockOnConfirmRead),
             ];
             const { result } = renderTestHook(awaitingApprovalToolCalls);
             await act(async () => {
                 await result.current.handleApprovalModeChange(ApprovalMode.AUTO_EDIT);
             });
             // Only replace and write_file should be auto-approved
-            expect(mockOnConfirmReplace).toHaveBeenCalledTimes(1);
             expect(mockOnConfirmReplace).toHaveBeenCalledWith(ToolConfirmationOutcome.ProceedOnce);
-            expect(mockOnConfirmWrite).toHaveBeenCalledTimes(1);
             expect(mockOnConfirmWrite).toHaveBeenCalledWith(ToolConfirmationOutcome.ProceedOnce);
             // read_file should not be auto-approved
             expect(mockOnConfirmRead).not.toHaveBeenCalled();
@@ -1172,36 +1075,7 @@ describe('useGeminiStream', () => {
         it('should not auto-approve any tools when switching to REQUIRE_CONFIRMATION mode', async () => {
             const mockOnConfirm = vi.fn().mockResolvedValue(undefined);
             const awaitingApprovalToolCalls = [
-                {
-                    request: {
-                        callId: 'call1',
-                        name: 'replace',
-                        args: { old_string: 'old', new_string: 'new' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'edit',
-                        title: 'Confirm Edit',
-                        onConfirm: mockOnConfirm,
-                        fileName: 'file.txt',
-                        filePath: '/test/file.txt',
-                        fileDiff: 'fake diff',
-                        originalContent: 'old',
-                        newContent: 'new',
-                    },
-                    tool: {
-                        name: 'replace',
-                        displayName: 'replace',
-                        description: 'Replace text',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
+                createMockToolCall('replace', 'call1', 'edit', mockOnConfirm),
             ];
             const { result } = renderTestHook(awaitingApprovalToolCalls);
             await act(async () => {
@@ -1219,74 +1093,16 @@ describe('useGeminiStream', () => {
                 .fn()
                 .mockRejectedValue(new Error('Approval failed'));
             const awaitingApprovalToolCalls = [
-                {
-                    request: {
-                        callId: 'call1',
-                        name: 'replace',
-                        args: { old_string: 'old', new_string: 'new' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'edit',
-                        title: 'Confirm Edit',
-                        onConfirm: mockOnConfirmSuccess,
-                        fileName: 'file.txt',
-                        filePath: '/test/file.txt',
-                        fileDiff: 'fake diff',
-                        originalContent: 'old',
-                        newContent: 'new',
-                    },
-                    tool: {
-                        name: 'replace',
-                        displayName: 'replace',
-                        description: 'Replace text',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
-                {
-                    request: {
-                        callId: 'call2',
-                        name: 'write_file',
-                        args: { path: '/test/file.txt', content: 'content' },
-                        isClientInitiated: false,
-                        prompt_id: 'prompt-id-1',
-                    },
-                    status: 'awaiting_approval',
-                    responseSubmittedToGemini: false,
-                    confirmationDetails: {
-                        type: 'edit',
-                        title: 'Confirm Edit',
-                        onConfirm: mockOnConfirmError,
-                        fileName: 'file.txt',
-                        filePath: '/test/file.txt',
-                        fileDiff: 'fake diff',
-                        originalContent: null,
-                        newContent: 'content',
-                    },
-                    tool: {
-                        name: 'write_file',
-                        displayName: 'write_file',
-                        description: 'Write file',
-                        build: vi.fn(),
-                    },
-                    invocation: {
-                        getDescription: () => 'Mock description',
-                    },
-                },
+                createMockToolCall('replace', 'call1', 'edit', mockOnConfirmSuccess),
+                createMockToolCall('write_file', 'call2', 'edit', mockOnConfirmError),
             ];
             const { result } = renderTestHook(awaitingApprovalToolCalls);
             await act(async () => {
                 await result.current.handleApprovalModeChange(ApprovalMode.YOLO);
             });
             // Both confirmation methods should be called
-            expect(mockOnConfirmSuccess).toHaveBeenCalledTimes(1);
-            expect(mockOnConfirmError).toHaveBeenCalledTimes(1);
+            expect(mockOnConfirmSuccess).toHaveBeenCalled();
+            expect(mockOnConfirmError).toHaveBeenCalled();
             // Error should be logged
             expect(debuggerSpy).toHaveBeenCalledWith('Failed to auto-approve tool call call2:', expect.any(Error));
             debuggerSpy.mockRestore();
@@ -1456,53 +1272,37 @@ describe('useGeminiStream', () => {
             beforeEach(() => {
                 vi.mocked(tokenLimit).mockReturnValue(100);
             });
-            it('should add message without suggestion when remaining tokens are > 75% of limit', async () => {
-                // Setup mock to return a stream with ContextWindowWillOverflow event
-                // Limit is 100, remaining is 80 (> 75)
-                mockSendMessageStream.mockReturnValue((async function* () {
-                    yield {
-                        type: ServerGeminiEventType.ContextWindowWillOverflow,
-                        value: {
-                            estimatedRequestTokenCount: 20,
-                            remainingTokenCount: 80,
-                        },
-                    };
-                })());
-                const { result } = renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockConfig, mockLoadedSettings, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve(), false, () => { }, () => { }, () => { }, () => { }, 80, 24));
-                // Submit a query
-                await act(async () => {
-                    await result.current.submitQuery('Test overflow');
-                });
-                // Check that the message was added without suggestion
-                await waitFor(() => {
-                    expect(mockAddItem).toHaveBeenCalledWith({
-                        type: 'info',
-                        text: `Sending this message (20 tokens) might exceed the remaining context window limit (80 tokens).`,
-                    }, expect.any(Number));
-                });
-            });
-            it('should add message with suggestion when remaining tokens are < 75% of limit', async () => {
-                // Setup mock to return a stream with ContextWindowWillOverflow event
-                // Limit is 100, remaining is 70 (< 75)
+            it.each([
+                {
+                    name: 'without suggestion when remaining tokens are > 75% of limit',
+                    requestTokens: 20,
+                    remainingTokens: 80,
+                    expectedMessage: 'Sending this message (20 tokens) might exceed the remaining context window limit (80 tokens).',
+                },
+                {
+                    name: 'with suggestion when remaining tokens are < 75% of limit',
+                    requestTokens: 30,
+                    remainingTokens: 70,
+                    expectedMessage: 'Sending this message (30 tokens) might exceed the remaining context window limit (70 tokens). Please try reducing the size of your message or use the `/compress` command to compress the chat history.',
+                },
+            ])('should add message $name', async ({ requestTokens, remainingTokens, expectedMessage }) => {
                 mockSendMessageStream.mockReturnValue((async function* () {
                     yield {
                         type: ServerGeminiEventType.ContextWindowWillOverflow,
                         value: {
-                            estimatedRequestTokenCount: 30,
-                            remainingTokenCount: 70,
+                            estimatedRequestTokenCount: requestTokens,
+                            remainingTokenCount: remainingTokens,
                         },
                     };
                 })());
-                const { result } = renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockConfig, mockLoadedSettings, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve(), false, () => { }, () => { }, () => { }, () => { }, 80, 24));
-                // Submit a query
+                const { result } = renderHookWithDefaults();
                 await act(async () => {
                     await result.current.submitQuery('Test overflow');
                 });
-                // Check that the message was added with suggestion
                 await waitFor(() => {
                     expect(mockAddItem).toHaveBeenCalledWith({
                         type: 'info',
-                        text: `Sending this message (30 tokens) might exceed the remaining context window limit (70 tokens). Please try reducing the size of your message or use the \`/compress\` command to compress the chat history.`,
+                        text: expectedMessage,
                     }, expect.any(Number));
                 });
             });
@@ -1529,112 +1329,71 @@ describe('useGeminiStream', () => {
                 expect(onCancelSubmitSpy).toHaveBeenCalled();
             });
         });
-        it('should not add message for STOP finish reason', async () => {
-            // Setup mock to return a stream with STOP finish reason
-            mockSendMessageStream.mockReturnValue((async function* () {
-                yield {
-                    type: ServerGeminiEventType.Content,
-                    value: 'Complete response',
-                };
-                yield {
-                    type: ServerGeminiEventType.Finished,
-                    value: { reason: 'STOP', usageMetadata: undefined },
-                };
-            })());
-            const { result } = renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockConfig, mockLoadedSettings, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve(), false, () => { }, () => { }, () => { }, () => { }, 80, 24));
-            // Submit a query
-            await act(async () => {
-                await result.current.submitQuery('Test normal completion');
-            });
-            // Wait a bit to ensure no message is added
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Check that no info message was added for STOP
-            const infoMessages = mockAddItem.mock.calls.filter((call) => call[0].type === 'info');
-            expect(infoMessages).toHaveLength(0);
-        });
-        it('should not add message for FINISH_REASON_UNSPECIFIED', async () => {
-            // Setup mock to return a stream with FINISH_REASON_UNSPECIFIED
+        it.each([
+            {
+                reason: 'STOP',
+                shouldAddMessage: false,
+            },
+            {
+                reason: 'FINISH_REASON_UNSPECIFIED',
+                shouldAddMessage: false,
+            },
+            {
+                reason: 'SAFETY',
+                message: '⚠️  Response stopped due to safety reasons.',
+            },
+            {
+                reason: 'RECITATION',
+                message: '⚠️  Response stopped due to recitation policy.',
+            },
+            {
+                reason: 'LANGUAGE',
+                message: '⚠️  Response stopped due to unsupported language.',
+            },
+            {
+                reason: 'BLOCKLIST',
+                message: '⚠️  Response stopped due to forbidden terms.',
+            },
+            {
+                reason: 'PROHIBITED_CONTENT',
+                message: '⚠️  Response stopped due to prohibited content.',
+            },
+            {
+                reason: 'SPII',
+                message: '⚠️  Response stopped due to sensitive personally identifiable information.',
+            },
+            {
+                reason: 'OTHER',
+                message: '⚠️  Response stopped for other reasons.',
+            },
+            {
+                reason: 'MALFORMED_FUNCTION_CALL',
+                message: '⚠️  Response stopped due to malformed function call.',
+            },
+            {
+                reason: 'IMAGE_SAFETY',
+                message: '⚠️  Response stopped due to image safety violations.',
+            },
+            {
+                reason: 'UNEXPECTED_TOOL_CALL',
+                message: '⚠️  Response stopped due to unexpected tool call.',
+            },
+        ])('should handle $reason finish reason correctly', async ({ reason, shouldAddMessage = true, message }) => {
             mockSendMessageStream.mockReturnValue((async function* () {
                 yield {
                     type: ServerGeminiEventType.Content,
-                    value: 'Response with unspecified finish',
+                    value: `Response for ${reason}`,
                 };
                 yield {
                     type: ServerGeminiEventType.Finished,
-                    value: {
-                        reason: 'FINISH_REASON_UNSPECIFIED',
-                        usageMetadata: undefined,
-                    },
+                    value: { reason, usageMetadata: undefined },
                 };
             })());
-            const { result } = renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockConfig, mockLoadedSettings, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve(), false, () => { }, () => { }, () => { }, () => { }, 80, 24));
-            // Submit a query
+            const { result } = renderHookWithDefaults();
             await act(async () => {
-                await result.current.submitQuery('Test unspecified finish');
+                await result.current.submitQuery(`Test ${reason}`);
             });
-            // Wait a bit to ensure no message is added
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Check that no info message was added
-            const infoMessages = mockAddItem.mock.calls.filter((call) => call[0].type === 'info');
-            expect(infoMessages).toHaveLength(0);
-        });
-        it('should add appropriate messages for other finish reasons', async () => {
-            const testCases = [
-                {
-                    reason: 'SAFETY',
-                    message: '⚠️  Response stopped due to safety reasons.',
-                },
-                {
-                    reason: 'RECITATION',
-                    message: '⚠️  Response stopped due to recitation policy.',
-                },
-                {
-                    reason: 'LANGUAGE',
-                    message: '⚠️  Response stopped due to unsupported language.',
-                },
-                {
-                    reason: 'BLOCKLIST',
-                    message: '⚠️  Response stopped due to forbidden terms.',
-                },
-                {
-                    reason: 'PROHIBITED_CONTENT',
-                    message: '⚠️  Response stopped due to prohibited content.',
-                },
-                {
-                    reason: 'SPII',
-                    message: '⚠️  Response stopped due to sensitive personally identifiable information.',
-                },
-                { reason: 'OTHER', message: '⚠️  Response stopped for other reasons.' },
-                {
-                    reason: 'MALFORMED_FUNCTION_CALL',
-                    message: '⚠️  Response stopped due to malformed function call.',
-                },
-                {
-                    reason: 'IMAGE_SAFETY',
-                    message: '⚠️  Response stopped due to image safety violations.',
-                },
-                {
-                    reason: 'UNEXPECTED_TOOL_CALL',
-                    message: '⚠️  Response stopped due to unexpected tool call.',
-                },
-            ];
-            for (const { reason, message } of testCases) {
-                // Reset mocks for each test case
-                mockAddItem.mockClear();
-                mockSendMessageStream.mockReturnValue((async function* () {
-                    yield {
-                        type: ServerGeminiEventType.Content,
-                        value: `Response for ${reason}`,
-                    };
-                    yield {
-                        type: ServerGeminiEventType.Finished,
-                        value: { reason, usageMetadata: undefined },
-                    };
-                })());
-                const { result } = renderHook(() => useGeminiStream(new MockedGeminiClientClass(mockConfig), [], mockAddItem, mockConfig, mockLoadedSettings, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve(), false, () => { }, () => { }, () => { }, vi.fn(), 80, 24));
-                await act(async () => {
-                    await result.current.submitQuery(`Test ${reason}`);
-                });
+            if (shouldAddMessage) {
                 await waitFor(() => {
                     expect(mockAddItem).toHaveBeenCalledWith({
                         type: 'info',
@@ -1642,6 +1401,14 @@ describe('useGeminiStream', () => {
                     }, expect.any(Number));
                 });
             }
+            else {
+                // Verify state returns to idle without any info messages
+                await waitFor(() => {
+                    expect(result.current.streamingState).toBe(StreamingState.Idle);
+                });
+                const infoMessages = mockAddItem.mock.calls.filter((call) => call[0].type === 'info');
+                expect(infoMessages).toHaveLength(0);
+            }
         });
     });
     it('should process @include commands, adding user turn after processing to prevent race conditions', async () => {