[v2] Minor task-related refactors

packages/core/src/experimental/tasks/interfaces.ts

@@ -25,15 +25,15 @@ import type {
  * @experimental
  */
 export type CreateTaskServerContext = ServerContext & {
-    task: { store: RequestTaskStore; requestedTtl?: number | null };
+    task: { store: RequestTaskStore; requestedTtl?: number };
 };
 
 /**
  * Server context with guaranteed task ID and store for task operations.
  * @experimental
  */
 export type TaskServerContext = ServerContext & {
-    task: { id: string; store: RequestTaskStore; requestedTtl?: number | null };
+    task: { id: string; store: RequestTaskStore; requestedTtl?: number };
 };
 
 /**

packages/core/src/shared/protocol.ts

@@ -258,7 +258,7 @@ export interface RequestTaskStore {
 export type TaskContext = {
     id?: string;
     store: RequestTaskStore;
-    requestedTtl?: number | null;
+    requestedTtl?: number;
 };
 
 /**

packages/core/src/types/types.ts

@@ -76,10 +76,9 @@ export const CursorSchema = z.string();
  */
 export const TaskCreationParamsSchema = z.looseObject({
     /**
-     * Time in milliseconds to keep task results available after completion.
-     * If `null`, the task has unlimited lifetime until manually cleaned up.
+     * Requested duration in milliseconds to retain task from creation.
      */
-    ttl: z.union([z.number(), z.null()]).optional(),
+    ttl: z.number().optional(),
 
     /**
      * Time in milliseconds to wait between task status requests.

packages/core/test/experimental/inMemory.test.ts

@@ -488,17 +488,16 @@ describe('InMemoryTaskStore', () => {
             expect(task).toBeNull();
         });
 
-        it('should support null TTL for unlimited lifetime', async () => {
-            // Test that null TTL means unlimited lifetime
-            const taskParams: TaskCreationParams = {
-                ttl: null
-            };
+        it('should support omitted TTL for unlimited lifetime', async () => {
+            // Test that omitting TTL means unlimited lifetime (server returns null)
+            // Per spec: clients omit ttl to let server decide, server returns null for unlimited
+            const taskParams: TaskCreationParams = {};
             const createdTask = await store.createTask(taskParams, 2222, {
                 method: 'tools/call',
                 params: {}
             });
 
-            // The returned task should have null TTL
+            // The returned task should have null TTL (unlimited)
             expect(createdTask.ttl).toBeNull();
 
             // Task should not be cleaned up even after a long time

test/integration/test/experimental/tasks/task.test.ts

@@ -1,5 +1,5 @@
-import { isTerminal } from '@modelcontextprotocol/core';
-import type { Task } from '@modelcontextprotocol/server';
+import type { Task } from '@modelcontextprotocol/core';
+import { isTerminal, TaskCreationParamsSchema } from '@modelcontextprotocol/core';
 import { describe, expect, it } from 'vitest';
 
 describe('Task utility functions', () => {
@@ -115,3 +115,30 @@ describe('Task Schema Validation', () => {
         }
     });
 });
+
+describe('TaskCreationParams Schema Validation', () => {
+    it('should accept ttl as a number', () => {
+        const result = TaskCreationParamsSchema.safeParse({ ttl: 60_000 });
+        expect(result.success).toBe(true);
+    });
+
+    it('should accept missing ttl (optional)', () => {
+        const result = TaskCreationParamsSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+
+    it('should reject null ttl (not allowed in request, only response)', () => {
+        const result = TaskCreationParamsSchema.safeParse({ ttl: null });
+        expect(result.success).toBe(false);
+    });
+
+    it('should accept pollInterval as a number', () => {
+        const result = TaskCreationParamsSchema.safeParse({ pollInterval: 1000 });
+        expect(result.success).toBe(true);
+    });
+
+    it('should accept both ttl and pollInterval', () => {
+        const result = TaskCreationParamsSchema.safeParse({ ttl: 60_000, pollInterval: 1000 });
+        expect(result.success).toBe(true);
+    });
+});