@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc2

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

@@ -4,13 +4,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
+import { act } from 'react';
+import { renderHook } from '../../test-utils/render.js';
 import { useReactToolScheduler, mapToDisplay, } from './useReactToolScheduler.js';
 import { DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES, DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD, ToolConfirmationOutcome, ApprovalMode, MockTool, } from '@google/gemini-cli-core';
 import { ToolCallStatus } from '../types.js';
 // Mocks
 vi.mock('@google/gemini-cli-core', async () => {
     const actual = await vi.importActual('@google/gemini-cli-core');
+    // Patch CoreToolScheduler to have cancelAll if it's missing in the test environment
+    if (actual.CoreToolScheduler &&
+        !actual.CoreToolScheduler.prototype.cancelAll) {
+        actual.CoreToolScheduler.prototype.cancelAll = vi.fn();
+    }
     return {
         ...actual,
         ToolRegistry: vi.fn(),
@@ -70,10 +76,8 @@ const mockToolRequiresConfirmation = new MockTool({
 });
 describe('useReactToolScheduler in YOLO Mode', () => {
     let onComplete;
-    let setPendingHistoryItem;
     beforeEach(() => {
         onComplete = vi.fn();
-        setPendingHistoryItem = vi.fn();
         mockToolRegistry.getTool.mockClear();
         mockToolRequiresConfirmation.execute.mockClear();
         mockToolRequiresConfirmation.shouldConfirmExecute.mockClear();
@@ -87,7 +91,7 @@ describe('useReactToolScheduler in YOLO Mode', () => {
         // IMPORTANT: Disable YOLO mode after this test suite
         mockConfig.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
     });
-    const renderSchedulerInYoloMode = () => renderHook(() => useReactToolScheduler(onComplete, mockConfig, setPendingHistoryItem, () => { }));
+    const renderSchedulerInYoloMode = () => renderHook(() => useReactToolScheduler(onComplete, mockConfig, () => undefined, () => { }));
     it('should skip confirmation and execute tool directly when yoloMode is true', async () => {
         mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
         const expectedOutput = 'YOLO Confirmed output';
@@ -106,13 +110,13 @@ describe('useReactToolScheduler in YOLO Mode', () => {
             schedule(request, new AbortController().signal);
         });
         await act(async () => {
-            await vi.runAllTimersAsync(); // Process validation
+            await vi.advanceTimersByTimeAsync(0); // Process validation
         });
         await act(async () => {
-            await vi.runAllTimersAsync(); // Process scheduling
+            await vi.advanceTimersByTimeAsync(0); // Process scheduling
         });
         await act(async () => {
-            await vi.runAllTimersAsync(); // Process execution
+            await vi.advanceTimersByTimeAsync(0); // Process execution
         });
         // Check that execute WAS called
         expect(mockToolRequiresConfirmation.execute).toHaveBeenCalledWith(request.args);
@@ -135,49 +139,27 @@ describe('useReactToolScheduler in YOLO Mode', () => {
                 }),
             }),
         ]);
-        // Ensure no confirmation UI was triggered (setPendingHistoryItem should not have been called with confirmation details)
-        const setPendingHistoryItemCalls = setPendingHistoryItem.mock.calls;
-        const confirmationCall = setPendingHistoryItemCalls.find((call) => {
-            const item = typeof call[0] === 'function' ? call[0]({}) : call[0];
-            return item?.tools?.[0]?.confirmationDetails;
-        });
-        expect(confirmationCall).toBeUndefined();
     });
 });
 describe('useReactToolScheduler', () => {
-    // TODO(ntaylormullen): The following tests are skipped due to difficulties in
-    // reliably testing the asynchronous state updates and interactions with timers.
-    // These tests involve complex sequences of events, including confirmations,
-    // live output updates, and cancellations, which are challenging to assert
-    // correctly with the current testing setup. Further investigation is needed
-    // to find a robust way to test these scenarios.
     let onComplete;
-    let setPendingHistoryItem;
     let capturedOnConfirmForTest;
+    const advanceAndSettle = async () => {
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(0);
+        });
+    };
+    const scheduleAndWaitForExecution = async (schedule, request) => {
+        act(() => {
+            schedule(request, new AbortController().signal);
+        });
+        await advanceAndSettle();
+        await advanceAndSettle();
+        await advanceAndSettle();
+    };
     beforeEach(() => {
         onComplete = vi.fn();
         capturedOnConfirmForTest = undefined;
-        setPendingHistoryItem = vi.fn((updaterOrValue) => {
-            let pendingItem = null;
-            if (typeof updaterOrValue === 'function') {
-                // Loosen the type for prevState to allow for more flexible updates in tests
-                const prevState = {
-                    type: 'tool_group', // Still default to tool_group for most cases
-                    tools: [],
-                };
-                pendingItem = updaterOrValue(prevState); // Allow any for more flexibility
-            }
-            else {
-                pendingItem = updaterOrValue;
-            }
-            // Capture onConfirm if it exists, regardless of the exact type of pendingItem
-            // This is a common pattern in these tests.
-            if (pendingItem?.tools?.[0]?.confirmationDetails
-                ?.onConfirm) {
-                capturedOnConfirmForTest = pendingItem
-                    .tools[0].confirmationDetails?.onConfirm;
-            }
-        });
         mockToolRegistry.getTool.mockClear();
         mockTool.execute.mockClear();
         mockTool.shouldConfirmExecute.mockClear();
@@ -199,7 +181,7 @@ describe('useReactToolScheduler', () => {
         vi.clearAllTimers();
         vi.useRealTimers();
     });
-    const renderScheduler = () => renderHook(() => useReactToolScheduler(onComplete, mockConfig, setPendingHistoryItem, () => { }));
+    const renderScheduler = () => renderHook(() => useReactToolScheduler(onComplete, mockConfig, () => undefined, () => { }));
     it('initial state should be empty', () => {
         const { result } = renderScheduler();
         expect(result.current[0]).toEqual([]);
@@ -212,120 +194,81 @@ describe('useReactToolScheduler', () => {
         });
         mockTool.shouldConfirmExecute.mockResolvedValue(null);
         const { result } = renderScheduler();
-        const schedule = result.current[1];
         const request = {
             callId: 'call1',
             name: 'mockTool',
             args: { param: 'value' },
         };
-        act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
+        let completedToolCalls = [];
+        onComplete.mockImplementation((calls) => {
+            completedToolCalls = calls;
         });
+        await scheduleAndWaitForExecution(result.current[1], request);
         expect(mockTool.execute).toHaveBeenCalledWith(request.args);
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'success',
-                request,
-                response: expect.objectContaining({
-                    resultDisplay: 'Formatted tool output',
-                    responseParts: [
-                        {
-                            functionResponse: {
-                                id: 'call1',
-                                name: 'mockTool',
-                                response: { output: 'Tool output' },
-                            },
-                        },
-                    ],
-                }),
-            }),
-        ]);
-        expect(result.current[0]).toEqual([]);
+        expect(completedToolCalls).toHaveLength(1);
+        expect(completedToolCalls[0].status).toBe('success');
+        expect(completedToolCalls[0].request).toBe(request);
+        if (completedToolCalls[0].status === 'success' ||
+            completedToolCalls[0].status === 'error') {
+            expect(completedToolCalls[0].response).toMatchSnapshot();
+        }
     });
-    it('should handle tool not found', async () => {
-        mockToolRegistry.getTool.mockReturnValue(undefined);
+    it('should clear previous tool calls when scheduling new ones', async () => {
+        mockToolRegistry.getTool.mockReturnValue(mockTool);
+        mockTool.execute.mockResolvedValue({
+            llmContent: 'Tool output',
+            returnDisplay: 'Formatted tool output',
+        });
         const { result } = renderScheduler();
         const schedule = result.current[1];
-        const request = {
-            callId: 'call1',
-            name: 'nonexistentTool',
-            args: {},
+        const setToolCallsForDisplay = result.current[3];
+        // Manually set a tool call in the display.
+        const oldToolCall = {
+            request: { callId: 'oldCall' },
+            status: 'success',
         };
         act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
+            setToolCallsForDisplay([oldToolCall]);
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'error',
-                request,
-                response: expect.objectContaining({
-                    error: expect.objectContaining({
-                        message: expect.stringMatching(/Tool "nonexistentTool" not found in registry/),
-                    }),
-                }),
-            }),
-        ]);
-        const errorMessage = onComplete.mock.calls[0][0][0].response.error.message;
-        expect(errorMessage).toContain('Did you mean one of:');
-        expect(errorMessage).toContain('"mockTool"');
-        expect(errorMessage).toContain('"anotherTool"');
-        expect(result.current[0]).toEqual([]);
-    });
-    it('should handle error during shouldConfirmExecute', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockTool);
-        const confirmError = new Error('Confirmation check failed');
-        mockTool.shouldConfirmExecute.mockRejectedValue(confirmError);
-        const { result } = renderScheduler();
-        const schedule = result.current[1];
-        const request = {
-            callId: 'call1',
+        expect(result.current[0]).toEqual([oldToolCall]);
+        const newRequest = {
+            callId: 'newCall',
             name: 'mockTool',
             args: {},
         };
         act(() => {
-            schedule(request, new AbortController().signal);
+            schedule(newRequest, new AbortController().signal);
         });
+        // After scheduling, the old call should be gone,
+        // and the new one should be in the display in its initial state.
+        expect(result.current[0].length).toBe(1);
+        expect(result.current[0][0].request.callId).toBe('newCall');
+        expect(result.current[0][0].request.callId).not.toBe('oldCall');
+        // Let the new call finish.
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
         });
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'error',
-                request,
-                response: expect.objectContaining({
-                    error: confirmError,
-                }),
-            }),
-        ]);
-        expect(result.current[0]).toEqual([]);
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(0);
+        });
+        expect(onComplete).toHaveBeenCalled();
     });
-    it('should handle error during execute', async () => {
+    it('should cancel all running tool calls', async () => {
         mockToolRegistry.getTool.mockReturnValue(mockTool);
+        let resolveExecute = () => { };
+        const executePromise = new Promise((resolve) => {
+            resolveExecute = resolve;
+        });
+        mockTool.execute.mockReturnValue(executePromise);
         mockTool.shouldConfirmExecute.mockResolvedValue(null);
-        const execError = new Error('Execution failed');
-        mockTool.execute.mockRejectedValue(execError);
         const { result } = renderScheduler();
         const schedule = result.current[1];
+        const cancelAllToolCalls = result.current[4];
         const request = {
-            callId: 'call1',
+            callId: 'cancelCall',
             name: 'mockTool',
             args: {},
         };
@@ -333,26 +276,97 @@ describe('useReactToolScheduler', () => {
             schedule(request, new AbortController().signal);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
-        });
+            await vi.advanceTimersByTimeAsync(0);
+        }); // validation
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0); // Process scheduling
+        });
+        // At this point, the tool is 'executing' and waiting on the promise.
+        expect(result.current[0][0].status).toBe('executing');
+        const cancelController = new AbortController();
+        act(() => {
+            cancelAllToolCalls(cancelController.signal);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
         });
         expect(onComplete).toHaveBeenCalledWith([
             expect.objectContaining({
-                status: 'error',
+                status: 'cancelled',
                 request,
-                response: expect.objectContaining({
-                    error: execError,
-                }),
             }),
         ]);
-        expect(result.current[0]).toEqual([]);
+        // Clean up the pending promise to avoid open handles.
+        await act(async () => {
+            resolveExecute({ llmContent: 'output', returnDisplay: 'display' });
+        });
+    });
+    it.each([
+        {
+            desc: 'tool not found',
+            setup: () => {
+                mockToolRegistry.getTool.mockReturnValue(undefined);
+            },
+            request: {
+                callId: 'call1',
+                name: 'nonexistentTool',
+                args: {},
+            },
+            expectedErrorContains: [
+                'Tool "nonexistentTool" not found in registry',
+                'Did you mean one of:',
+            ],
+        },
+        {
+            desc: 'error during shouldConfirmExecute',
+            setup: () => {
+                mockToolRegistry.getTool.mockReturnValue(mockTool);
+                const confirmError = new Error('Confirmation check failed');
+                mockTool.shouldConfirmExecute.mockRejectedValue(confirmError);
+            },
+            request: {
+                callId: 'call1',
+                name: 'mockTool',
+                args: {},
+            },
+            expectedError: new Error('Confirmation check failed'),
+        },
+        {
+            desc: 'error during execute',
+            setup: () => {
+                mockToolRegistry.getTool.mockReturnValue(mockTool);
+                mockTool.shouldConfirmExecute.mockResolvedValue(null);
+                const execError = new Error('Execution failed');
+                mockTool.execute.mockRejectedValue(execError);
+            },
+            request: {
+                callId: 'call1',
+                name: 'mockTool',
+                args: {},
+            },
+            expectedError: new Error('Execution failed'),
+        },
+    ])('should handle $desc', async ({ setup, request, expectedErrorContains, expectedError }) => {
+        setup();
+        const { result } = renderScheduler();
+        let completedToolCalls = [];
+        onComplete.mockImplementation((calls) => {
+            completedToolCalls = calls;
+        });
+        await scheduleAndWaitForExecution(result.current[1], request);
+        expect(completedToolCalls).toHaveLength(1);
+        expect(completedToolCalls[0].status).toBe('error');
+        expect(completedToolCalls[0].request).toBe(request);
+        if (expectedErrorContains) {
+            expectedErrorContains.forEach((errorText) => {
+                expect(completedToolCalls[0].response.error.message).toContain(errorText);
+            });
+        }
+        if (expectedError) {
+            expect(completedToolCalls[0].response.error.message).toBe(expectedError.message);
+        }
     });
-    it.skip('should handle tool requiring confirmation - approved', async () => {
+    it('should handle tool requiring confirmation - approved', async () => {
         mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
         const expectedOutput = 'Confirmed output';
         mockToolRequiresConfirmation.execute.mockResolvedValue({
@@ -369,43 +383,28 @@ describe('useReactToolScheduler', () => {
         act(() => {
             schedule(request, new AbortController().signal);
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(setPendingHistoryItem).toHaveBeenCalled();
+        await advanceAndSettle();
+        const waitingCall = result.current[0][0];
+        expect(waitingCall.status).toBe('awaiting_approval');
+        capturedOnConfirmForTest = waitingCall.confirmationDetails?.onConfirm;
         expect(capturedOnConfirmForTest).toBeDefined();
         await act(async () => {
             await capturedOnConfirmForTest?.(ToolConfirmationOutcome.ProceedOnce);
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
+        await advanceAndSettle();
+        await advanceAndSettle();
+        await advanceAndSettle();
         expect(mockOnUserConfirmForToolConfirmation).toHaveBeenCalledWith(ToolConfirmationOutcome.ProceedOnce);
         expect(mockToolRequiresConfirmation.execute).toHaveBeenCalled();
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'success',
-                request,
-                response: expect.objectContaining({
-                    resultDisplay: 'Confirmed display',
-                    responseParts: expect.arrayContaining([
-                        expect.objectContaining({
-                            functionResponse: expect.objectContaining({
-                                response: { output: expectedOutput },
-                            }),
-                        }),
-                    ]),
-                }),
-            }),
-        ]);
+        const completedCalls = onComplete.mock.calls[0][0];
+        expect(completedCalls[0].status).toBe('success');
+        expect(completedCalls[0].request).toBe(request);
+        if (completedCalls[0].status === 'success' ||
+            completedCalls[0].status === 'error') {
+            expect(completedCalls[0].response).toMatchSnapshot();
+        }
     });
-    it.skip('should handle tool requiring confirmation - cancelled by user', async () => {
+    it('should handle tool requiring confirmation - cancelled by user', async () => {
         mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
         const { result } = renderScheduler();
         const schedule = result.current[1];
@@ -417,40 +416,27 @@ describe('useReactToolScheduler', () => {
         act(() => {
             schedule(request, new AbortController().signal);
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(setPendingHistoryItem).toHaveBeenCalled();
+        await advanceAndSettle();
+        const waitingCall = result.current[0][0];
+        expect(waitingCall.status).toBe('awaiting_approval');
+        capturedOnConfirmForTest = waitingCall.confirmationDetails?.onConfirm;
         expect(capturedOnConfirmForTest).toBeDefined();
         await act(async () => {
             await capturedOnConfirmForTest?.(ToolConfirmationOutcome.Cancel);
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
+        await advanceAndSettle();
+        await advanceAndSettle();
         expect(mockOnUserConfirmForToolConfirmation).toHaveBeenCalledWith(ToolConfirmationOutcome.Cancel);
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'cancelled',
-                request,
-                response: expect.objectContaining({
-                    responseParts: expect.arrayContaining([
-                        expect.objectContaining({
-                            functionResponse: expect.objectContaining({
-                                response: expect.objectContaining({
-                                    error: `User did not allow tool call ${request.name}. Reason: User cancelled.`,
-                                }),
-                            }),
-                        }),
-                    ]),
-                }),
-            }),
-        ]);
+        const completedCalls = onComplete.mock.calls[0][0];
+        expect(completedCalls[0].status).toBe('cancelled');
+        expect(completedCalls[0].request).toBe(request);
+        if (completedCalls[0].status === 'success' ||
+            completedCalls[0].status === 'error' ||
+            completedCalls[0].status === 'cancelled') {
+            expect(completedCalls[0].response).toMatchSnapshot();
+        }
     });
-    it.skip('should handle live output updates', async () => {
+    it('should handle live output updates', async () => {
         mockToolRegistry.getTool.mockReturnValue(mockToolWithLiveOutput);
         let liveUpdateFn;
         let resolveExecutePromise;
@@ -463,60 +449,40 @@ describe('useReactToolScheduler', () => {
         });
         mockToolWithLiveOutput.shouldConfirmExecute.mockResolvedValue(null);
         const { result } = renderScheduler();
-        const schedule = result.current[1];
         const request = {
             callId: 'liveCall',
             name: 'mockToolWithLiveOutput',
             args: {},
         };
         act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
+            result.current[1](request, new AbortController().signal);
         });
+        await advanceAndSettle();
         expect(liveUpdateFn).toBeDefined();
-        expect(setPendingHistoryItem).toHaveBeenCalled();
+        expect(result.current[0][0].status).toBe('executing');
         await act(async () => {
             liveUpdateFn?.('Live output 1');
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
+        await advanceAndSettle();
         await act(async () => {
             liveUpdateFn?.('Live output 2');
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
+        await advanceAndSettle();
         act(() => {
             resolveExecutePromise({
                 llmContent: 'Final output',
                 returnDisplay: 'Final display',
             });
         });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'success',
-                request,
-                response: expect.objectContaining({
-                    resultDisplay: 'Final display',
-                    responseParts: expect.arrayContaining([
-                        expect.objectContaining({
-                            functionResponse: expect.objectContaining({
-                                response: { output: 'Final output' },
-                            }),
-                        }),
-                    ]),
-                }),
-            }),
-        ]);
+        await advanceAndSettle();
+        await advanceAndSettle();
+        const completedCalls = onComplete.mock.calls[0][0];
+        expect(completedCalls[0].status).toBe('success');
+        expect(completedCalls[0].request).toBe(request);
+        if (completedCalls[0].status === 'success' ||
+            completedCalls[0].status === 'error') {
+            expect(completedCalls[0].response).toMatchSnapshot();
+        }
         expect(result.current[0]).toEqual([]);
     });
     it('should schedule and execute multiple tool calls', async () => {
@@ -553,16 +519,16 @@ describe('useReactToolScheduler', () => {
             schedule(requests, new AbortController().signal);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
         });
         expect(onComplete).toHaveBeenCalledTimes(1);
         const completedCalls = onComplete.mock.calls[0][0];
@@ -601,9 +567,10 @@ describe('useReactToolScheduler', () => {
                 ],
             }),
         });
-        expect(result.current[0]).toEqual([]);
+        expect(completedCalls).toHaveLength(2);
+        expect(completedCalls.every((t) => t.status === 'success')).toBe(true);
     });
-    it.skip('should throw error if scheduling while already running', async () => {
+    it('should queue if scheduling while already running', async () => {
         mockToolRegistry.getTool.mockReturnValue(mockTool);
         const longExecutePromise = new Promise((resolve) => setTimeout(() => resolve({
             llmContent: 'done',
@@ -627,14 +594,16 @@ describe('useReactToolScheduler', () => {
             schedule(request1, new AbortController().signal);
         });
         await act(async () => {
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
+        });
+        act(() => {
+            schedule(request2, new AbortController().signal);
         });
-        expect(() => schedule(request2, new AbortController().signal)).toThrow('Cannot schedule tool calls while other tool calls are running');
         await act(async () => {
             await vi.advanceTimersByTimeAsync(50);
-            await vi.runAllTimersAsync();
+            await vi.advanceTimersByTimeAsync(0);
             await act(async () => {
-                await vi.runAllTimersAsync();
+                await vi.advanceTimersByTimeAsync(0);
             });
         });
         expect(onComplete).toHaveBeenCalledWith([
@@ -644,7 +613,22 @@ describe('useReactToolScheduler', () => {
                 response: expect.objectContaining({ resultDisplay: 'done display' }),
             }),
         ]);
-        expect(result.current[0]).toEqual([]);
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(50);
+            await vi.advanceTimersByTimeAsync(0);
+            await act(async () => {
+                await vi.advanceTimersByTimeAsync(0);
+            });
+        });
+        expect(onComplete).toHaveBeenCalledWith([
+            expect.objectContaining({
+                status: 'success',
+                request: request2,
+                response: expect.objectContaining({ resultDisplay: 'done display' }),
+            }),
+        ]);
+        const toolCalls = result.current[0];
+        expect(toolCalls).toHaveLength(0);
     });
 });
 describe('mapToDisplay', () => {