diff --git a/‎packages/a2a-server/src/agent/executor.test.ts‎
Lines changed: 61 additions & 0 deletions b/‎packages/a2a-server/src/agent/executor.test.ts‎
Lines changed: 61 additions & 0 deletions
diff --git a/‎packages/a2a-server/src/agent/executor.ts‎
Lines changed: 40 additions & 1 deletion b/‎packages/a2a-server/src/agent/executor.ts‎
Lines changed: 40 additions & 1 deletion
@@ -300,4 +300,65 @@ describe('CoderAgentExecutor', () => {
       true,
     );
   });
+
+  it('cancelTask should abort the active execution loop', async () => {
+    const abortSpy = vi.spyOn(AbortController.prototype, 'abort');
+    const taskId = 'test-task-to-cancel';
+    const contextId = 'test-context';
+
+    const mockSocket = new EventEmitter();
+    (requestStorage.getStore as Mock).mockReturnValue({
+      req: { socket: mockSocket },
+    });
+
+    const requestContext = {
+      userMessage: {
+        messageId: 'msg-1',
+        taskId,
+        contextId,
+        parts: [{ kind: 'text', text: 'a long running prompt' }],
+        metadata: {
+          coderAgent: { kind: 'agent-settings', workspacePath: '/tmp' },
+        },
+      },
+    } as unknown as RequestContext;
+
+    // Don't await this, let it run in the background.
+    // The mocked acceptUserMessage will hang until aborted.
+    const primaryPromise = executor.execute(requestContext, mockEventBus);
+
+    // Give it a moment to start and register the controller.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    const wrapper = executor.getTask(taskId);
+    expect(wrapper).toBeDefined();
+    const setTaskStateSpy = vi
+      .spyOn(wrapper!.task, 'setTaskStateAndPublishUpdate')
+      .mockImplementation((newState) => {
+        // Make the mock realistic: actually update the state when called.
+        wrapper!.task.taskState = newState;
+      });
+
+    // Now, cancel the task.
+    await executor.cancelTask(taskId, mockEventBus);
+
+    // Verify that the abort method on the controller was called and state was updated.
+    expect(abortSpy).toHaveBeenCalledOnce();
+    expect(setTaskStateSpy).toHaveBeenCalledWith(
+      'canceled',
+      expect.any(Object),
+      'Task canceled by user request.',
+      undefined,
+      true,
+    );
+
+    // Clean up the test by allowing the promise to resolve.
+    // The abort call should have unblocked the acceptUserMessage generator.
+    await primaryPromise;
+
+    // Verify task is evicted from cache
+    expect(executor.getTask(taskId)).toBeUndefined();
+
+    abortSpy.mockRestore();
+  });
 });
@@ -90,6 +90,7 @@ export class CoderAgentExecutor implements AgentExecutor {
   private tasks: Map<string, TaskWrapper> = new Map();
   // Track tasks with an active execution loop.
   private executingTasks = new Set<string>();
+  private activeAbortControllers = new Map<string, AbortController>();
 
   constructor(private taskStore?: TaskStore) {}
 
@@ -187,6 +188,35 @@ export class CoderAgentExecutor implements AgentExecutor {
     logger.info(
       `[CoderAgentExecutor] Received cancel request for task ${taskId}`,
     );
+
+    // If there is an active execution loop, just abort it.
+    // The `finally` block of the `execute` method will handle cleanup.
+    const abortController = this.activeAbortControllers.get(taskId);
+    if (abortController) {
+      logger.info(
+        `[CoderAgentExecutor] Aborting active execution loop for task ${taskId}.`,
+      );
+      const wrapper = this.tasks.get(taskId);
+      if (wrapper) {
+        const { task } = wrapper;
+        task.cancelPendingTools('Task canceled by user request.');
+        task.setTaskStateAndPublishUpdate(
+          'canceled',
+          { kind: CoderAgentEvent.StateChangeEvent },
+          'Task canceled by user request.',
+          undefined,
+          true,
+        );
+      }
+      abortController.abort();
+      return;
+    }
+
+    // If there is no active execution loop, the task is idle.
+    // We can clean it up directly.
+    logger.info(
+      `[CoderAgentExecutor] No active execution for task ${taskId}. Cleaning up directly.`,
+    );
     const wrapper = this.tasks.get(taskId);
 
     if (!wrapper) {
@@ -244,7 +274,7 @@ export class CoderAgentExecutor implements AgentExecutor {
 
     try {
       logger.info(
-        `[CoderAgentExecutor] Initiating cancellation for task ${taskId}.`,
+        `[CoderAgentExecutor] Initiating cancellation for idle task ${taskId}.`,
       );
       task.cancelPendingTools('Task canceled by user request.');
 
@@ -332,6 +362,14 @@ export class CoderAgentExecutor implements AgentExecutor {
     const abortController = new AbortController();
     const abortSignal = abortController.signal;
 
+    // Register the abort controller only for the primary execution loop.
+    if (
+      !this.executingTasks.has(taskId) &&
+      !this.activeAbortControllers.has(taskId)
+    ) {
+      this.activeAbortControllers.set(taskId, abortController);
+    }
+
     if (store) {
       // Grab the raw socket from the request object
       const socket = store.req.socket;
@@ -644,6 +682,7 @@ export class CoderAgentExecutor implements AgentExecutor {
       }
     } finally {
       if (isPrimaryExecution) {
+        this.activeAbortControllers.delete(taskId); // Clean up the reference
         this.executingTasks.delete(taskId);
         logger.info(
           `[CoderAgentExecutor] Saving final state for task ${taskId}.`,