@machina.ai/cell-cli 1.64.0-rc2 → 1.66.0-rc1

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

@@ -12,7 +12,7 @@ import { useGeminiStream } from './useGeminiStream.js';
 import { useKeypress } from './useKeypress.js';
 import * as atCommandProcessor from './atCommandProcessor.js';
 import { useToolScheduler, } from './useToolScheduler.js';
-import { CoreToolCallStatus, ApprovalMode, DEFAULT_GEMINI_FLASH_MODEL, AuthType, GeminiEventType as ServerGeminiEventType, uiTelemetryService, ToolErrorType, ToolConfirmationOutcome, MessageBusType, tokenLimit, debugLogger, coreEvents, CoreEvent, SHELL_TOOL_NAME, MCPDiscoveryState, GeminiCliOperation, getPlanModeExitMessage, UPDATE_TOPIC_TOOL_NAME, TRUE_EMPTY_RESPONSE_MESSAGE, } from '@google/gemini-cli-core';
+import { CoreToolCallStatus, ApprovalMode, DEFAULT_GEMINI_FLASH_MODEL, AuthType, GeminiEventType as ServerGeminiEventType, uiTelemetryService, ToolErrorType, ToolConfirmationOutcome, MessageBusType, tokenLimit, debugLogger, coreEvents, CoreEvent, SHELL_TOOL_NAME, MCPDiscoveryState, GeminiCliOperation, getPlanModeExitMessage, UPDATE_TOPIC_TOOL_NAME, TRUE_EMPTY_RESPONSE_MESSAGE, Kind, } from '@google/gemini-cli-core';
 import { MessageType, StreamingState } from '../types.js';
 import { findLastSafeSplitPoint } from '../utils/markdownUtilities.js';
 import { theme } from '../semantic-colors.js';
@@ -1732,7 +1732,7 @@ describe('useGeminiStream', () => {
             expect(result.current.retryStatus).toEqual(retryPayload);
             // Cancel to make isResponding false
             await act(async () => {
-                result.current.cancelOngoingRequest();
+                await result.current.cancelOngoingRequest();
             });
             expect(result.current.retryStatus).toBeNull();
         });
@@ -1767,7 +1767,7 @@ describe('useGeminiStream', () => {
             });
             expect(result.current.retryStatus).toEqual(retryPayload);
             await act(async () => {
-                result.current.cancelOngoingRequest();
+                await result.current.cancelOngoingRequest();
             });
             await waitFor(() => {
                 expect(result.current.retryStatus).toBeNull();
@@ -3223,6 +3223,133 @@ describe('useGeminiStream', () => {
             });
         });
     });
+    describe('Grouped Tool Calls', () => {
+        const createToolCall = (callId, { status = CoreToolCallStatus.Success, kind = Kind.Agent, groupId, } = {}) => ({
+            request: {
+                callId,
+                name: `tool-${callId}`,
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-1',
+                groupId,
+            },
+            status,
+            responseSubmittedToGemini: false,
+            response: {
+                callId,
+                responseParts: [],
+                resultDisplay: `result of ${callId}`,
+                error: undefined,
+                errorType: undefined,
+            },
+            tool: {
+                name: `tool-${callId}`,
+                displayName: `tool-${callId}`,
+                description: `description of ${callId}`,
+                kind,
+                build: vi.fn(),
+            },
+            invocation: {
+                getDescription: () => `Mock description of ${callId}`,
+            },
+        });
+        const setToolCalls = (toolCalls) => {
+            mockUseToolScheduler.mockReturnValue([
+                toolCalls,
+                mockScheduleToolCalls,
+                mockMarkToolsAsSubmitted,
+                vi.fn(),
+                mockCancelAllToolCalls,
+                0,
+            ]);
+        };
+        const renderWithToolCalls = async (toolCalls) => {
+            setToolCalls(toolCalls);
+            return renderHookWithProviders(() => useGeminiStream(mockConfig.getGeminiClient(), [], mockAddItem, mockConfig, mockLoadedSettings, mockOnDebugMessage, mockHandleSlashCommand, false, () => 'vscode', () => { }, () => Promise.resolve(), false, () => { }, () => { }, () => { }, 80, 24));
+        };
+        // The call IDs of every tool group pushed to history. `useStateAndRef` is
+        // mocked in this file, so the effect that pushes finished tools starts from
+        // scratch on every render. The assertions below therefore check which
+        // groups were pushed rather than how many times `addItem` was called.
+        const getPushedGroups = () => mockAddItem.mock.calls
+            .map(([item]) => item)
+            .filter((item) => item.type === 'tool_group')
+            .map((item) => item.tools.map((tool) => tool.callId));
+        it('should hold back a group until every call in it has finished', async () => {
+            const { rerender } = await renderWithToolCalls([
+                createToolCall('agent-1', { groupId: 'agent-1' }),
+                createToolCall('agent-2', {
+                    status: CoreToolCallStatus.Executing,
+                    groupId: 'agent-1',
+                }),
+            ]);
+            expect(getPushedGroups()).toEqual([]);
+            setToolCalls([
+                createToolCall('agent-1', { groupId: 'agent-1' }),
+                createToolCall('agent-2', { groupId: 'agent-1' }),
+            ]);
+            rerender();
+            expect(getPushedGroups()).toContainEqual(['agent-1', 'agent-2']);
+        });
+        it('should treat failed and cancelled calls as finished', async () => {
+            await renderWithToolCalls([
+                createToolCall('agent-1', { groupId: 'agent-1' }),
+                createToolCall('agent-2', {
+                    status: CoreToolCallStatus.Error,
+                    groupId: 'agent-1',
+                }),
+                createToolCall('agent-3', {
+                    status: CoreToolCallStatus.Cancelled,
+                    groupId: 'agent-1',
+                }),
+            ]);
+            expect(getPushedGroups()).toContainEqual([
+                'agent-1',
+                'agent-2',
+                'agent-3',
+            ]);
+        });
+        it('should group by group ID rather than by tool kind', async () => {
+            const { rerender } = await renderWithToolCalls([
+                createToolCall('read-1', { kind: Kind.Read, groupId: 'read-1' }),
+                createToolCall('read-2', {
+                    kind: Kind.Read,
+                    status: CoreToolCallStatus.Executing,
+                    groupId: 'read-1',
+                }),
+            ]);
+            expect(getPushedGroups()).toEqual([]);
+            setToolCalls([
+                createToolCall('read-1', { kind: Kind.Read, groupId: 'read-1' }),
+                createToolCall('read-2', { kind: Kind.Read, groupId: 'read-1' }),
+            ]);
+            rerender();
+            expect(getPushedGroups()).toContainEqual(['read-1', 'read-2']);
+        });
+        it('should push calls without a group ID individually, whatever their kind', async () => {
+            await renderWithToolCalls([
+                createToolCall('agent-1'),
+                createToolCall('agent-2'),
+            ]);
+            const groups = getPushedGroups();
+            expect(groups).toContainEqual(['agent-1']);
+            expect(groups).toContainEqual(['agent-2']);
+            expect(groups).not.toContainEqual(['agent-1', 'agent-2']);
+        });
+        it('should push finished calls ahead of a group that is still running', async () => {
+            await renderWithToolCalls([
+                createToolCall('read-1', { kind: Kind.Read }),
+                createToolCall('agent-1', { groupId: 'agent-1' }),
+                createToolCall('agent-2', {
+                    status: CoreToolCallStatus.Executing,
+                    groupId: 'agent-1',
+                }),
+            ]);
+            const groups = getPushedGroups();
+            expect(groups).toContainEqual(['read-1']);
+            expect(groups.flat()).not.toContain('agent-1');
+        });
+    });
     describe('Stream Splitting', () => {
         it('should not add empty history item when splitting message results in empty or whitespace-only beforeText', async () => {
             // Mock split point to always be 0, causing beforeText to be empty
@@ -3291,5 +3418,105 @@ describe('useGeminiStream', () => {
         });
         expect(spanMetadata.input).toBe('telemetry test query');
     });
+    describe('cancelOngoingRequest session log harmonization & timeout bound', () => {
+        it('immediately synthesizes and records filler functionResponse via recordCompletedToolCalls when cancelling active tools', async () => {
+            const executingToolCall = {
+                request: {
+                    callId: 'call-abc',
+                    name: 'run_shell_command',
+                    args: { command: 'sleep 30' },
+                    isClientInitiated: false,
+                    prompt_id: 'prompt-1',
+                },
+                status: CoreToolCallStatus.Executing,
+                tool: {
+                    name: 'run_shell_command',
+                    displayName: 'Shell',
+                },
+                invocation: {
+                    getDescription: () => 'sleep 30',
+                },
+            };
+            const { result, client } = await renderTestHook([executingToolCall]);
+            const mockRecordCompletedToolCalls = client.getChat().recordCompletedToolCalls;
+            await act(async () => {
+                await result.current.cancelOngoingRequest();
+            });
+            expect(mockCancelAllToolCalls).toHaveBeenCalledTimes(1);
+            expect(mockRecordCompletedToolCalls).toHaveBeenCalledTimes(1);
+            expect(mockRecordCompletedToolCalls).toHaveBeenCalledWith(expect.any(String), [
+                expect.objectContaining({
+                    status: CoreToolCallStatus.Cancelled,
+                    request: executingToolCall.request,
+                    response: expect.objectContaining({
+                        callId: 'call-abc',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    id: 'call-abc',
+                                    name: 'run_shell_command',
+                                    response: {
+                                        error: '[Operation Cancelled] Reason: User cancelled operation',
+                                    },
+                                },
+                            },
+                        ],
+                    }),
+                }),
+            ]);
+        });
+        it('bounds waiting on an unresponsive tool schedule promise at 1000ms', async () => {
+            vi.useFakeTimers();
+            try {
+                mockScheduleToolCalls.mockImplementation(() => new Promise(() => { }));
+                mockSendMessageStream.mockReturnValue((async function* () {
+                    yield {
+                        type: ServerGeminiEventType.ToolCallRequest,
+                        value: {
+                            callId: 'call-hang',
+                            name: 'hanging_tool',
+                            args: {},
+                            isClientInitiated: false,
+                            prompt_id: 'prompt-hang',
+                        },
+                    };
+                })());
+                const { result, client } = await renderTestHook();
+                const mockRecordCompletedToolCalls = client.getChat().recordCompletedToolCalls;
+                act(() => {
+                    void result.current.submitQuery('run hanging tool');
+                });
+                await act(async () => {
+                    await vi.advanceTimersByTimeAsync(10);
+                });
+                expect(mockScheduleToolCalls).toHaveBeenCalledTimes(1);
+                let cancelResolved = false;
+                let cancelPromise;
+                act(() => {
+                    cancelPromise = result.current.cancelOngoingRequest().then(() => {
+                        cancelResolved = true;
+                    });
+                });
+                expect(mockRecordCompletedToolCalls).toHaveBeenCalledWith(expect.any(String), [
+                    expect.objectContaining({
+                        status: CoreToolCallStatus.Cancelled,
+                        request: expect.objectContaining({
+                            callId: 'call-hang',
+                            name: 'hanging_tool',
+                        }),
+                    }),
+                ]);
+                expect(cancelResolved).toBe(false);
+                await act(async () => {
+                    await vi.advanceTimersByTimeAsync(1000);
+                    await cancelPromise;
+                });
+                expect(cancelResolved).toBe(true);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+    });
 });
 //# sourceMappingURL=useGeminiStream.test.js.map