@office-ai/aioncli-core 0.26.0 → 0.30.1

package/dist/src/agents/local-executor.test.js

@@ -8,6 +8,7 @@ import { debugLogger } from '../utils/debugLogger.js';
 import { LocalAgentExecutor } from './local-executor.js';
 import { makeFakeConfig } from '../test-utils/config.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
+import { DiscoveredMCPTool, MCP_QUALIFIED_NAME_SEPARATOR, } from '../tools/mcp-tool.js';
 import { LSTool } from '../tools/ls.js';
 import { LS_TOOL_NAME, READ_FILE_TOOL_NAME } from '../tools/tool-names.js';
 import { GeminiChat, StreamEventType, } from '../core/geminiChat.js';
@@ -17,14 +18,15 @@ import { getDirectoryContextString } from '../utils/environmentContext.js';
 import { z } from 'zod';
 import { promptIdContext } from '../utils/promptIdContext.js';
 import { logAgentStart, logAgentFinish, logRecoveryAttempt, } from '../telemetry/loggers.js';
+import { LlmRole } from '../telemetry/types.js';
 import { AgentStartEvent, AgentFinishEvent, RecoveryAttemptEvent, } from '../telemetry/types.js';
 import { AgentTerminateMode } from './types.js';
 import { CompressionStatus } from '../core/turn.js';
 import { ChatCompressionService } from '../services/chatCompressionService.js';
 import { getModelConfigAlias } from './registry.js';
-const { mockSendMessageStream, mockExecuteToolCall, mockSetSystemInstruction, mockCompress, } = vi.hoisted(() => ({
+const { mockSendMessageStream, mockScheduleAgentTools, mockSetSystemInstruction, mockCompress, } = vi.hoisted(() => ({
     mockSendMessageStream: vi.fn(),
-    mockExecuteToolCall: vi.fn(),
+    mockScheduleAgentTools: vi.fn(),
     mockSetSystemInstruction: vi.fn(),
     mockCompress: vi.fn(),
 }));
@@ -49,8 +51,8 @@ vi.mock('../core/geminiChat.js', async (importOriginal) => {
         })),
     };
 });
-vi.mock('../core/nonInteractiveToolExecutor.js', () => ({
-    executeToolCall: mockExecuteToolCall,
+vi.mock('./agent-scheduler.js', () => ({
+    scheduleAgentTools: mockScheduleAgentTools,
 }));
 vi.mock('../utils/version.js', () => ({
     getVersion: vi.fn().mockResolvedValue('1.2.3'),
@@ -61,6 +63,20 @@ vi.mock('../telemetry/loggers.js', () => ({
     logAgentFinish: vi.fn(),
     logRecoveryAttempt: vi.fn(),
 }));
+vi.mock('../utils/schemaValidator.js', () => ({
+    SchemaValidator: {
+        validate: vi.fn().mockReturnValue(null),
+        validateSchema: vi.fn().mockReturnValue(null),
+    },
+}));
+vi.mock('../utils/filesearch/crawler.js', () => ({
+    crawl: vi.fn().mockResolvedValue([]),
+}));
+vi.mock('../telemetry/clearcut-logger/clearcut-logger.js', () => ({
+    ClearcutLogger: class {
+        log() { }
+    },
+}));
 vi.mock('../utils/promptIdContext.js', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -141,10 +157,22 @@ const createTestDefinition = (tools = [LS_TOOL_NAME], runConfigOverrides = {}, o
         name: 'TestAgent',
         description: 'An agent for testing.',
         inputConfig: {
-            inputs: { goal: { type: 'string', required: true, description: 'goal' } },
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    goal: { type: 'string', description: 'goal' },
+                },
+                required: ['goal'],
+            },
         },
-        modelConfig: { model: 'gemini-test-model', temp: 0, top_p: 1 },
-        runConfig: { max_time_minutes: 5, max_turns: 5, ...runConfigOverrides },
+        modelConfig: {
+            model: 'gemini-test-model',
+            generateContentConfig: {
+                temperature: 0,
+                topP: 1,
+            },
+        },
+        runConfig: { maxTimeMinutes: 5, maxTurns: 5, ...runConfigOverrides },
         promptConfig: { systemPrompt: 'Achieve the goal: ${goal}.' },
         toolConfig: { tools },
         outputConfig,
@@ -161,7 +189,7 @@ describe('LocalAgentExecutor', () => {
         mockSetHistory.mockClear();
         mockSendMessageStream.mockReset();
         mockSetSystemInstruction.mockReset();
-        mockExecuteToolCall.mockReset();
+        mockScheduleAgentTools.mockReset();
         mockedLogAgentStart.mockReset();
         mockedLogAgentFinish.mockReset();
         mockedPromptIdContext.getStore.mockReset();
@@ -187,6 +215,9 @@ describe('LocalAgentExecutor', () => {
         parentToolRegistry.registerTool(new MockTool({ name: READ_FILE_TOOL_NAME }));
         parentToolRegistry.registerTool(MOCK_TOOL_NOT_ALLOWED);
         vi.spyOn(mockConfig, 'getToolRegistry').mockReturnValue(parentToolRegistry);
+        vi.spyOn(mockConfig, 'getAgentRegistry').mockReturnValue({
+            getAllAgentNames: () => [],
+        });
         mockedGetDirectoryContextString.mockResolvedValue('Mocked Environment Context');
         activities = [];
         onActivity = (activity) => activities.push(activity);
@@ -256,13 +287,80 @@ describe('LocalAgentExecutor', () => {
             const secondPart = startHistory?.[1]?.parts?.[0];
             expect(secondPart?.text).toBe('OK, starting on TestGoal.');
         });
+        it('should filter out subagent tools to prevent recursion', async () => {
+            const subAgentName = 'recursive-agent';
+            // Register a mock tool that simulates a subagent
+            parentToolRegistry.registerTool(new MockTool({ name: subAgentName }));
+            // Mock the agent registry to return the subagent name
+            vi.spyOn(mockConfig.getAgentRegistry(), 'getAllAgentNames').mockReturnValue([subAgentName]);
+            const definition = createTestDefinition([LS_TOOL_NAME, subAgentName]);
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            const agentRegistry = executor['toolRegistry'];
+            // LS should be present
+            expect(agentRegistry.getTool(LS_TOOL_NAME)).toBeDefined();
+            // Subagent should be filtered out
+            expect(agentRegistry.getTool(subAgentName)).toBeUndefined();
+        });
+        it('should default to ALL tools (except subagents) when toolConfig is undefined', async () => {
+            const subAgentName = 'recursive-agent';
+            // Register tools in parent registry
+            // LS_TOOL_NAME is already registered in beforeEach
+            const otherTool = new MockTool({ name: 'other-tool' });
+            parentToolRegistry.registerTool(otherTool);
+            parentToolRegistry.registerTool(new MockTool({ name: subAgentName }));
+            // Mock the agent registry to return the subagent name
+            vi.spyOn(mockConfig.getAgentRegistry(), 'getAllAgentNames').mockReturnValue([subAgentName]);
+            // Create definition and force toolConfig to be undefined
+            const definition = createTestDefinition();
+            definition.toolConfig = undefined;
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            const agentRegistry = executor['toolRegistry'];
+            // Should include standard tools
+            expect(agentRegistry.getTool(LS_TOOL_NAME)).toBeDefined();
+            expect(agentRegistry.getTool('other-tool')).toBeDefined();
+            // Should exclude subagent
+            expect(agentRegistry.getTool(subAgentName)).toBeUndefined();
+        });
+        it('should enforce qualified names for MCP tools in agent definitions', async () => {
+            const serverName = 'mcp-server';
+            const toolName = 'mcp-tool';
+            const qualifiedName = `${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${toolName}`;
+            const mockMcpTool = {
+                tool: vi.fn(),
+                callTool: vi.fn(),
+            };
+            const mcpTool = new DiscoveredMCPTool(mockMcpTool, serverName, toolName, 'description', {}, mockConfig.getMessageBus());
+            // Mock getTool to return our real DiscoveredMCPTool instance
+            const getToolSpy = vi
+                .spyOn(parentToolRegistry, 'getTool')
+                .mockImplementation((name) => {
+                if (name === toolName || name === qualifiedName) {
+                    return mcpTool;
+                }
+                return undefined;
+            });
+            // 1. Qualified name works and registers the tool (using short name per status quo)
+            const definition = createTestDefinition([qualifiedName]);
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            const agentRegistry = executor['toolRegistry'];
+            // Registry shortening logic means it's registered as 'mcp-tool' internally
+            expect(agentRegistry.getTool(toolName)).toBeDefined();
+            // 2. Unqualified name for MCP tool THROWS
+            const badDefinition = createTestDefinition([toolName]);
+            await expect(LocalAgentExecutor.create(badDefinition, mockConfig, onActivity)).rejects.toThrow(/must be requested with its server prefix/);
+            getToolSpy.mockRestore();
+        });
     });
     describe('run (Execution Loop and Logic)', () => {
         it('should log AgentFinish with error if run throws', async () => {
             const definition = createTestDefinition();
             // Make the definition invalid to cause an error during run
-            definition.inputConfig.inputs = {
-                goal: { type: 'string', required: true, description: 'goal' },
+            definition.inputConfig.inputSchema = {
+                type: 'object',
+                properties: {
+                    goal: { type: 'string', description: 'goal' },
+                },
+                required: ['goal'],
             };
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             // Run without inputs to trigger validation error
@@ -279,34 +377,36 @@ describe('LocalAgentExecutor', () => {
             const inputs = { goal: 'Find files' };
             // Turn 1: Model calls ls
             mockModelResponse([{ name: LS_TOOL_NAME, args: { path: '.' }, id: 'call1' }], 'T1: Listing');
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'success',
-                request: {
-                    callId: 'call1',
-                    name: LS_TOOL_NAME,
-                    args: { path: '.' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: 'call1',
-                    resultDisplay: 'file1.txt',
-                    responseParts: [
-                        {
-                            functionResponse: {
-                                name: LS_TOOL_NAME,
-                                response: { result: 'file1.txt' },
-                                id: 'call1',
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call1',
+                        name: LS_TOOL_NAME,
+                        args: { path: '.' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: 'call1',
+                        resultDisplay: 'file1.txt',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    response: { result: 'file1.txt' },
+                                    id: 'call1',
+                                },
                             },
-                        },
-                    ],
-                    error: undefined,
-                    errorType: undefined,
-                    contentLength: undefined,
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: undefined,
+                    },
                 },
-            });
+            ]);
             // Turn 2: Model calls complete_task with required output
             mockModelResponse([
                 {
@@ -380,34 +480,36 @@ describe('LocalAgentExecutor', () => {
             mockModelResponse([
                 { name: LS_TOOL_NAME, args: { path: '.' }, id: 'call1' },
             ]);
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'success',
-                request: {
-                    callId: 'call1',
-                    name: LS_TOOL_NAME,
-                    args: { path: '.' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: 'call1',
-                    resultDisplay: 'ok',
-                    responseParts: [
-                        {
-                            functionResponse: {
-                                name: LS_TOOL_NAME,
-                                response: {},
-                                id: 'call1',
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call1',
+                        name: LS_TOOL_NAME,
+                        args: { path: '.' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: 'call1',
+                        resultDisplay: 'ok',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    response: {},
+                                    id: 'call1',
+                                },
                             },
-                        },
-                    ],
-                    error: undefined,
-                    errorType: undefined,
-                    contentLength: undefined,
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: undefined,
+                    },
                 },
-            });
+            ]);
             mockModelResponse([
                 {
                     name: TASK_COMPLETE_TOOL_NAME,
@@ -434,34 +536,36 @@ describe('LocalAgentExecutor', () => {
             mockModelResponse([
                 { name: LS_TOOL_NAME, args: { path: '.' }, id: 'call1' },
             ]);
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'success',
-                request: {
-                    callId: 'call1',
-                    name: LS_TOOL_NAME,
-                    args: { path: '.' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: 'call1',
-                    resultDisplay: 'ok',
-                    responseParts: [
-                        {
-                            functionResponse: {
-                                name: LS_TOOL_NAME,
-                                response: {},
-                                id: 'call1',
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call1',
+                        name: LS_TOOL_NAME,
+                        args: { path: '.' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: 'call1',
+                        resultDisplay: 'ok',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    response: {},
+                                    id: 'call1',
+                                },
                             },
-                        },
-                    ],
-                    error: undefined,
-                    errorType: undefined,
-                    contentLength: undefined,
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: undefined,
+                    },
                 },
-            });
+            ]);
             // Turn 2 (protocol violation)
             mockModelResponse([], 'I think I am done.');
             // Turn 3 (recovery turn - also fails)
@@ -574,33 +678,36 @@ describe('LocalAgentExecutor', () => {
             const bothStarted = new Promise((r) => {
                 resolveCalls = r;
             });
-            mockExecuteToolCall.mockImplementation(async (_ctx, reqInfo) => {
-                callsStarted++;
-                if (callsStarted === 2)
-                    resolveCalls();
-                await vi.advanceTimersByTimeAsync(100);
-                return {
-                    status: 'success',
-                    request: reqInfo,
-                    tool: {},
-                    invocation: {},
-                    response: {
-                        callId: reqInfo.callId,
-                        resultDisplay: 'ok',
-                        responseParts: [
-                            {
-                                functionResponse: {
-                                    name: reqInfo.name,
-                                    response: {},
-                                    id: reqInfo.callId,
+            mockScheduleAgentTools.mockImplementation(async (_ctx, requests) => {
+                const results = await Promise.all(requests.map(async (reqInfo) => {
+                    callsStarted++;
+                    if (callsStarted === 2)
+                        resolveCalls();
+                    await vi.advanceTimersByTimeAsync(100);
+                    return {
+                        status: 'success',
+                        request: reqInfo,
+                        tool: {},
+                        invocation: {},
+                        response: {
+                            callId: reqInfo.callId,
+                            resultDisplay: 'ok',
+                            responseParts: [
+                                {
+                                    functionResponse: {
+                                        name: reqInfo.name,
+                                        response: {},
+                                        id: reqInfo.callId,
+                                    },
                                 },
-                            },
-                        ],
-                        error: undefined,
-                        errorType: undefined,
-                        contentLength: undefined,
-                    },
-                };
+                            ],
+                            error: undefined,
+                            errorType: undefined,
+                            contentLength: undefined,
+                        },
+                    };
+                }));
+                return results;
             });
             // Turn 2: Completion
             mockModelResponse([
@@ -616,7 +723,7 @@ describe('LocalAgentExecutor', () => {
             await vi.advanceTimersByTimeAsync(150);
             await vi.advanceTimersByTimeAsync(1);
             const output = await runPromise;
-            expect(mockExecuteToolCall).toHaveBeenCalledTimes(2);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(1);
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
             // Safe access to message parts
             const turn2Params = getMockMessageParams(1);
@@ -657,7 +764,7 @@ describe('LocalAgentExecutor', () => {
                 .mockImplementation(() => { });
             await executor.run({ goal: 'Sec test' }, signal);
             // Verify external executor was not called (Security held)
-            expect(mockExecuteToolCall).not.toHaveBeenCalled();
+            expect(mockScheduleAgentTools).not.toHaveBeenCalled();
             // 2. Verify console warning
             expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining(`[LocalAgentExecutor] Blocked call:`));
             consoleWarnSpy.mockRestore();
@@ -761,37 +868,36 @@ describe('LocalAgentExecutor', () => {
             mockModelResponse([
                 { name: LS_TOOL_NAME, args: { path: '/fake' }, id: 'call1' },
             ]);
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'error',
-                request: {
-                    callId: 'call1',
-                    name: LS_TOOL_NAME,
-                    args: { path: '/fake' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: 'call1',
-                    resultDisplay: '',
-                    responseParts: [
-                        {
-                            functionResponse: {
-                                name: LS_TOOL_NAME,
-                                response: { error: toolErrorMessage },
-                                id: 'call1',
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'error',
+                    request: {
+                        callId: 'call1',
+                        name: LS_TOOL_NAME,
+                        args: { path: '/fake' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: 'call1',
+                        resultDisplay: '',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    response: { error: toolErrorMessage },
+                                    id: 'call1',
+                                },
                             },
-                        },
-                    ],
-                    error: {
-                        type: 'ToolError',
-                        message: toolErrorMessage,
+                        ],
+                        error: new Error(toolErrorMessage),
+                        errorType: 'ToolError',
+                        contentLength: 0,
                     },
-                    errorType: 'ToolError',
-                    contentLength: 0,
                 },
-            });
+            ]);
             // Turn 2: Model sees the error and completes
             mockModelResponse([
                 {
@@ -801,7 +907,7 @@ describe('LocalAgentExecutor', () => {
                 },
             ]);
             const output = await executor.run({ goal: 'Tool failure test' }, signal);
-            expect(mockExecuteToolCall).toHaveBeenCalledTimes(1);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(1);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
             // Verify the error was reported in the activity stream
             expect(activities).toContainEqual(expect.objectContaining({
@@ -830,36 +936,91 @@ describe('LocalAgentExecutor', () => {
             expect(output.result).toBe('Aborted due to tool failure.');
         });
     });
+    describe('Model Routing', () => {
+        it('should use model routing when the agent model is "auto"', async () => {
+            const definition = createTestDefinition();
+            definition.modelConfig.model = 'auto';
+            const mockRouter = {
+                route: vi.fn().mockResolvedValue({
+                    model: 'routed-model',
+                    metadata: { source: 'test', reasoning: 'test' },
+                }),
+            };
+            vi.spyOn(mockConfig, 'getModelRouterService').mockReturnValue(mockRouter);
+            // Mock resolved config to return 'auto'
+            vi.spyOn(mockConfig.modelConfigService, 'getResolvedConfig').mockReturnValue({
+                model: 'auto',
+                generateContentConfig: {},
+            });
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            mockModelResponse([
+                {
+                    name: TASK_COMPLETE_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'call1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            expect(mockRouter.route).toHaveBeenCalled();
+            expect(mockSendMessageStream).toHaveBeenCalledWith(expect.objectContaining({ model: 'routed-model' }), expect.any(Array), expect.any(String), expect.any(AbortSignal), LlmRole.SUBAGENT);
+        });
+        it('should NOT use model routing when the agent model is NOT "auto"', async () => {
+            const definition = createTestDefinition();
+            definition.modelConfig.model = 'concrete-model';
+            const mockRouter = {
+                route: vi.fn(),
+            };
+            vi.spyOn(mockConfig, 'getModelRouterService').mockReturnValue(mockRouter);
+            // Mock resolved config to return 'concrete-model'
+            vi.spyOn(mockConfig.modelConfigService, 'getResolvedConfig').mockReturnValue({
+                model: 'concrete-model',
+                generateContentConfig: {},
+            });
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            mockModelResponse([
+                {
+                    name: TASK_COMPLETE_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'call1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            expect(mockRouter.route).not.toHaveBeenCalled();
+            expect(mockSendMessageStream).toHaveBeenCalledWith(expect.objectContaining({ model: 'concrete-model' }), expect.any(Array), expect.any(String), expect.any(AbortSignal), LlmRole.SUBAGENT);
+        });
+    });
     describe('run (Termination Conditions)', () => {
         const mockWorkResponse = (id) => {
             mockModelResponse([{ name: LS_TOOL_NAME, args: { path: '.' }, id }]);
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'success',
-                request: {
-                    callId: id,
-                    name: LS_TOOL_NAME,
-                    args: { path: '.' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: id,
-                    resultDisplay: 'ok',
-                    responseParts: [
-                        { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
-                    ],
-                    error: undefined,
-                    errorType: undefined,
-                    contentLength: undefined,
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: id,
+                        name: LS_TOOL_NAME,
+                        args: { path: '.' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: id,
+                        resultDisplay: 'ok',
+                        responseParts: [
+                            { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: undefined,
+                    },
                 },
-            });
+            ]);
         };
         it('should terminate when max_turns is reached', async () => {
             const MAX = 2;
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_turns: MAX,
+                maxTurns: MAX,
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig);
             mockWorkResponse('t1');
@@ -872,7 +1033,7 @@ describe('LocalAgentExecutor', () => {
         });
         it('should terminate with TIMEOUT if a model call takes too long', async () => {
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_time_minutes: 0.5, // 30 seconds
+                maxTimeMinutes: 0.5, // 30 seconds
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             // Mock a model call that is interruptible by an abort signal.
@@ -883,7 +1044,7 @@ describe('LocalAgentExecutor', () => {
                     // This promise resolves when aborted, ending the generator.
                     signal?.addEventListener('abort', () => {
                         resolve();
-                    });
+                    }, { once: true });
                 });
             })());
             // Recovery turn
@@ -910,29 +1071,31 @@ describe('LocalAgentExecutor', () => {
         });
         it('should terminate with TIMEOUT if a tool call takes too long', async () => {
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_time_minutes: 1,
+                maxTimeMinutes: 1,
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig);
             mockModelResponse([
                 { name: LS_TOOL_NAME, args: { path: '.' }, id: 't1' },
             ]);
             // Long running tool
-            mockExecuteToolCall.mockImplementationOnce(async (_ctx, reqInfo) => {
+            mockScheduleAgentTools.mockImplementationOnce(async (_ctx, requests) => {
                 await vi.advanceTimersByTimeAsync(61 * 1000);
-                return {
-                    status: 'success',
-                    request: reqInfo,
-                    tool: {},
-                    invocation: {},
-                    response: {
-                        callId: 't1',
-                        resultDisplay: 'ok',
-                        responseParts: [],
-                        error: undefined,
-                        errorType: undefined,
-                        contentLength: undefined,
+                return [
+                    {
+                        status: 'success',
+                        request: requests[0],
+                        tool: {},
+                        invocation: {},
+                        response: {
+                            callId: 't1',
+                            resultDisplay: 'ok',
+                            responseParts: [],
+                            error: undefined,
+                            errorType: undefined,
+                            contentLength: undefined,
+                        },
                     },
-                };
+                ];
             });
             // Recovery turn
             mockModelResponse([], 'I give up');
@@ -959,33 +1122,35 @@ describe('LocalAgentExecutor', () => {
     describe('run (Recovery Turns)', () => {
         const mockWorkResponse = (id) => {
             mockModelResponse([{ name: LS_TOOL_NAME, args: { path: '.' }, id }]);
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'success',
-                request: {
-                    callId: id,
-                    name: LS_TOOL_NAME,
-                    args: { path: '.' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: id,
-                    resultDisplay: 'ok',
-                    responseParts: [
-                        { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
-                    ],
-                    error: undefined,
-                    errorType: undefined,
-                    contentLength: undefined,
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: id,
+                        name: LS_TOOL_NAME,
+                        args: { path: '.' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: id,
+                        resultDisplay: 'ok',
+                        responseParts: [
+                            { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: undefined,
+                    },
                 },
-            });
+            ]);
         };
         it('should recover successfully if complete_task is called during the grace turn after MAX_TURNS', async () => {
             const MAX = 1;
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_turns: MAX,
+                maxTurns: MAX,
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             // Turn 1 (hits max_turns)
@@ -1016,7 +1181,7 @@ describe('LocalAgentExecutor', () => {
         it('should fail if complete_task is NOT called during the grace turn after MAX_TURNS', async () => {
             const MAX = 1;
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_turns: MAX,
+                maxTurns: MAX,
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             // Turn 1 (hits max_turns)
@@ -1084,7 +1249,7 @@ describe('LocalAgentExecutor', () => {
         });
         it('should recover successfully from a TIMEOUT', async () => {
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_time_minutes: 0.5, // 30 seconds
+                maxTimeMinutes: 0.5, // 30 seconds
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             // Mock a model call that gets interrupted by the timeout.
@@ -1093,7 +1258,9 @@ describe('LocalAgentExecutor', () => {
             (async function* () {
                 // This promise never resolves, it waits for abort.
                 await new Promise((resolve) => {
-                    signal?.addEventListener('abort', () => resolve());
+                    signal?.addEventListener('abort', () => resolve(), {
+                        once: true,
+                    });
                 });
             })());
             // Recovery turn (succeeds)
@@ -1120,19 +1287,23 @@ describe('LocalAgentExecutor', () => {
         });
         it('should fail recovery from a TIMEOUT if the grace period also times out', async () => {
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_time_minutes: 0.5, // 30 seconds
+                maxTimeMinutes: 0.5, // 30 seconds
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             mockSendMessageStream.mockImplementationOnce(async (_key, _message, _promptId, signal) => 
             // eslint-disable-next-line require-yield
             (async function* () {
-                await new Promise((resolve) => signal?.addEventListener('abort', () => resolve()));
+                await new Promise((resolve) => signal?.addEventListener('abort', () => resolve(), {
+                    once: true,
+                }));
             })());
             // Mock the recovery call to also be long-running
             mockSendMessageStream.mockImplementationOnce(async (_key, _message, _promptId, signal) => 
             // eslint-disable-next-line require-yield
             (async function* () {
-                await new Promise((resolve) => signal?.addEventListener('abort', () => resolve()));
+                await new Promise((resolve) => signal?.addEventListener('abort', () => resolve(), {
+                    once: true,
+                }));
             })());
             const runPromise = executor.run({ goal: 'Timeout recovery fail' }, signal);
             // 1. Trigger the main timeout
@@ -1157,28 +1328,30 @@ describe('LocalAgentExecutor', () => {
     describe('Telemetry and Logging', () => {
         const mockWorkResponse = (id) => {
             mockModelResponse([{ name: LS_TOOL_NAME, args: { path: '.' }, id }]);
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'success',
-                request: {
-                    callId: id,
-                    name: LS_TOOL_NAME,
-                    args: { path: '.' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: id,
-                    resultDisplay: 'ok',
-                    responseParts: [
-                        { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
-                    ],
-                    error: undefined,
-                    errorType: undefined,
-                    contentLength: undefined,
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: id,
+                        name: LS_TOOL_NAME,
+                        args: { path: '.' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: id,
+                        resultDisplay: 'ok',
+                        responseParts: [
+                            { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: undefined,
+                    },
                 },
-            });
+            ]);
         };
         beforeEach(() => {
             mockedLogRecoveryAttempt.mockClear();
@@ -1186,7 +1359,7 @@ describe('LocalAgentExecutor', () => {
         it('should log a RecoveryAttemptEvent when a recoverable error occurs and recovery fails', async () => {
             const MAX = 1;
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_turns: MAX,
+                maxTurns: MAX,
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig);
             // Turn 1 (hits max_turns)
@@ -1206,7 +1379,7 @@ describe('LocalAgentExecutor', () => {
         it('should log a successful RecoveryAttemptEvent when recovery succeeds', async () => {
             const MAX = 1;
             const definition = createTestDefinition([LS_TOOL_NAME], {
-                max_turns: MAX,
+                maxTurns: MAX,
             });
             const executor = await LocalAgentExecutor.create(definition, mockConfig);
             // Turn 1 (hits max_turns)
@@ -1230,28 +1403,30 @@ describe('LocalAgentExecutor', () => {
     describe('Chat Compression', () => {
         const mockWorkResponse = (id) => {
             mockModelResponse([{ name: LS_TOOL_NAME, args: { path: '.' }, id }]);
-            mockExecuteToolCall.mockResolvedValueOnce({
-                status: 'success',
-                request: {
-                    callId: id,
-                    name: LS_TOOL_NAME,
-                    args: { path: '.' },
-                    isClientInitiated: false,
-                    prompt_id: 'test-prompt',
-                },
-                tool: {},
-                invocation: {},
-                response: {
-                    callId: id,
-                    resultDisplay: 'ok',
-                    responseParts: [
-                        { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
-                    ],
-                    error: undefined,
-                    errorType: undefined,
-                    contentLength: undefined,
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: id,
+                        name: LS_TOOL_NAME,
+                        args: { path: '.' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    response: {
+                        callId: id,
+                        resultDisplay: 'ok',
+                        responseParts: [
+                            { functionResponse: { name: LS_TOOL_NAME, response: {}, id } },
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: undefined,
+                    },
                 },
-            });
+            ]);
         };
         it('should attempt to compress chat history on each turn', async () => {
             const definition = createTestDefinition();