feat(core, cli): Implement sequential approval. (#11593)

packages/a2a-server/src/agent/task.test.ts

@@ -4,11 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Task } from './task.js';
 import type { Config, ToolCallRequestInfo } from '@google/gemini-cli-core';
 import { createMockConfig } from '../utils/testing_utils.js';
 import type { ExecutionEventBus } from '@a2a-js/sdk/server';
+import type { ToolCall } from '@google/gemini-cli-core';
 
 describe('Task', () => {
   it('scheduleToolCalls should not modify the input requests array', async () => {
@@ -94,4 +95,122 @@ describe('Task', () => {
       );
     });
   });
+
+  describe('_schedulerToolCallsUpdate', () => {
+    let task: Task;
+    type SpyInstance = ReturnType<typeof vi.spyOn>;
+    let setTaskStateAndPublishUpdateSpy: SpyInstance;
+
+    beforeEach(() => {
+      const mockConfig = createMockConfig();
+      const mockEventBus: ExecutionEventBus = {
+        publish: vi.fn(),
+        on: vi.fn(),
+        off: vi.fn(),
+        once: vi.fn(),
+        removeAllListeners: vi.fn(),
+        finished: vi.fn(),
+      };
+
+      // @ts-expect-error - Calling private constructor
+      task = new Task(
+        'task-id',
+        'context-id',
+        mockConfig as Config,
+        mockEventBus,
+      );
+
+      // Spy on the method we want to check calls for
+      setTaskStateAndPublishUpdateSpy = vi.spyOn(
+        task,
+        'setTaskStateAndPublishUpdate',
+      );
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should set state to input-required when a tool is awaiting approval and none are executing', () => {
+      const toolCalls = [
+        { request: { callId: '1' }, status: 'awaiting_approval' },
+      ] as ToolCall[];
+
+      // @ts-expect-error - Calling private method
+      task._schedulerToolCallsUpdate(toolCalls);
+
+      // The last call should be the final state update
+      expect(setTaskStateAndPublishUpdateSpy).toHaveBeenLastCalledWith(
+        'input-required',
+        { kind: 'state-change' },
+        undefined,
+        undefined,
+        true, // final: true
+      );
+    });
+
+    it('should NOT set state to input-required if a tool is awaiting approval but another is executing', () => {
+      const toolCalls = [
+        { request: { callId: '1' }, status: 'awaiting_approval' },
+        { request: { callId: '2' }, status: 'executing' },
+      ] as ToolCall[];
+
+      // @ts-expect-error - Calling private method
+      task._schedulerToolCallsUpdate(toolCalls);
+
+      // It will be called for status updates, but not with final: true
+      const finalCall = setTaskStateAndPublishUpdateSpy.mock.calls.find(
+        (call) => call[4] === true,
+      );
+      expect(finalCall).toBeUndefined();
+    });
+
+    it('should set state to input-required once an executing tool finishes, leaving one awaiting approval', () => {
+      const initialToolCalls = [
+        { request: { callId: '1' }, status: 'awaiting_approval' },
+        { request: { callId: '2' }, status: 'executing' },
+      ] as ToolCall[];
+      // @ts-expect-error - Calling private method
+      task._schedulerToolCallsUpdate(initialToolCalls);
+
+      // No final call yet
+      let finalCall = setTaskStateAndPublishUpdateSpy.mock.calls.find(
+        (call) => call[4] === true,
+      );
+      expect(finalCall).toBeUndefined();
+
+      // Now, the executing tool finishes. The scheduler would call _resolveToolCall for it.
+      // @ts-expect-error - Calling private method
+      task._resolveToolCall('2');
+
+      // Then another update comes in for the awaiting tool (e.g., a re-check)
+      const subsequentToolCalls = [
+        { request: { callId: '1' }, status: 'awaiting_approval' },
+      ] as ToolCall[];
+      // @ts-expect-error - Calling private method
+      task._schedulerToolCallsUpdate(subsequentToolCalls);
+
+      // NOW we should get the final call
+      finalCall = setTaskStateAndPublishUpdateSpy.mock.calls.find(
+        (call) => call[4] === true,
+      );
+      expect(finalCall).toBeDefined();
+      expect(finalCall?.[0]).toBe('input-required');
+    });
+
+    it('should NOT set state to input-required if skipFinalTrueAfterInlineEdit is true', () => {
+      task.skipFinalTrueAfterInlineEdit = true;
+      const toolCalls = [
+        { request: { callId: '1' }, status: 'awaiting_approval' },
+      ] as ToolCall[];
+
+      // @ts-expect-error - Calling private method
+      task._schedulerToolCallsUpdate(toolCalls);
+
+      const finalCall = setTaskStateAndPublishUpdateSpy.mock.calls.find(
+        (call) => call[4] === true,
+      );
+      expect(finalCall).toBeUndefined();
+    });
+  });
 });