fss-link 1.1.8 → 1.2.0

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

@@ -1,845 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useReactToolScheduler, mapToDisplay, } from './useReactToolScheduler.js';
-import { ToolConfirmationOutcome, ApprovalMode, Kind, BaseDeclarativeTool, BaseToolInvocation, } from 'fss-link-core';
-import { ToolCallStatus, } from '../types.js';
-// Mocks
-vi.mock('fss-link-core', async () => {
-    const actual = await vi.importActual('fss-link-core');
-    return {
-        ...actual,
-        ToolRegistry: vi.fn(),
-        Config: vi.fn(),
-    };
-});
-const mockToolRegistry = {
-    getTool: vi.fn(),
-};
-const mockConfig = {
-    getToolRegistry: vi.fn(() => mockToolRegistry),
-    getApprovalMode: vi.fn(() => ApprovalMode.DEFAULT),
-    getUsageStatisticsEnabled: () => true,
-    getDebugMode: () => false,
-    getSessionId: () => 'test-session-id',
-    getContentGeneratorConfig: () => ({
-        model: 'test-model',
-        authType: 'oauth-personal',
-    }),
-};
-class MockToolInvocation extends BaseToolInvocation {
-    tool;
-    constructor(tool, params) {
-        super(params);
-        this.tool = tool;
-    }
-    getDescription() {
-        return JSON.stringify(this.params);
-    }
-    shouldConfirmExecute(abortSignal) {
-        return this.tool.shouldConfirmExecute(this.params, abortSignal);
-    }
-    execute(signal, updateOutput, terminalColumns, terminalRows) {
-        return this.tool.execute(this.params, signal, updateOutput, terminalColumns, terminalRows);
-    }
-}
-class MockTool extends BaseDeclarativeTool {
-    constructor(name, displayName, canUpdateOutput = false, shouldConfirm = false, isOutputMarkdown = false) {
-        super(name, displayName, 'A mock tool for testing', Kind.Other, {}, isOutputMarkdown, canUpdateOutput);
-        if (shouldConfirm) {
-            this.shouldConfirmExecute.mockImplementation(async () => ({
-                type: 'edit',
-                title: 'Mock Tool Requires Confirmation',
-                onConfirm: mockOnUserConfirmForToolConfirmation,
-                filePath: 'mock',
-                fileName: 'mockToolRequiresConfirmation.ts',
-                fileDiff: 'Mock tool requires confirmation',
-                originalContent: 'Original content',
-                newContent: 'New content',
-            }));
-        }
-    }
-    execute = vi.fn();
-    shouldConfirmExecute = vi.fn();
-    createInvocation(params) {
-        return new MockToolInvocation(this, params);
-    }
-}
-const mockTool = new MockTool('mockTool', 'Mock Tool');
-const mockToolWithLiveOutput = new MockTool('mockToolWithLiveOutput', 'Mock Tool With Live Output', true);
-let mockOnUserConfirmForToolConfirmation;
-const mockToolRequiresConfirmation = new MockTool('mockToolRequiresConfirmation', 'Mock Tool Requires Confirmation', false, true);
-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();
-        // IMPORTANT: Enable YOLO mode for this test suite
-        mockConfig.getApprovalMode.mockReturnValue(ApprovalMode.YOLO);
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.clearAllTimers();
-        vi.useRealTimers();
-        // IMPORTANT: Disable YOLO mode after this test suite
-        mockConfig.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
-    });
-    const renderSchedulerInYoloMode = () => renderHook(() => useReactToolScheduler(onComplete, mockConfig, setPendingHistoryItem, () => undefined, () => { }));
-    it('should skip confirmation and execute tool directly when yoloMode is true', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
-        const expectedOutput = 'YOLO Confirmed output';
-        mockToolRequiresConfirmation.execute.mockResolvedValue({
-            llmContent: expectedOutput,
-            returnDisplay: 'YOLO Formatted tool output',
-            summary: 'YOLO summary',
-        });
-        const { result } = renderSchedulerInYoloMode();
-        const schedule = result.current[1];
-        const request = {
-            callId: 'yoloCall',
-            name: 'mockToolRequiresConfirmation',
-            args: { data: 'any data' },
-        };
-        act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync(); // Process validation
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync(); // Process scheduling
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync(); // Process execution
-        });
-        // Check that shouldConfirmExecute was NOT called
-        expect(mockToolRequiresConfirmation.shouldConfirmExecute).not.toHaveBeenCalled();
-        // Check that execute WAS called
-        expect(mockToolRequiresConfirmation.execute).toHaveBeenCalledWith(request.args, expect.any(AbortSignal), undefined, undefined, undefined);
-        // Check that onComplete was called with success
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'success',
-                request,
-                response: expect.objectContaining({
-                    resultDisplay: 'YOLO Formatted tool output',
-                    responseParts: {
-                        functionResponse: {
-                            id: 'yoloCall',
-                            name: 'mockToolRequiresConfirmation',
-                            response: { output: expectedOutput },
-                        },
-                    },
-                }),
-            }),
-        ]);
-        // 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;
-    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();
-        mockToolWithLiveOutput.execute.mockClear();
-        mockToolWithLiveOutput.shouldConfirmExecute.mockClear();
-        mockToolRequiresConfirmation.execute.mockClear();
-        mockToolRequiresConfirmation.shouldConfirmExecute.mockClear();
-        mockOnUserConfirmForToolConfirmation = vi.fn();
-        mockToolRequiresConfirmation.shouldConfirmExecute.mockImplementation(async () => ({
-            onConfirm: mockOnUserConfirmForToolConfirmation,
-            fileName: 'mockToolRequiresConfirmation.ts',
-            fileDiff: 'Mock tool requires confirmation',
-            type: 'edit',
-            title: 'Mock Tool Requires Confirmation',
-        }));
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.clearAllTimers();
-        vi.useRealTimers();
-    });
-    const renderScheduler = () => renderHook(() => useReactToolScheduler(onComplete, mockConfig, setPendingHistoryItem, () => undefined, () => { }));
-    it('initial state should be empty', () => {
-        const { result } = renderScheduler();
-        expect(result.current[0]).toEqual([]);
-    });
-    it('should schedule and execute a tool call successfully', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockTool);
-        mockTool.execute.mockResolvedValue({
-            llmContent: 'Tool output',
-            returnDisplay: 'Formatted tool output',
-            summary: 'Formatted summary',
-        });
-        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();
-        });
-        expect(mockTool.execute).toHaveBeenCalledWith(request.args, expect.any(AbortSignal), undefined, undefined, undefined);
-        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([]);
-    });
-    it('should handle tool not found', async () => {
-        mockToolRegistry.getTool.mockReturnValue(undefined);
-        const { result } = renderScheduler();
-        const schedule = result.current[1];
-        const request = {
-            callId: 'call1',
-            name: 'nonexistentTool',
-            args: {},
-        };
-        act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'error',
-                request,
-                response: expect.objectContaining({
-                    error: expect.objectContaining({
-                        message: 'Tool "nonexistentTool" not found in registry.',
-                    }),
-                }),
-            }),
-        ]);
-        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',
-            name: 'mockTool',
-            args: {},
-        };
-        act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'error',
-                request,
-                response: expect.objectContaining({
-                    error: confirmError,
-                }),
-            }),
-        ]);
-        expect(result.current[0]).toEqual([]);
-    });
-    it('should handle error during execute', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockTool);
-        mockTool.shouldConfirmExecute.mockResolvedValue(null);
-        const execError = new Error('Execution failed');
-        mockTool.execute.mockRejectedValue(execError);
-        const { result } = renderScheduler();
-        const schedule = result.current[1];
-        const request = {
-            callId: 'call1',
-            name: 'mockTool',
-            args: {},
-        };
-        act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'error',
-                request,
-                response: expect.objectContaining({
-                    error: execError,
-                }),
-            }),
-        ]);
-        expect(result.current[0]).toEqual([]);
-    });
-    it.skip('should handle tool requiring confirmation - approved', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
-        const expectedOutput = 'Confirmed output';
-        mockToolRequiresConfirmation.execute.mockResolvedValue({
-            llmContent: expectedOutput,
-            returnDisplay: 'Confirmed display',
-            summary: 'Confirmed summary',
-        });
-        const { result } = renderScheduler();
-        const schedule = result.current[1];
-        const request = {
-            callId: 'callConfirm',
-            name: 'mockToolRequiresConfirmation',
-            args: { data: 'sensitive' },
-        };
-        act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(setPendingHistoryItem).toHaveBeenCalled();
-        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();
-        });
-        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 },
-                            }),
-                        }),
-                    ]),
-                }),
-            }),
-        ]);
-    });
-    it.skip('should handle tool requiring confirmation - cancelled by user', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockToolRequiresConfirmation);
-        const { result } = renderScheduler();
-        const schedule = result.current[1];
-        const request = {
-            callId: 'callConfirmCancel',
-            name: 'mockToolRequiresConfirmation',
-            args: {},
-        };
-        act(() => {
-            schedule(request, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(setPendingHistoryItem).toHaveBeenCalled();
-        expect(capturedOnConfirmForTest).toBeDefined();
-        await act(async () => {
-            await capturedOnConfirmForTest?.(ToolConfirmationOutcome.Cancel);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        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.`,
-                                }),
-                            }),
-                        }),
-                    ]),
-                }),
-            }),
-        ]);
-    });
-    it.skip('should handle live output updates', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockToolWithLiveOutput);
-        let liveUpdateFn;
-        let resolveExecutePromise;
-        const executePromise = new Promise((resolve) => {
-            resolveExecutePromise = resolve;
-        });
-        mockToolWithLiveOutput.execute.mockImplementation(async (_args, _signal, updateFn) => {
-            liveUpdateFn = updateFn;
-            return executePromise;
-        });
-        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();
-        });
-        expect(liveUpdateFn).toBeDefined();
-        expect(setPendingHistoryItem).toHaveBeenCalled();
-        await act(async () => {
-            liveUpdateFn?.('Live output 1');
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            liveUpdateFn?.('Live output 2');
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        act(() => {
-            resolveExecutePromise({
-                llmContent: 'Final output',
-                returnDisplay: 'Final display',
-                summary: 'Final summary',
-            });
-        });
-        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' },
-                            }),
-                        }),
-                    ]),
-                }),
-            }),
-        ]);
-        expect(result.current[0]).toEqual([]);
-    });
-    it('should schedule and execute multiple tool calls', async () => {
-        const tool1 = new MockTool('tool1', 'Tool 1');
-        tool1.execute.mockResolvedValue({
-            llmContent: 'Output 1',
-            returnDisplay: 'Display 1',
-            summary: 'Summary 1',
-        });
-        tool1.shouldConfirmExecute.mockResolvedValue(null);
-        const tool2 = new MockTool('tool2', 'Tool 2');
-        tool2.execute.mockResolvedValue({
-            llmContent: 'Output 2',
-            returnDisplay: 'Display 2',
-            summary: 'Summary 2',
-        });
-        tool2.shouldConfirmExecute.mockResolvedValue(null);
-        mockToolRegistry.getTool.mockImplementation((name) => {
-            if (name === 'tool1')
-                return tool1;
-            if (name === 'tool2')
-                return tool2;
-            return undefined;
-        });
-        const { result } = renderScheduler();
-        const schedule = result.current[1];
-        const requests = [
-            { callId: 'multi1', name: 'tool1', args: { p: 1 } },
-            { callId: 'multi2', name: 'tool2', args: { p: 2 } },
-        ];
-        act(() => {
-            schedule(requests, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        expect(onComplete).toHaveBeenCalledTimes(1);
-        const completedCalls = onComplete.mock.calls[0][0];
-        expect(completedCalls.length).toBe(2);
-        const call1Result = completedCalls.find((c) => c.request.callId === 'multi1');
-        const call2Result = completedCalls.find((c) => c.request.callId === 'multi2');
-        expect(call1Result).toMatchObject({
-            status: 'success',
-            request: requests[0],
-            response: expect.objectContaining({
-                resultDisplay: 'Display 1',
-                responseParts: {
-                    functionResponse: {
-                        id: 'multi1',
-                        name: 'tool1',
-                        response: { output: 'Output 1' },
-                    },
-                },
-            }),
-        });
-        expect(call2Result).toMatchObject({
-            status: 'success',
-            request: requests[1],
-            response: expect.objectContaining({
-                resultDisplay: 'Display 2',
-                responseParts: {
-                    functionResponse: {
-                        id: 'multi2',
-                        name: 'tool2',
-                        response: { output: 'Output 2' },
-                    },
-                },
-            }),
-        });
-        expect(result.current[0]).toEqual([]);
-    });
-    it.skip('should throw error if scheduling while already running', async () => {
-        mockToolRegistry.getTool.mockReturnValue(mockTool);
-        const longExecutePromise = new Promise((resolve) => setTimeout(() => resolve({
-            llmContent: 'done',
-            returnDisplay: 'done display',
-            summary: 'done summary',
-        }), 50));
-        mockTool.execute.mockReturnValue(longExecutePromise);
-        mockTool.shouldConfirmExecute.mockResolvedValue(null);
-        const { result } = renderScheduler();
-        const schedule = result.current[1];
-        const request1 = {
-            callId: 'run1',
-            name: 'mockTool',
-            args: {},
-        };
-        const request2 = {
-            callId: 'run2',
-            name: 'mockTool',
-            args: {},
-        };
-        act(() => {
-            schedule(request1, new AbortController().signal);
-        });
-        await act(async () => {
-            await vi.runAllTimersAsync();
-        });
-        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 act(async () => {
-                await vi.runAllTimersAsync();
-            });
-        });
-        expect(onComplete).toHaveBeenCalledWith([
-            expect.objectContaining({
-                status: 'success',
-                request: request1,
-                response: expect.objectContaining({ resultDisplay: 'done display' }),
-            }),
-        ]);
-        expect(result.current[0]).toEqual([]);
-    });
-});
-describe('mapToDisplay', () => {
-    const baseRequest = {
-        callId: 'testCallId',
-        name: 'testTool',
-        args: { foo: 'bar' },
-    };
-    const baseTool = new MockTool('testTool', 'Test Tool Display');
-    const baseResponse = {
-        callId: 'testCallId',
-        responseParts: [
-            {
-                functionResponse: {
-                    name: 'testTool',
-                    id: 'testCallId',
-                    response: { output: 'Test output' },
-                },
-            },
-        ],
-        resultDisplay: 'Test display output',
-        error: undefined,
-    };
-    const baseInvocation = baseTool.build(baseRequest.args);
-    const testCases = [
-        {
-            name: 'validating',
-            status: 'validating',
-            extraProps: { tool: baseTool, invocation: baseInvocation },
-            expectedStatus: ToolCallStatus.Executing,
-            expectedName: baseTool.displayName,
-            expectedDescription: baseInvocation.getDescription(),
-        },
-        {
-            name: 'awaiting_approval',
-            status: 'awaiting_approval',
-            extraProps: {
-                tool: baseTool,
-                invocation: baseInvocation,
-                confirmationDetails: {
-                    onConfirm: vi.fn(),
-                    type: 'edit',
-                    title: 'Test Tool Display',
-                    serverName: 'testTool',
-                    toolName: 'testTool',
-                    toolDisplayName: 'Test Tool Display',
-                    filePath: 'mock',
-                    fileName: 'test.ts',
-                    fileDiff: 'Test diff',
-                    originalContent: 'Original content',
-                    newContent: 'New content',
-                },
-            },
-            expectedStatus: ToolCallStatus.Confirming,
-            expectedName: baseTool.displayName,
-            expectedDescription: baseInvocation.getDescription(),
-        },
-        {
-            name: 'scheduled',
-            status: 'scheduled',
-            extraProps: { tool: baseTool, invocation: baseInvocation },
-            expectedStatus: ToolCallStatus.Pending,
-            expectedName: baseTool.displayName,
-            expectedDescription: baseInvocation.getDescription(),
-        },
-        {
-            name: 'executing no live output',
-            status: 'executing',
-            extraProps: { tool: baseTool, invocation: baseInvocation },
-            expectedStatus: ToolCallStatus.Executing,
-            expectedName: baseTool.displayName,
-            expectedDescription: baseInvocation.getDescription(),
-        },
-        {
-            name: 'executing with live output',
-            status: 'executing',
-            extraProps: {
-                tool: baseTool,
-                invocation: baseInvocation,
-                liveOutput: 'Live test output',
-            },
-            expectedStatus: ToolCallStatus.Executing,
-            expectedResultDisplay: 'Live test output',
-            expectedName: baseTool.displayName,
-            expectedDescription: baseInvocation.getDescription(),
-        },
-        {
-            name: 'success',
-            status: 'success',
-            extraProps: {
-                tool: baseTool,
-                invocation: baseInvocation,
-                response: baseResponse,
-            },
-            expectedStatus: ToolCallStatus.Success,
-            expectedResultDisplay: baseResponse.resultDisplay,
-            expectedName: baseTool.displayName,
-            expectedDescription: baseInvocation.getDescription(),
-        },
-        {
-            name: 'error tool not found',
-            status: 'error',
-            extraProps: {
-                response: {
-                    ...baseResponse,
-                    error: new Error('Test error tool not found'),
-                    resultDisplay: 'Error display tool not found',
-                },
-            },
-            expectedStatus: ToolCallStatus.Error,
-            expectedResultDisplay: 'Error display tool not found',
-            expectedName: baseRequest.name,
-            expectedDescription: JSON.stringify(baseRequest.args),
-        },
-        {
-            name: 'error tool execution failed',
-            status: 'error',
-            extraProps: {
-                tool: baseTool,
-                response: {
-                    ...baseResponse,
-                    error: new Error('Tool execution failed'),
-                    resultDisplay: 'Execution failed display',
-                },
-            },
-            expectedStatus: ToolCallStatus.Error,
-            expectedResultDisplay: 'Execution failed display',
-            expectedName: baseTool.displayName, // Changed from baseTool.name
-            expectedDescription: baseInvocation.getDescription(),
-        },
-        {
-            name: 'cancelled',
-            status: 'cancelled',
-            extraProps: {
-                tool: baseTool,
-                invocation: baseInvocation,
-                response: {
-                    ...baseResponse,
-                    resultDisplay: 'Cancelled display',
-                },
-            },
-            expectedStatus: ToolCallStatus.Canceled,
-            expectedResultDisplay: 'Cancelled display',
-            expectedName: baseTool.displayName,
-            expectedDescription: baseInvocation.getDescription(),
-        },
-    ];
-    testCases.forEach(({ name: testName, status, extraProps, expectedStatus, expectedResultDisplay, expectedName, expectedDescription, }) => {
-        it(`should map ToolCall with status '${status}' (${testName}) correctly`, () => {
-            const toolCall = {
-                request: baseRequest,
-                status,
-                ...(extraProps || {}),
-            };
-            const display = mapToDisplay(toolCall);
-            expect(display.type).toBe('tool_group');
-            expect(display.tools.length).toBe(1);
-            const toolDisplay = display.tools[0];
-            expect(toolDisplay.callId).toBe(baseRequest.callId);
-            expect(toolDisplay.status).toBe(expectedStatus);
-            expect(toolDisplay.resultDisplay).toBe(expectedResultDisplay);
-            expect(toolDisplay.name).toBe(expectedName);
-            expect(toolDisplay.description).toBe(expectedDescription);
-            expect(toolDisplay.renderOutputAsMarkdown).toBe(extraProps?.tool?.isOutputMarkdown ?? false);
-            if (status === 'awaiting_approval') {
-                expect(toolDisplay.confirmationDetails).toBe(extraProps.confirmationDetails);
-            }
-            else {
-                expect(toolDisplay.confirmationDetails).toBeUndefined();
-            }
-        });
-    });
-    it('should map an array of ToolCalls correctly', () => {
-        const toolCall1 = {
-            request: { ...baseRequest, callId: 'call1' },
-            status: 'success',
-            tool: baseTool,
-            invocation: baseTool.build(baseRequest.args),
-            response: { ...baseResponse, callId: 'call1' },
-        };
-        const toolForCall2 = new MockTool(baseTool.name, baseTool.displayName, false, false, true);
-        const toolCall2 = {
-            request: { ...baseRequest, callId: 'call2' },
-            status: 'executing',
-            tool: toolForCall2,
-            invocation: toolForCall2.build(baseRequest.args),
-            liveOutput: 'markdown output',
-        };
-        const display = mapToDisplay([toolCall1, toolCall2]);
-        expect(display.tools.length).toBe(2);
-        expect(display.tools[0].callId).toBe('call1');
-        expect(display.tools[0].status).toBe(ToolCallStatus.Success);
-        expect(display.tools[0].renderOutputAsMarkdown).toBe(false);
-        expect(display.tools[1].callId).toBe('call2');
-        expect(display.tools[1].status).toBe(ToolCallStatus.Executing);
-        expect(display.tools[1].resultDisplay).toBe('markdown output');
-        expect(display.tools[1].renderOutputAsMarkdown).toBe(true);
-    });
-});
-//# sourceMappingURL=useToolScheduler.test.js.map