@google/gemini-cli-a2a-server 0.33.0-preview.13 → 0.33.0-preview.14

package/dist/src/agent/executor.test.js

@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CoderAgentExecutor } from './executor.js';
+import { EventEmitter } from 'node:events';
+import { requestStorage } from '../http/requestStorage.js';
+// Mocks for constructor dependencies
+vi.mock('../config/config.js', () => ({
+    loadConfig: vi.fn().mockReturnValue({
+        getSessionId: () => 'test-session',
+        getTargetDir: () => '/tmp',
+        getCheckpointingEnabled: () => false,
+    }),
+    loadEnvironment: vi.fn(),
+    setTargetDir: vi.fn().mockReturnValue('/tmp'),
+}));
+vi.mock('../config/settings.js', () => ({
+    loadSettings: vi.fn().mockReturnValue({}),
+}));
+vi.mock('../config/extension.js', () => ({
+    loadExtensions: vi.fn().mockReturnValue([]),
+}));
+vi.mock('../http/requestStorage.js', () => ({
+    requestStorage: {
+        getStore: vi.fn(),
+    },
+}));
+vi.mock('./task.js', () => {
+    const mockTaskInstance = (taskId, contextId) => ({
+        id: taskId,
+        contextId,
+        taskState: 'working',
+        acceptUserMessage: vi
+            .fn()
+            .mockImplementation(async function* (context, aborted) {
+            const isConfirmation = context.userMessage.parts.some((p) => p.kind === 'confirmation');
+            // Hang only for main user messages (text), allow confirmations to finish quickly
+            if (!isConfirmation && aborted) {
+                await new Promise((resolve) => {
+                    aborted.addEventListener('abort', resolve, { once: true });
+                });
+            }
+            yield { type: 'content', value: 'hello' };
+        }),
+        acceptAgentMessage: vi.fn().mockResolvedValue(undefined),
+        scheduleToolCalls: vi.fn().mockResolvedValue(undefined),
+        waitForPendingTools: vi.fn().mockResolvedValue(undefined),
+        getAndClearCompletedTools: vi.fn().mockReturnValue([]),
+        addToolResponsesToHistory: vi.fn(),
+        sendCompletedToolsToLlm: vi.fn().mockImplementation(async function* () { }),
+        cancelPendingTools: vi.fn(),
+        setTaskStateAndPublishUpdate: vi.fn(),
+        dispose: vi.fn(),
+        getMetadata: vi.fn().mockResolvedValue({}),
+        geminiClient: {
+            initialize: vi.fn().mockResolvedValue(undefined),
+        },
+        toSDKTask: () => ({
+            id: taskId,
+            contextId,
+            kind: 'task',
+            status: { state: 'working', timestamp: new Date().toISOString() },
+            metadata: {},
+            history: [],
+            artifacts: [],
+        }),
+    });
+    const MockTask = vi.fn().mockImplementation(mockTaskInstance);
+    MockTask.create = vi
+        .fn()
+        .mockImplementation(async (taskId, contextId) => mockTaskInstance(taskId, contextId));
+    return { Task: MockTask };
+});
+describe('CoderAgentExecutor', () => {
+    let executor;
+    let mockTaskStore;
+    let mockEventBus;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockTaskStore = {
+            save: vi.fn().mockResolvedValue(undefined),
+            load: vi.fn().mockResolvedValue(undefined),
+            delete: vi.fn().mockResolvedValue(undefined),
+            list: vi.fn().mockResolvedValue([]),
+        };
+        mockEventBus = new EventEmitter();
+        mockEventBus.publish = vi.fn();
+        mockEventBus.finished = vi.fn();
+        executor = new CoderAgentExecutor(mockTaskStore);
+    });
+    it('should distinguish between primary and secondary execution', async () => {
+        const taskId = 'test-task';
+        const contextId = 'test-context';
+        const mockSocket = new EventEmitter();
+        const requestContext = {
+            userMessage: {
+                messageId: 'msg-1',
+                taskId,
+                contextId,
+                parts: [{ kind: 'text', text: 'hi' }],
+                metadata: {
+                    coderAgent: { kind: 'agent-settings', workspacePath: '/tmp' },
+                },
+            },
+        };
+        // Mock requestStorage for primary
+        requestStorage.getStore.mockReturnValue({
+            req: { socket: mockSocket },
+        });
+        // First execution (Primary)
+        const primaryPromise = executor.execute(requestContext, mockEventBus);
+        // Give it enough time to reach line 490 in executor.ts
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        expect(executor.executingTasks.has(taskId)).toBe(true);
+        const wrapper = executor.getTask(taskId);
+        expect(wrapper).toBeDefined();
+        // Mock requestStorage for secondary
+        const secondarySocket = new EventEmitter();
+        requestStorage.getStore.mockReturnValue({
+            req: { socket: secondarySocket },
+        });
+        const secondaryRequestContext = {
+            userMessage: {
+                messageId: 'msg-2',
+                taskId,
+                contextId,
+                parts: [{ kind: 'confirmation', callId: '1', outcome: 'proceed' }],
+                metadata: {
+                    coderAgent: { kind: 'agent-settings', workspacePath: '/tmp' },
+                },
+            },
+        };
+        const secondaryPromise = executor.execute(secondaryRequestContext, mockEventBus);
+        // Secondary execution should NOT add to executingTasks (already there)
+        // and should return early after its loop
+        await secondaryPromise;
+        // Task should still be in executingTasks and NOT disposed
+        expect(executor.executingTasks.has(taskId)).toBe(true);
+        expect(wrapper?.task.dispose).not.toHaveBeenCalled();
+        // Now simulate secondary socket closure - it should NOT affect primary
+        secondarySocket.emit('end');
+        expect(executor.executingTasks.has(taskId)).toBe(true);
+        expect(wrapper?.task.dispose).not.toHaveBeenCalled();
+        // Set to terminal state to verify disposal on finish
+        wrapper.task.taskState = 'completed';
+        // Now close primary socket
+        mockSocket.emit('end');
+        await primaryPromise;
+        expect(executor.executingTasks.has(taskId)).toBe(false);
+        expect(wrapper?.task.dispose).toHaveBeenCalled();
+    });
+    it('should evict task from cache when it reaches terminal state', async () => {
+        const taskId = 'test-task-terminal';
+        const contextId = 'test-context';
+        const mockSocket = new EventEmitter();
+        requestStorage.getStore.mockReturnValue({
+            req: { socket: mockSocket },
+        });
+        const requestContext = {
+            userMessage: {
+                messageId: 'msg-1',
+                taskId,
+                contextId,
+                parts: [{ kind: 'text', text: 'hi' }],
+                metadata: {
+                    coderAgent: { kind: 'agent-settings', workspacePath: '/tmp' },
+                },
+            },
+        };
+        const primaryPromise = executor.execute(requestContext, mockEventBus);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        const wrapper = executor.getTask(taskId);
+        expect(wrapper).toBeDefined();
+        // Simulate terminal state
+        wrapper.task.taskState = 'completed';
+        // Finish primary execution
+        mockSocket.emit('end');
+        await primaryPromise;
+        expect(executor.getTask(taskId)).toBeUndefined();
+        expect(wrapper.task.dispose).toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=executor.test.js.map

package/dist/src/agent/executor.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.test.js","sourceRoot":"","sources":["../../../src/agent/executor.test.ts"],"names":[],"mappings":"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"}

package/dist/src/agent/task-event-driven.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/agent/task-event-driven.test.js

@@ -0,0 +1,446 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Task } from './task.js';
+import { MessageBusType, ToolConfirmationOutcome, ApprovalMode, Scheduler, } from '@google/gemini-cli-core';
+import { createMockConfig } from '../utils/testing_utils.js';
+describe('Task Event-Driven Scheduler', () => {
+    let mockConfig;
+    let mockEventBus;
+    let messageBus;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockConfig = createMockConfig({
+            isEventDrivenSchedulerEnabled: () => true,
+        });
+        messageBus = mockConfig.getMessageBus();
+        mockEventBus = {
+            publish: vi.fn(),
+            on: vi.fn(),
+            off: vi.fn(),
+            once: vi.fn(),
+            removeAllListeners: vi.fn(),
+            finished: vi.fn(),
+        };
+    });
+    it('should instantiate Scheduler when enabled', () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        expect(task.scheduler).toBeInstanceOf(Scheduler);
+    });
+    it('should subscribe to TOOL_CALLS_UPDATE and map status changes', async () => {
+        // @ts-expect-error - Calling private constructor
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'ls', args: {} },
+            status: 'executing',
+        };
+        // Simulate MessageBus event
+        // Simulate MessageBus event
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        if (!handler) {
+            throw new Error('TOOL_CALLS_UPDATE handler not found');
+        }
+        handler({
+            type: MessageBusType.TOOL_CALLS_UPDATE,
+            toolCalls: [toolCall],
+        });
+        expect(mockEventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            status: expect.objectContaining({
+                state: 'submitted', // initial task state
+            }),
+            metadata: expect.objectContaining({
+                coderAgent: expect.objectContaining({
+                    kind: 'tool-call-update',
+                }),
+            }),
+        }));
+    });
+    it('should handle tool confirmations by publishing to MessageBus', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'ls', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-1',
+            confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
+        };
+        // Simulate MessageBus event to stash the correlationId
+        // Simulate MessageBus event
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        if (!handler) {
+            throw new Error('TOOL_CALLS_UPDATE handler not found');
+        }
+        handler({
+            type: MessageBusType.TOOL_CALLS_UPDATE,
+            toolCalls: [toolCall],
+        });
+        // Simulate A2A client confirmation
+        const part = {
+            kind: 'data',
+            data: {
+                callId: '1',
+                outcome: 'proceed_once',
+            },
+        };
+        const handled = await task._handleToolConfirmationPart(part);
+        expect(handled).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-1',
+            confirmed: true,
+            outcome: ToolConfirmationOutcome.ProceedOnce,
+        }));
+    });
+    it('should handle Rejection (Cancel) and Modification (ModifyWithEditor)', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'ls', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-1',
+            confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
+        // Simulate Rejection (Cancel)
+        const handled = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '1', outcome: 'cancel' },
+        });
+        expect(handled).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-1',
+            confirmed: false,
+        }));
+        const toolCall2 = {
+            request: { callId: '2', name: 'ls', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-2',
+            confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
+        };
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall2] });
+        // Simulate ModifyWithEditor
+        const handled2 = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '2', outcome: 'modify_with_editor' },
+        });
+        expect(handled2).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-2',
+            confirmed: false,
+            outcome: ToolConfirmationOutcome.ModifyWithEditor,
+            payload: undefined,
+        }));
+    });
+    it('should handle MCP Server tool operations correctly', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'call_mcp_tool', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-mcp-1',
+            confirmationDetails: {
+                type: 'mcp',
+                title: 'MCP Server Operation',
+                prompt: 'test_mcp',
+            },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
+        // Simulate ProceedOnce for MCP
+        const handled = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '1', outcome: 'proceed_once' },
+        });
+        expect(handled).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-mcp-1',
+            confirmed: true,
+            outcome: ToolConfirmationOutcome.ProceedOnce,
+        }));
+    });
+    it('should handle MCP Server tool ProceedAlwaysServer outcome', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'call_mcp_tool', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-mcp-2',
+            confirmationDetails: {
+                type: 'mcp',
+                title: 'MCP Server Operation',
+                prompt: 'test_mcp',
+            },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
+        const handled = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '1', outcome: 'proceed_always_server' },
+        });
+        expect(handled).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-mcp-2',
+            confirmed: true,
+            outcome: ToolConfirmationOutcome.ProceedAlwaysServer,
+        }));
+    });
+    it('should handle MCP Server tool ProceedAlwaysTool outcome', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'call_mcp_tool', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-mcp-3',
+            confirmationDetails: {
+                type: 'mcp',
+                title: 'MCP Server Operation',
+                prompt: 'test_mcp',
+            },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
+        const handled = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '1', outcome: 'proceed_always_tool' },
+        });
+        expect(handled).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-mcp-3',
+            confirmed: true,
+            outcome: ToolConfirmationOutcome.ProceedAlwaysTool,
+        }));
+    });
+    it('should handle MCP Server tool ProceedAlwaysAndSave outcome', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'call_mcp_tool', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-mcp-4',
+            confirmationDetails: {
+                type: 'mcp',
+                title: 'MCP Server Operation',
+                prompt: 'test_mcp',
+            },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
+        const handled = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '1', outcome: 'proceed_always_and_save' },
+        });
+        expect(handled).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-mcp-4',
+            confirmed: true,
+            outcome: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+        }));
+    });
+    it('should execute without confirmation in YOLO mode and not transition to input-required', async () => {
+        // Enable YOLO mode
+        const yoloConfig = createMockConfig({
+            isEventDrivenSchedulerEnabled: () => true,
+            getApprovalMode: () => ApprovalMode.YOLO,
+        });
+        const yoloMessageBus = yoloConfig.getMessageBus();
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', yoloConfig, mockEventBus);
+        task.setTaskStateAndPublishUpdate = vi.fn();
+        const toolCall = {
+            request: { callId: '1', name: 'ls', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-1',
+            confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
+        };
+        const handler = yoloMessageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
+        // Should NOT auto-publish ProceedOnce anymore, because PolicyEngine handles it directly
+        expect(yoloMessageBus.publish).not.toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+        }));
+        // Should NOT transition to input-required since it was auto-approved
+        expect(task.setTaskStateAndPublishUpdate).not.toHaveBeenCalledWith('input-required', expect.anything(), undefined, undefined, true);
+    });
+    it('should handle output updates via the message bus', async () => {
+        // @ts-expect-error - Calling private constructor
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall = {
+            request: { callId: '1', name: 'ls', args: {} },
+            status: 'executing',
+            liveOutput: 'chunk1',
+        };
+        // Simulate MessageBus event
+        // Simulate MessageBus event
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        if (!handler) {
+            throw new Error('TOOL_CALLS_UPDATE handler not found');
+        }
+        handler({
+            type: MessageBusType.TOOL_CALLS_UPDATE,
+            toolCalls: [toolCall],
+        });
+        // Should publish artifact update for output
+        expect(mockEventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            kind: 'artifact-update',
+            artifact: expect.objectContaining({
+                artifactId: 'tool-1-output',
+                parts: [{ kind: 'text', text: 'chunk1' }],
+            }),
+        }));
+    });
+    it('should complete artifact creation without hanging', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCallId = 'create-file-123';
+        task['_registerToolCall'](toolCallId, 'executing');
+        const toolCall = {
+            request: {
+                callId: toolCallId,
+                name: 'writeFile',
+                args: { path: 'test.sh' },
+            },
+            status: 'success',
+            result: { ok: true },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
+        // The tool should be complete and registered appropriately, eventually
+        // triggering the toolCompletionPromise resolution when all clear.
+        const internalTask = task;
+        expect(internalTask.completedToolCalls.length).toBe(1);
+        expect(internalTask.pendingToolCalls.size).toBe(0);
+    });
+    it('should preserve messageId across multiple text chunks to prevent UI duplication', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        // Initialize the ID for the first turn (happens internally upon LLM stream)
+        task.currentAgentMessageId = 'test-id-123';
+        // Simulate sending multiple text chunks
+        task._sendTextContent('chunk 1');
+        task._sendTextContent('chunk 2');
+        // Both text contents should have been published with the same messageId
+        const textCalls = mockEventBus.publish.mock.calls.filter((call) => call[0].status?.message?.kind === 'message');
+        expect(textCalls.length).toBe(2);
+        expect(textCalls[0][0].status.message.messageId).toBe('test-id-123');
+        expect(textCalls[1][0].status.message.messageId).toBe('test-id-123');
+        // Simulate starting a new turn by calling getAndClearCompletedTools
+        // (which precedes sendCompletedToolsToLlm where a new ID is minted)
+        task.getAndClearCompletedTools();
+        // sendCompletedToolsToLlm internally rolls the ID forward.
+        // Simulate what sendCompletedToolsToLlm does:
+        const internalTask = task;
+        internalTask.setTaskStateAndPublishUpdate('working', {});
+        // Simulate what sendCompletedToolsToLlm does: generate a new UUID for the next turn
+        task.currentAgentMessageId = 'test-id-456';
+        task._sendTextContent('chunk 3');
+        const secondTurnCalls = mockEventBus.publish.mock.calls.filter((call) => call[0].status?.message?.messageId === 'test-id-456');
+        expect(secondTurnCalls.length).toBe(1);
+        expect(secondTurnCalls[0][0].status.message.parts[0].text).toBe('chunk 3');
+    });
+    it('should handle parallel tool calls correctly', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const toolCall1 = {
+            request: { callId: '1', name: 'ls', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-1',
+            confirmationDetails: { type: 'info', title: 'test 1', prompt: 'test 1' },
+        };
+        const toolCall2 = {
+            request: { callId: '2', name: 'pwd', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-2',
+            confirmationDetails: { type: 'info', title: 'test 2', prompt: 'test 2' },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        // Publish update for both tool calls simultaneously
+        handler({
+            type: MessageBusType.TOOL_CALLS_UPDATE,
+            toolCalls: [toolCall1, toolCall2],
+        });
+        // Confirm first tool call
+        const handled1 = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '1', outcome: 'proceed_once' },
+        });
+        expect(handled1).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-1',
+            confirmed: true,
+        }));
+        // Confirm second tool call
+        const handled2 = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: '2', outcome: 'cancel' },
+        });
+        expect(handled2).toBe(true);
+        expect(messageBus.publish).toHaveBeenCalledWith(expect.objectContaining({
+            type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
+            correlationId: 'corr-2',
+            confirmed: false,
+        }));
+    });
+    it('should wait for executing tools before transitioning to input-required state', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        task.setTaskStateAndPublishUpdate = vi.fn();
+        // Register tool 1 as executing
+        task['_registerToolCall']('1', 'executing');
+        const toolCall1 = {
+            request: { callId: '1', name: 'ls', args: {} },
+            status: 'executing',
+        };
+        const toolCall2 = {
+            request: { callId: '2', name: 'pwd', args: {} },
+            status: 'awaiting_approval',
+            correlationId: 'corr-2',
+            confirmationDetails: { type: 'info', title: 'test 2', prompt: 'test 2' },
+        };
+        const handler = messageBus.subscribe.mock.calls.find((call) => call[0] === MessageBusType.TOOL_CALLS_UPDATE)?.[1];
+        handler({
+            type: MessageBusType.TOOL_CALLS_UPDATE,
+            toolCalls: [toolCall1, toolCall2],
+        });
+        // Should NOT transition to input-required yet
+        expect(task.setTaskStateAndPublishUpdate).not.toHaveBeenCalledWith('input-required', expect.anything(), undefined, undefined, true);
+        // Complete tool 1
+        const toolCall1Complete = {
+            ...toolCall1,
+            status: 'success',
+            result: { ok: true },
+        };
+        handler({
+            type: MessageBusType.TOOL_CALLS_UPDATE,
+            toolCalls: [toolCall1Complete, toolCall2],
+        });
+        // Now it should transition
+        expect(task.setTaskStateAndPublishUpdate).toHaveBeenCalledWith('input-required', expect.anything(), undefined, undefined, true);
+    });
+    it('should ignore confirmations for unknown tool calls', async () => {
+        // @ts-expect-error - Calling private constructor
+        const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
+        const handled = await task._handleToolConfirmationPart({
+            kind: 'data',
+            data: { callId: 'unknown-id', outcome: 'proceed_once' },
+        });
+        // Should return false for unhandled tool call
+        expect(handled).toBe(false);
+        // Should not publish anything to the message bus
+        expect(messageBus.publish).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=task-event-driven.test.js.map