Return task data in cancellation result

Author: LucaButBoring

src/integration-tests/taskLifecycle.test.ts

@@ -10,6 +10,8 @@ import {
     CreateTaskResultSchema,
     ElicitRequestSchema,
     ElicitResultSchema,
+    ErrorCode,
+    McpError,
     RELATED_TASK_META_KEY,
     TaskSchema
 } from '../types.js';
@@ -316,7 +318,7 @@ describe('Task Lifecycle Integration Tests', () => {
     });
 
     describe('Task Cancellation', () => {
-        it('should cancel a working task', async () => {
+        it('should cancel a working task and return the cancelled task', async () => {
             const client = new Client({
                 name: 'test-client',
                 version: '1.0.0'
@@ -348,17 +350,24 @@ describe('Task Lifecycle Integration Tests', () => {
             let task = await taskStore.getTask(taskId);
             expect(task?.status).toBe('working');
 
-            // Cancel the task
-            await taskStore.updateTaskStatus(taskId, 'cancelled');
+            // Cancel the task via client.cancelTask - per spec, returns Result & Task
+            const cancelResult = await client.cancelTask({ taskId });
 
-            // Verify task is cancelled
+            // Verify the cancel response includes the cancelled task (per MCP spec CancelTaskResult is Result & Task)
+            expect(cancelResult.taskId).toBe(taskId);
+            expect(cancelResult.status).toBe('cancelled');
+            expect(cancelResult.createdAt).toBeDefined();
+            expect(cancelResult.lastUpdatedAt).toBeDefined();
+            expect(cancelResult.ttl).toBeDefined();
+
+            // Verify task is cancelled in store as well
             task = await taskStore.getTask(taskId);
             expect(task?.status).toBe('cancelled');
 
             await transport.close();
         });
 
-        it('should reject cancellation of completed task', async () => {
+        it('should reject cancellation of completed task with error code -32602', async () => {
             const client = new Client({
                 name: 'test-client',
                 version: '1.0.0'
@@ -393,8 +402,13 @@ describe('Task Lifecycle Integration Tests', () => {
             const task = await taskStore.getTask(taskId);
             expect(task?.status).toBe('completed');
 
-            // Try to cancel (should fail)
-            await expect(taskStore.updateTaskStatus(taskId, 'cancelled')).rejects.toThrow();
+            // Try to cancel via tasks/cancel request (should fail with -32602)
+            await expect(client.cancelTask({ taskId })).rejects.toSatisfy((error: McpError) => {
+                expect(error).toBeInstanceOf(McpError);
+                expect(error.code).toBe(ErrorCode.InvalidParams);
+                expect(error.message).toContain('Cannot cancel task in terminal status');
+                return true;
+            });
 
             await transport.close();
         });
@@ -775,7 +789,7 @@ describe('Task Lifecycle Integration Tests', () => {
     });
 
     describe('Error Handling', () => {
-        it('should return null for non-existent task', async () => {
+        it('should return error code -32602 for non-existent task in tasks/get', async () => {
             const client = new Client({
                 name: 'test-client',
                 version: '1.0.0'
@@ -784,14 +798,18 @@ describe('Task Lifecycle Integration Tests', () => {
             const transport = new StreamableHTTPClientTransport(baseUrl);
             await client.connect(transport);
 
-            // Try to get non-existent task
-            const task = await taskStore.getTask('non-existent');
-            expect(task).toBeNull();
+            // Try to get non-existent task via tasks/get request
+            await expect(client.getTask({ taskId: 'non-existent-task-id' })).rejects.toSatisfy((error: McpError) => {
+                expect(error).toBeInstanceOf(McpError);
+                expect(error.code).toBe(ErrorCode.InvalidParams);
+                expect(error.message).toContain('Task not found');
+                return true;
+            });
 
             await transport.close();
         });
 
-        it('should return error for invalid task operation', async () => {
+        it('should return error code -32602 for non-existent task in tasks/cancel', async () => {
             const client = new Client({
                 name: 'test-client',
                 version: '1.0.0'
@@ -800,30 +818,41 @@ describe('Task Lifecycle Integration Tests', () => {
             const transport = new StreamableHTTPClientTransport(baseUrl);
             await client.connect(transport);
 
-            // Create and complete a task
-            const createResult = await client.request(
-                {
-                    method: 'tools/call',
-                    params: {
-                        name: 'long-task',
-                        arguments: {
-                            duration: 100
-                        },
-                        task: {
-                            ttl: 60000
-                        }
-                    }
-                },
-                CreateTaskResultSchema
-            );
+            // Try to cancel non-existent task via tasks/cancel request
+            await expect(client.cancelTask({ taskId: 'non-existent-task-id' })).rejects.toSatisfy((error: McpError) => {
+                expect(error).toBeInstanceOf(McpError);
+                expect(error.code).toBe(ErrorCode.InvalidParams);
+                expect(error.message).toContain('Task not found');
+                return true;
+            });
 
-            const taskId = createResult.task.taskId;
+            await transport.close();
+        });
 
-            // Wait for completion
-            await new Promise(resolve => setTimeout(resolve, 200));
+        it('should return error code -32602 for non-existent task in tasks/result', async () => {
+            const client = new Client({
+                name: 'test-client',
+                version: '1.0.0'
+            });
 
-            // Try to cancel completed task (should fail)
-            await expect(taskStore.updateTaskStatus(taskId, 'cancelled')).rejects.toThrow();
+            const transport = new StreamableHTTPClientTransport(baseUrl);
+            await client.connect(transport);
+
+            // Try to get result of non-existent task via tasks/result request
+            await expect(
+                client.request(
+                    {
+                        method: 'tasks/result',
+                        params: { taskId: 'non-existent-task-id' }
+                    },
+                    CallToolResultSchema
+                )
+            ).rejects.toSatisfy((error: McpError) => {
+                expect(error).toBeInstanceOf(McpError);
+                expect(error.code).toBe(ErrorCode.InvalidParams);
+                expect(error.message).toContain('Task not found');
+                return true;
+            });
 
             await transport.close();
         });

src/shared/protocol.test.ts

@@ -1715,13 +1715,18 @@ describe('Task-based execution', () => {
 
             const deleteTaskPromise = protocol.cancelTask({ taskId: 'task-to-delete' });
 
-            // Simulate server response
+            // Simulate server response - per MCP spec, CancelTaskResult is Result & Task
             setTimeout(() => {
                 transport.onmessage?.({
                     jsonrpc: '2.0',
                     id: sendSpy.mock.calls[0][0].id,
                     result: {
-                        _meta: {}
+                        _meta: {},
+                        taskId: 'task-to-delete',
+                        status: 'cancelled',
+                        ttl: 60000,
+                        createdAt: new Date().toISOString(),
+                        lastUpdatedAt: new Date().toISOString()
                     }
                 });
             }, 0);
@@ -1738,6 +1743,8 @@ describe('Task-based execution', () => {
                 expect.any(Object)
             );
             expect(result._meta).toBeDefined();
+            expect(result.taskId).toBe('task-to-delete');
+            expect(result.status).toBe('cancelled');
         });
     });
 

src/shared/protocol.ts

@@ -507,9 +507,16 @@ export abstract class Protocol<SendRequestT extends Request, SendNotificationT e
 
                     this._clearTaskQueue(request.params.taskId);
 
+                    const cancelledTask = await this._taskStore!.getTask(request.params.taskId, extra.sessionId);
+                    if (!cancelledTask) {
+                        // Task was deleted during cancellation (e.g., cleanup happened)
+                        throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+                    }
+
                     return {
-                        _meta: {}
-                    } as SendResultT;
+                        _meta: {},
+                        ...cancelledTask
+                    } as unknown as SendResultT;
                 } catch (error) {
                     // Re-throw McpError as-is
                     if (error instanceof McpError) {

src/shared/task-listing.test.ts

@@ -3,6 +3,7 @@ import { InMemoryTransport } from '../inMemory.js';
 import { Client } from '../client/index.js';
 import { Server } from '../server/index.js';
 import { InMemoryTaskStore, InMemoryTaskMessageQueue } from '../examples/shared/inMemoryTaskStore.js';
+import { ErrorCode, McpError } from '../types.js';
 
 describe('Task Listing with Pagination', () => {
     let client: Client;
@@ -125,14 +126,19 @@ describe('Task Listing with Pagination', () => {
         expect(result.tasks).toHaveLength(2);
     });
 
-    it('should return error for invalid cursor', async () => {
+    it('should return error code -32602 for invalid cursor', async () => {
         await taskStore.createTask({}, 1, {
             method: 'tools/call',
             params: { name: 'test-tool' }
         });
 
-        // Try to use an invalid cursor
-        await expect(client.listTasks({ cursor: 'invalid-cursor' })).rejects.toThrow();
+        // Try to use an invalid cursor - should return -32602 (Invalid params) per MCP spec
+        await expect(client.listTasks({ cursor: 'invalid-cursor' })).rejects.toSatisfy((error: McpError) => {
+            expect(error).toBeInstanceOf(McpError);
+            expect(error.code).toBe(ErrorCode.InvalidParams);
+            expect(error.message).toContain('Invalid cursor');
+            return true;
+        });
     });
 
     it('should ensure tasks accessible via tasks/get are also accessible via tasks/list', async () => {

src/types.ts

@@ -735,7 +735,7 @@ export const CancelTaskRequestSchema = RequestSchema.extend({
 /**
  * The response to a tasks/cancel request.
  */
-export const CancelTaskResultSchema = ResultSchema;
+export const CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
 
 /* Resources */
 /**