@office-ai/aioncli-core 0.8.1 → 0.18.5

package/dist/src/core/coreToolScheduler.test.js

@@ -7,8 +7,10 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { CoreToolScheduler, convertToFunctionResponse, truncateAndSaveToFile, } from './coreToolScheduler.js';
 import { DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES, DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD, BaseDeclarativeTool, BaseToolInvocation, ToolConfirmationOutcome, Kind, ApprovalMode, } from '../index.js';
 import { MockModifiableTool, MockTool, MOCK_TOOL_SHOULD_CONFIRM_EXECUTE, } from '../test-utils/mock-tool.js';
+import * as modifiableToolModule from '../tools/modifiable-tool.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { isShellInvocationAllowlisted } from '../utils/shell-utils.js';
 vi.mock('fs/promises', () => ({
     writeFile: vi.fn(),
 }));
@@ -121,6 +123,50 @@ async function waitForStatus(onToolCallsUpdate, status, timeout = 5000) {
         check();
     });
 }
+function createMockConfig(overrides = {}) {
+    const defaultToolRegistry = {
+        getTool: () => undefined,
+        getToolByName: () => undefined,
+        getFunctionDeclarations: () => [],
+        tools: new Map(),
+        discovery: {},
+        registerTool: () => { },
+        getToolByDisplayName: () => undefined,
+        getTools: () => [],
+        discoverTools: async () => { },
+        getAllTools: () => [],
+        getToolsByServer: () => [],
+    };
+    const baseConfig = {
+        getSessionId: () => 'test-session-id',
+        getUsageStatisticsEnabled: () => true,
+        getDebugMode: () => false,
+        getApprovalMode: () => ApprovalMode.DEFAULT,
+        setApprovalMode: () => { },
+        getAllowedTools: () => [],
+        getContentGeneratorConfig: () => ({
+            model: 'test-model',
+            authType: 'oauth-personal',
+        }),
+        getShellExecutionConfig: () => ({
+            terminalWidth: 90,
+            terminalHeight: 30,
+        }),
+        storage: {
+            getProjectTempDir: () => '/tmp',
+        },
+        getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
+        getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
+        getToolRegistry: () => defaultToolRegistry,
+        getUseSmartEdit: () => false,
+        getUseModelRouter: () => false,
+        getGeminiClient: () => null,
+        getEnableMessageBusIntegration: () => false,
+        getMessageBus: () => null,
+        getPolicyEngine: () => null,
+    };
+    return { ...baseConfig, ...overrides };
+}
 describe('CoreToolScheduler', () => {
     it('should cancel a tool call if the signal is aborted before confirmation', async () => {
         const mockTool = new MockTool({
@@ -143,36 +189,15 @@ describe('CoreToolScheduler', () => {
         };
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.DEFAULT,
-            getAllowedTools: () => [],
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
+        const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         const request = {
@@ -189,6 +214,184 @@ describe('CoreToolScheduler', () => {
             .calls[0][0];
         expect(completedCalls[0].status).toBe('cancelled');
     });
+    it('should cancel all tools when cancelAll is called', async () => {
+        const mockTool1 = new MockTool({
+            name: 'mockTool1',
+            shouldConfirmExecute: MOCK_TOOL_SHOULD_CONFIRM_EXECUTE,
+        });
+        const mockTool2 = new MockTool({ name: 'mockTool2' });
+        const mockTool3 = new MockTool({ name: 'mockTool3' });
+        const mockToolRegistry = {
+            getTool: (name) => {
+                if (name === 'mockTool1')
+                    return mockTool1;
+                if (name === 'mockTool2')
+                    return mockTool2;
+                if (name === 'mockTool3')
+                    return mockTool3;
+                return undefined;
+            },
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByName: (name) => {
+                if (name === 'mockTool1')
+                    return mockTool1;
+                if (name === 'mockTool2')
+                    return mockTool2;
+                if (name === 'mockTool3')
+                    return mockTool3;
+                return undefined;
+            },
+            getToolByDisplayName: () => undefined,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const onAllToolCallsComplete = vi.fn();
+        const onToolCallsUpdate = vi.fn();
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            isInteractive: () => false,
+        });
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            onToolCallsUpdate,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const requests = [
+            {
+                callId: '1',
+                name: 'mockTool1',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-1',
+            },
+            {
+                callId: '2',
+                name: 'mockTool2',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-1',
+            },
+            {
+                callId: '3',
+                name: 'mockTool3',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-1',
+            },
+        ];
+        // Don't await, let it run in the background
+        void scheduler.schedule(requests, abortController.signal);
+        // Wait for the first tool to be awaiting approval
+        await waitForStatus(onToolCallsUpdate, 'awaiting_approval');
+        // Cancel all operations
+        scheduler.cancelAll(abortController.signal);
+        abortController.abort(); // Also fire the signal
+        await vi.waitFor(() => {
+            expect(onAllToolCallsComplete).toHaveBeenCalled();
+        });
+        const completedCalls = onAllToolCallsComplete.mock
+            .calls[0][0];
+        expect(completedCalls).toHaveLength(3);
+        expect(completedCalls.find((c) => c.request.callId === '1')?.status).toBe('cancelled');
+        expect(completedCalls.find((c) => c.request.callId === '2')?.status).toBe('cancelled');
+        expect(completedCalls.find((c) => c.request.callId === '3')?.status).toBe('cancelled');
+    });
+    it('should cancel all tools in a batch when one is cancelled via confirmation', async () => {
+        const mockTool1 = new MockTool({
+            name: 'mockTool1',
+            shouldConfirmExecute: MOCK_TOOL_SHOULD_CONFIRM_EXECUTE,
+        });
+        const mockTool2 = new MockTool({ name: 'mockTool2' });
+        const mockTool3 = new MockTool({ name: 'mockTool3' });
+        const mockToolRegistry = {
+            getTool: (name) => {
+                if (name === 'mockTool1')
+                    return mockTool1;
+                if (name === 'mockTool2')
+                    return mockTool2;
+                if (name === 'mockTool3')
+                    return mockTool3;
+                return undefined;
+            },
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByName: (name) => {
+                if (name === 'mockTool1')
+                    return mockTool1;
+                if (name === 'mockTool2')
+                    return mockTool2;
+                if (name === 'mockTool3')
+                    return mockTool3;
+                return undefined;
+            },
+            getToolByDisplayName: () => undefined,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const onAllToolCallsComplete = vi.fn();
+        const onToolCallsUpdate = vi.fn();
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            isInteractive: () => false,
+        });
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            onToolCallsUpdate,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const requests = [
+            {
+                callId: '1',
+                name: 'mockTool1',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-1',
+            },
+            {
+                callId: '2',
+                name: 'mockTool2',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-1',
+            },
+            {
+                callId: '3',
+                name: 'mockTool3',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-1',
+            },
+        ];
+        // Don't await, let it run in the background
+        void scheduler.schedule(requests, abortController.signal);
+        // Wait for the first tool to be awaiting approval
+        const awaitingCall = (await waitForStatus(onToolCallsUpdate, 'awaiting_approval'));
+        // Cancel the first tool via its confirmation handler
+        await awaitingCall.confirmationDetails.onConfirm(ToolConfirmationOutcome.Cancel);
+        abortController.abort(); // User cancelling often involves an abort signal
+        await vi.waitFor(() => {
+            expect(onAllToolCallsComplete).toHaveBeenCalled();
+        });
+        const completedCalls = onAllToolCallsComplete.mock
+            .calls[0][0];
+        expect(completedCalls).toHaveLength(3);
+        expect(completedCalls.find((c) => c.request.callId === '1')?.status).toBe('cancelled');
+        expect(completedCalls.find((c) => c.request.callId === '2')?.status).toBe('cancelled');
+        expect(completedCalls.find((c) => c.request.callId === '3')?.status).toBe('cancelled');
+    });
     it('should mark tool call as cancelled when abort happens during confirmation error', async () => {
         const abortController = new AbortController();
         const abortError = new Error('Abort requested during confirmation');
@@ -208,36 +411,15 @@ describe('CoreToolScheduler', () => {
         };
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.DEFAULT,
-            getAllowedTools: () => [],
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
+        const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null,
-        };
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const request = {
             callId: 'abort-1',
@@ -257,20 +439,17 @@ describe('CoreToolScheduler', () => {
     describe('getToolSuggestion', () => {
         it('should suggest the top N closest tool names for a typo', () => {
             // Create mocked tool registry
-            const mockConfig = {
-                getToolRegistry: () => mockToolRegistry,
-                getUseSmartEdit: () => false,
-                getUseModelRouter: () => false,
-                getGeminiClient: () => null, // No client needed for these tests
-            };
             const mockToolRegistry = {
                 getAllToolNames: () => ['list_files', 'read_file', 'write_file'],
             };
+            const mockConfig = createMockConfig({
+                getToolRegistry: () => mockToolRegistry,
+                isInteractive: () => false,
+            });
             // Create scheduler
             const scheduler = new CoreToolScheduler({
                 config: mockConfig,
                 getPreferredEditor: () => 'vscode',
-                onEditorClose: vi.fn(),
             });
             // Test that the right tool is selected, with only 1 result, for typos
             // @ts-expect-error accessing private method
@@ -307,36 +486,15 @@ describe('CoreToolScheduler with payload', () => {
         };
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.DEFAULT,
-            getAllowedTools: () => [],
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
+        const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         const request = {
@@ -584,34 +742,15 @@ describe('CoreToolScheduler edit cancellation', () => {
         };
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.DEFAULT,
-            getAllowedTools: () => [],
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
+        const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         const request = {
@@ -670,36 +809,16 @@ describe('CoreToolScheduler YOLO mode', () => {
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
         // Configure the scheduler for YOLO mode.
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.YOLO,
-            getAllowedTools: () => [],
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
+        const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            getApprovalMode: () => ApprovalMode.YOLO,
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         const request = {
@@ -764,36 +883,16 @@ describe('CoreToolScheduler request queueing', () => {
         };
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.YOLO, // Use YOLO to avoid confirmation prompts
-            getAllowedTools: () => [],
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
+        const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            getApprovalMode: () => ApprovalMode.YOLO, // Use YOLO to avoid confirmation prompts
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         const request1 = {
@@ -874,38 +973,20 @@ describe('CoreToolScheduler request queueing', () => {
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
         // Configure the scheduler to auto-approve the specific tool call.
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.DEFAULT, // Not YOLO mode
+        const mockConfig = createMockConfig({
             getAllowedTools: () => ['mockTool'], // Auto-approve this tool
             getToolRegistry: () => toolRegistry,
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
             getShellExecutionConfig: () => ({
                 terminalWidth: 80,
                 terminalHeight: 24,
             }),
-            getTerminalWidth: vi.fn(() => 80),
-            getTerminalHeight: vi.fn(() => 24),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         const request = {
@@ -946,6 +1027,71 @@ describe('CoreToolScheduler request queueing', () => {
             expect(completedCall.response.resultDisplay).toBe('Tool executed');
         }
     });
+    it('should require approval for a chained shell command even when prefix is allowlisted', async () => {
+        expect(isShellInvocationAllowlisted({
+            params: { command: 'git status && rm -rf /tmp/should-not-run' },
+        }, ['run_shell_command(git)'])).toBe(false);
+        const executeFn = vi.fn().mockResolvedValue({
+            llmContent: 'Shell command executed',
+            returnDisplay: 'Shell command executed',
+        });
+        const mockShellTool = new MockTool({
+            name: 'run_shell_command',
+            shouldConfirmExecute: (params) => Promise.resolve({
+                type: 'exec',
+                title: 'Confirm Shell Command',
+                command: String(params['command'] ?? ''),
+                rootCommand: 'git',
+                onConfirm: async () => { },
+            }),
+            execute: () => executeFn({}),
+        });
+        const toolRegistry = {
+            getTool: () => mockShellTool,
+            getToolByName: () => mockShellTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByDisplayName: () => mockShellTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const onAllToolCallsComplete = vi.fn();
+        const onToolCallsUpdate = vi.fn();
+        const mockConfig = createMockConfig({
+            getAllowedTools: () => ['run_shell_command(git)'],
+            getShellExecutionConfig: () => ({
+                terminalWidth: 80,
+                terminalHeight: 24,
+            }),
+            getToolRegistry: () => toolRegistry,
+            isInteractive: () => false,
+        });
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            onToolCallsUpdate,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const request = {
+            callId: 'shell-1',
+            name: 'run_shell_command',
+            args: { command: 'git status && rm -rf /tmp/should-not-run' },
+            isClientInitiated: false,
+            prompt_id: 'prompt-shell-auto-approved',
+        };
+        await scheduler.schedule([request], abortController.signal);
+        const statusUpdates = onToolCallsUpdate.mock.calls
+            .map((call) => call[0][0]?.status)
+            .filter(Boolean);
+        expect(statusUpdates).toContain('awaiting_approval');
+        expect(executeFn).not.toHaveBeenCalled();
+        expect(onAllToolCallsComplete).not.toHaveBeenCalled();
+    }, 20000);
     it('should handle two synchronous calls to schedule', async () => {
         const executeFn = vi.fn().mockResolvedValue({
             llmContent: 'Tool executed',
@@ -968,36 +1114,16 @@ describe('CoreToolScheduler request queueing', () => {
         };
         const onAllToolCallsComplete = vi.fn();
         const onToolCallsUpdate = vi.fn();
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
-            getApprovalMode: () => ApprovalMode.YOLO,
-            getAllowedTools: () => [],
-            getContentGeneratorConfig: () => ({
-                model: 'test-model',
-                authType: 'oauth-personal',
-            }),
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
+        const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            getApprovalMode: () => ApprovalMode.YOLO,
+            isInteractive: () => false,
+        });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
             onToolCallsUpdate,
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         const request1 = {
@@ -1028,28 +1154,13 @@ describe('CoreToolScheduler request queueing', () => {
     });
     it('should auto-approve remaining tool calls when first tool call is approved with ProceedAlways', async () => {
         let approvalMode = ApprovalMode.DEFAULT;
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getUsageStatisticsEnabled: () => true,
-            getDebugMode: () => false,
+        const mockConfig = createMockConfig({
             getApprovalMode: () => approvalMode,
-            getAllowedTools: () => [],
             setApprovalMode: (mode) => {
                 approvalMode = mode;
             },
-            getShellExecutionConfig: () => ({
-                terminalWidth: 90,
-                terminalHeight: 30,
-            }),
-            storage: {
-                getProjectTempDir: () => '/tmp',
-            },
-            getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-            getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
-            getUseSmartEdit: () => false,
-            getUseModelRouter: () => false,
-            getGeminiClient: () => null, // No client needed for these tests
-        };
+            isInteractive: () => false,
+        });
         const testTool = new TestApprovalTool(mockConfig);
         const toolRegistry = {
             getTool: () => testTool,
@@ -1094,7 +1205,6 @@ describe('CoreToolScheduler request queueing', () => {
                 });
             },
             getPreferredEditor: () => 'vscode',
-            onEditorClose: vi.fn(),
         });
         const abortController = new AbortController();
         // Schedule multiple tools that need confirmation
@@ -1122,27 +1232,273 @@ describe('CoreToolScheduler request queueing', () => {
             },
         ];
         await scheduler.schedule(requests, abortController.signal);
-        // Wait for all tools to be awaiting approval
+        // Wait for the FIRST tool to be awaiting approval
         await vi.waitFor(() => {
             const calls = onToolCallsUpdate.mock.calls.at(-1)?.[0];
+            // With the sequential scheduler, the update includes the active call and the queue.
             expect(calls?.length).toBe(3);
-            expect(calls?.every((call) => call.status === 'awaiting_approval')).toBe(true);
+            expect(calls?.[0].status).toBe('awaiting_approval');
+            expect(calls?.[0].request.callId).toBe('1');
+            // Check that the other two are in the queue (still in 'validating' state)
+            expect(calls?.[1].status).toBe('validating');
+            expect(calls?.[2].status).toBe('validating');
         });
-        expect(pendingConfirmations.length).toBe(3);
+        expect(pendingConfirmations.length).toBe(1);
         // Approve the first tool with ProceedAlways
         const firstConfirmation = pendingConfirmations[0];
         firstConfirmation(ToolConfirmationOutcome.ProceedAlways);
         // Wait for all tools to be completed
         await vi.waitFor(() => {
             expect(onAllToolCallsComplete).toHaveBeenCalled();
-            const completedCalls = onAllToolCallsComplete.mock.calls.at(-1)?.[0];
-            expect(completedCalls?.length).toBe(3);
-            expect(completedCalls?.every((call) => call.status === 'success')).toBe(true);
         });
+        const completedCalls = onAllToolCallsComplete.mock.calls.at(-1)?.[0];
+        expect(completedCalls?.length).toBe(3);
+        expect(completedCalls?.every((call) => call.status === 'success')).toBe(true);
         // Verify approval mode was changed
         expect(approvalMode).toBe(ApprovalMode.AUTO_EDIT);
     });
 });
+describe('CoreToolScheduler Sequential Execution', () => {
+    it('should execute tool calls in a batch sequentially', async () => {
+        // Arrange
+        let firstCallFinished = false;
+        const executeFn = vi
+            .fn()
+            .mockImplementation(async (args) => {
+            if (args.call === 1) {
+                // First call, wait for a bit to simulate work
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                firstCallFinished = true;
+                return { llmContent: 'First call done' };
+            }
+            if (args.call === 2) {
+                // Second call, should only happen after the first is finished
+                if (!firstCallFinished) {
+                    throw new Error('Second tool call started before the first one finished!');
+                }
+                return { llmContent: 'Second call done' };
+            }
+            return { llmContent: 'default' };
+        });
+        const mockTool = new MockTool({ name: 'mockTool', execute: executeFn });
+        const declarativeTool = mockTool;
+        const mockToolRegistry = {
+            getTool: () => declarativeTool,
+            getToolByName: () => declarativeTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByDisplayName: () => declarativeTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const onAllToolCallsComplete = vi.fn();
+        const onToolCallsUpdate = vi.fn();
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            getApprovalMode: () => ApprovalMode.YOLO, // Use YOLO to avoid confirmation prompts
+            isInteractive: () => false,
+        });
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            onToolCallsUpdate,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const requests = [
+            {
+                callId: '1',
+                name: 'mockTool',
+                args: { call: 1 },
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+            {
+                callId: '2',
+                name: 'mockTool',
+                args: { call: 2 },
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+        ];
+        // Act
+        await scheduler.schedule(requests, abortController.signal);
+        // Assert
+        await vi.waitFor(() => {
+            expect(onAllToolCallsComplete).toHaveBeenCalled();
+        });
+        // Check that execute was called twice
+        expect(executeFn).toHaveBeenCalledTimes(2);
+        // Check the order of calls
+        const calls = executeFn.mock.calls;
+        expect(calls[0][0]).toEqual({ call: 1 });
+        expect(calls[1][0]).toEqual({ call: 2 });
+        // The onAllToolCallsComplete should be called once with both results
+        const completedCalls = onAllToolCallsComplete.mock
+            .calls[0][0];
+        expect(completedCalls).toHaveLength(2);
+        expect(completedCalls[0].status).toBe('success');
+        expect(completedCalls[1].status).toBe('success');
+    });
+    it('should cancel subsequent tools when the signal is aborted.', async () => {
+        // Arrange
+        const abortController = new AbortController();
+        let secondCallStarted = false;
+        const executeFn = vi
+            .fn()
+            .mockImplementation(async (args) => {
+            if (args.call === 1) {
+                return { llmContent: 'First call done' };
+            }
+            if (args.call === 2) {
+                secondCallStarted = true;
+                // This call will be cancelled while it's "running".
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                // It should not return a value because it will be cancelled.
+                return { llmContent: 'Second call should not complete' };
+            }
+            if (args.call === 3) {
+                return { llmContent: 'Third call done' };
+            }
+            return { llmContent: 'default' };
+        });
+        const mockTool = new MockTool({ name: 'mockTool', execute: executeFn });
+        const declarativeTool = mockTool;
+        const mockToolRegistry = {
+            getTool: () => declarativeTool,
+            getToolByName: () => declarativeTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByDisplayName: () => declarativeTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const onAllToolCallsComplete = vi.fn();
+        const onToolCallsUpdate = vi.fn();
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            getApprovalMode: () => ApprovalMode.YOLO,
+            isInteractive: () => false,
+        });
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            onToolCallsUpdate,
+            getPreferredEditor: () => 'vscode',
+        });
+        const requests = [
+            {
+                callId: '1',
+                name: 'mockTool',
+                args: { call: 1 },
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+            {
+                callId: '2',
+                name: 'mockTool',
+                args: { call: 2 },
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+            {
+                callId: '3',
+                name: 'mockTool',
+                args: { call: 3 },
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+        ];
+        // Act
+        const schedulePromise = scheduler.schedule(requests, abortController.signal);
+        // Wait for the second call to start, then abort.
+        await vi.waitFor(() => {
+            expect(secondCallStarted).toBe(true);
+        });
+        abortController.abort();
+        await schedulePromise;
+        // Assert
+        await vi.waitFor(() => {
+            expect(onAllToolCallsComplete).toHaveBeenCalled();
+        });
+        // Check that execute was called for the first two tools only
+        expect(executeFn).toHaveBeenCalledTimes(2);
+        expect(executeFn).toHaveBeenCalledWith({ call: 1 });
+        expect(executeFn).toHaveBeenCalledWith({ call: 2 });
+        const completedCalls = onAllToolCallsComplete.mock
+            .calls[0][0];
+        expect(completedCalls).toHaveLength(3);
+        const call1 = completedCalls.find((c) => c.request.callId === '1');
+        const call2 = completedCalls.find((c) => c.request.callId === '2');
+        const call3 = completedCalls.find((c) => c.request.callId === '3');
+        expect(call1?.status).toBe('success');
+        expect(call2?.status).toBe('cancelled');
+        expect(call3?.status).toBe('cancelled');
+    });
+    it('should pass confirmation diff data into modifyWithEditor overrides', async () => {
+        const modifyWithEditorSpy = vi
+            .spyOn(modifiableToolModule, 'modifyWithEditor')
+            .mockResolvedValue({
+            updatedParams: { param: 'updated' },
+            updatedDiff: 'updated diff',
+        });
+        const mockModifiableTool = new MockModifiableTool('mockModifiableTool');
+        const mockToolRegistry = {
+            getTool: () => mockModifiableTool,
+            getToolByName: () => mockModifiableTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByDisplayName: () => mockModifiableTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const onAllToolCallsComplete = vi.fn();
+        const onToolCallsUpdate = vi.fn();
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+        });
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            onToolCallsUpdate,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        await scheduler.schedule([
+            {
+                callId: '1',
+                name: 'mockModifiableTool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+        ], abortController.signal);
+        const toolCall = scheduler
+            .toolCalls[0];
+        expect(toolCall.status).toBe('awaiting_approval');
+        const confirmationSignal = new AbortController().signal;
+        await scheduler.handleConfirmationResponse(toolCall.request.callId, async () => { }, ToolConfirmationOutcome.ModifyWithEditor, confirmationSignal);
+        expect(modifyWithEditorSpy).toHaveBeenCalled();
+        const overrides = modifyWithEditorSpy.mock.calls[modifyWithEditorSpy.mock.calls.length - 1][4];
+        expect(overrides).toEqual({
+            currentContent: 'originalContent',
+            proposedContent: 'newContent',
+        });
+        modifyWithEditorSpy.mockRestore();
+    });
+});
 describe('truncateAndSaveToFile', () => {
     const mockWriteFile = vi.mocked(fs.writeFile);
     const THRESHOLD = 40_000;