refactor(core)!: remove experimental tasks interception from Protocol

Removes the 2025-11 task side-channel from Protocol (no compatibility owed; surface was experimental). SEP-2663's server-directed model has no equivalent to processInbound*/processOutbound* interception: a handler returns a CreateTaskResult and the client polls tasks/* methods.

Test handling:
- DELETED (~121, protocol.test.ts): mechanism tests for processInbound*/processOutbound*/relatedTask/NullTaskManager. Mechanism removed; no SEP-2663 equivalent. Per-suite reasons in the comment block at the deletion site.
- SKIPPED (~85, integration): behavior tests (create/poll/result). TODO(F3) markers; rewritten via tasksPlugin in F3.
- KEPT: storage-layer tests (InMemoryTaskStore etc.). Interfaces unchanged.

Tasks comes back as tasksPlugin() in F3.

Author: felixweinberger

docs/migration-SKILL.md

@@ -420,9 +420,7 @@ Request/notification params remain fully typed. Remove unused schema imports aft
 | `extra.requestInfo`              | `ctx.http?.req` (standard Web `Request`, only `ServerContext`)             |
 | `extra.closeSSEStream`           | `ctx.http?.closeSSE` (only `ServerContext`)                                |
 | `extra.closeStandaloneSSEStream` | `ctx.http?.closeStandaloneSSE` (only `ServerContext`)                      |
-| `extra.taskStore`                | `ctx.task?.store`                                                          |
-| `extra.taskId`                   | `ctx.task?.id`                                                             |
-| `extra.taskRequestedTtl`         | `ctx.task?.requestedTtl`                                                   |
+| `extra.taskStore` / `taskId` / `taskRequestedTtl` | _removed; see §12_                                        |
 
 `ServerContext` convenience methods (new in v2, no v1 equivalent):
 
@@ -473,24 +471,22 @@ If a `*Schema` constant was used for **runtime validation** (not just as a `requ
 
 `isCallToolResult(value)` still works, but `isSpecType` covers every spec type by name.
 
-## 12. Experimental: `TaskCreationParams.ttl` no longer accepts `null`
+## 12. Experimental tasks interception removed
 
-`TaskCreationParams.ttl` changed from `z.union([z.number(), z.null()]).optional()` to `z.number().optional()`. Per the MCP spec, `null` TTL (unlimited lifetime) is only valid in server responses (`Task.ttl`), not in client requests. Omit `ttl` to let the server decide.
+The 2025-11 task side-channel through `Protocol` is removed (was always `@experimental`; SEP-2663 reattaches via `tasksPlugin()` in a follow-up). No mechanical migration; remove usages.
 
-| v1                     | v2                                 |
-| ---------------------- | ---------------------------------- |
-| `task: { ttl: null }`  | `task: {}` (omit ttl)              |
-| `task: { ttl: 60000 }` | `task: { ttl: 60000 }` (unchanged) |
+| Removed | Notes |
+| --- | --- |
+| `ProtocolOptions.tasks` | drop the option |
+| `protocol.taskManager` | gone |
+| `RequestOptions.task` / `.relatedTask`, `NotificationOptions.relatedTask` | drop the option |
+| `BaseContext.task` (`ctx.task?.*`) | gone; future: `ctx.ext.task` via `tasksPlugin()` |
+| `assertTaskCapability` / `assertTaskHandlerCapability` overrides | delete the override |
+| `*.experimental.tasks.{requestStream,callToolStream,createMessageStream,elicitInputStream}` | still defined; throw `CapabilityNotSupported` until `tasksPlugin()` |
 
-Type changes in handler context:
+`TaskStore` / `InMemoryTaskStore` / `TaskMetadata` / `TaskMessageQueue` (storage interfaces) are unchanged.
 
-| Type                                        | v1                            | v2                    |
-| ------------------------------------------- | ----------------------------- | --------------------- |
-| `TaskContext.requestedTtl`                  | `number \| null \| undefined` | `number \| undefined` |
-| `CreateTaskServerContext.task.requestedTtl` | `number \| null \| undefined` | `number \| undefined` |
-| `TaskServerContext.task.requestedTtl`       | `number \| null \| undefined` | `number \| undefined` |
-
-> These task APIs are `@experimental` and may change without notice.
+`TaskCreationParams.ttl` also no longer accepts `null` (`number | undefined` only); omit `ttl` to let the server decide.
 
 ## 13. Client Behavioral Changes
 

docs/migration.md

@@ -591,9 +591,7 @@ The `RequestHandlerExtra` type has been replaced with a structured context type
 | `extra.closeSSEStream`                   | `ctx.http?.closeSSE` (only on `ServerContext`)                         |
 | `extra.closeStandaloneSSEStream`         | `ctx.http?.closeStandaloneSSE` (only on `ServerContext`)               |
 | `extra.sessionId`                        | `ctx.sessionId`                                                        |
-| `extra.taskStore`                        | `ctx.task?.store`                                                      |
-| `extra.taskId`                           | `ctx.task?.id`                                                         |
-| `extra.taskRequestedTtl`                 | `ctx.task?.requestedTtl`                                               |
+| `extra.taskStore` / `taskId` / `taskRequestedTtl` | _removed — see "Experimental tasks interception removed" below_ |
 
 **Before (v1):**
 
@@ -853,7 +851,23 @@ try {
 }
 ```
 
-### Experimental: `TaskCreationParams.ttl` no longer accepts `null`
+### Experimental tasks interception removed
+
+The 2025-11 experimental tasks side-channel woven through `Protocol` has been removed in preparation for the SEP-2663 Tasks Extension. The following are gone with no in-place replacement:
+
+- `ProtocolOptions.tasks` (the `{ taskStore, taskMessageQueue }` constructor option)
+- `protocol.taskManager` getter, `Protocol#_bindTaskManager`
+- `RequestOptions.task` / `RequestOptions.relatedTask`, `NotificationOptions.relatedTask`
+- `BaseContext.task` (`ctx.task?.store` / `ctx.task?.id` / `ctx.task?.requestedTtl`)
+- abstract `assertTaskCapability` / `assertTaskHandlerCapability`
+
+The `*.experimental.tasks.*` accessor methods (`requestStream`, `callToolStream`, `createMessageStream`, `elicitInputStream`) are still defined but now throw `SdkError(CapabilityNotSupported)` until `tasksPlugin()` lands.
+
+**Unchanged:** the storage interfaces in `experimental/tasks/` (`TaskStore`, `InMemoryTaskStore`, `TaskMetadata`, `TaskMessageQueue`). These will be consumed by `tasksPlugin()` in a follow-up.
+
+There is no migration path for the removed surface; it was always `@experimental`. Under SEP-2663, tasks reattach via a `DispatchMiddleware` (`mcp.use(tasksPlugin({ store }))`) and handlers read task context from `ctx.ext.task` instead of `ctx.task`.
+
+#### `TaskCreationParams.ttl` no longer accepts `null`
 
 The `ttl` field in `TaskCreationParams` (used when requesting the server to create a task) no longer accepts `null`. Per the MCP spec, `null` TTL (meaning unlimited lifetime) is only valid in server responses (`Task.ttl`), not in client requests. Clients should omit `ttl` to let
 the server decide the lifetime.

examples/client/src/simpleOAuthClient.ts

@@ -362,18 +362,10 @@ class InteractiveOAuthClient {
             // Using the experimental tasks API - WARNING: may change without notice
             console.log(`\n🔧 Streaming tool '${toolName}'...`);
 
-            const stream = this.client.experimental.tasks.callToolStream(
-                {
-                    name: toolName,
-                    arguments: toolArgs
-                },
-                {
-                    task: {
-                        taskId: `task-${Date.now()}`,
-                        ttl: 60_000
-                    }
-                }
-            );
+            const stream = this.client.experimental.tasks.callToolStream({
+                name: toolName,
+                arguments: toolArgs
+            });
 
             // Iterate through all messages yielded by the generator
             for await (const message of stream) {

examples/client/src/simpleStreamableHttp.ts

@@ -296,13 +296,8 @@ async function connect(url?: string): Promise<void> {
                 action: 'accept' | 'decline' | 'cancel';
                 content?: Record<string, string | number | boolean | string[]>;
             }) => {
-                if (request.params.task && extra.task?.store) {
-                    // Create a task and store the result
-                    const task = await extra.task.store.createTask({ ttl: extra.task.requestedTtl });
-                    await extra.task.store.storeTaskResult(task.taskId, 'completed', result);
-                    console.log(`📋 Created client-side task: ${task.taskId}`);
-                    return { task };
-                }
+                void request;
+                void extra;
                 return result;
             };
 
@@ -895,17 +890,10 @@ async function callToolTask(name: string, args: Record<string, unknown>): Promis
 
     try {
         // Call the tool with task metadata using streaming API
-        const stream = client.experimental.tasks.callToolStream(
-            {
-                name,
-                arguments: args
-            },
-            {
-                task: {
-                    ttl: 60_000 // Keep results for 60 seconds
-                }
-            }
-        );
+        const stream = client.experimental.tasks.callToolStream({
+            name,
+            arguments: args
+        });
 
         console.log('Waiting for task completion...');
 

examples/client/src/simpleTaskInteractiveClient.ts

@@ -121,7 +121,7 @@ async function run(url: string): Promise<void> {
 
     const confirmStream = client.experimental.tasks.callToolStream(
         { name: 'confirm_delete', arguments: { filename: 'important.txt' } },
-        { task: { ttl: 60_000 } }
+        {}
     );
 
     for await (const message of confirmStream) {
@@ -150,10 +150,7 @@ async function run(url: string): Promise<void> {
     console.log('\n--- Demo 2: Sampling ---');
     console.log('Calling write_haiku tool...');
 
-    const haikuStream = client.experimental.tasks.callToolStream(
-        { name: 'write_haiku', arguments: { topic: 'autumn leaves' } },
-        { task: { ttl: 60_000 } }
-    );
+    const haikuStream = client.experimental.tasks.callToolStream({ name: 'write_haiku', arguments: { topic: 'autumn leaves' } }, {});
 
     for await (const message of haikuStream) {
         switch (message.type) {

examples/server/src/simpleStreamableHttp.ts

@@ -5,7 +5,6 @@ import { createMcpExpressApp, getOAuthProtectedResourceMetadataUrl, requireBeare
 import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
 import type {
     CallToolResult,
-    ElicitResult,
     GetPromptResult,
     PrimitiveSchemaDefinition,
     ReadResourceResult,
@@ -439,159 +438,8 @@ const getServer = () => {
         }
     );
 
-    // Register a long-running tool that demonstrates task execution
-    // Using the experimental tasks API - WARNING: may change without notice
-    server.experimental.tasks.registerToolTask(
-        'delay',
-        {
-            title: 'Delay',
-            description: 'A simple tool that delays for a specified duration, useful for testing task execution',
-            inputSchema: z.object({
-                duration: z.number().describe('Duration in milliseconds').default(5000)
-            })
-        },
-        {
-            async createTask({ duration }, ctx) {
-                // Create the task
-                const task = await ctx.task.store.createTask({
-                    ttl: ctx.task.requestedTtl
-                });
-
-                // Simulate out-of-band work
-                (async () => {
-                    await new Promise(resolve => setTimeout(resolve, duration));
-                    await ctx.task.store.storeTaskResult(task.taskId, 'completed', {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Completed ${duration}ms delay`
-                            }
-                        ]
-                    });
-                })();
-
-                // Return CreateTaskResult with the created task
-                return {
-                    task
-                };
-            },
-            async getTask(_args, ctx) {
-                return await ctx.task.store.getTask(ctx.task.id);
-            },
-            async getTaskResult(_args, ctx) {
-                const result = await ctx.task.store.getTaskResult(ctx.task.id);
-                return result as CallToolResult;
-            }
-        }
-    );
-
-    // Register a tool that demonstrates bidirectional task support:
-    // Server creates a task, then elicits input from client using elicitInputStream
-    // Using the experimental tasks API - WARNING: may change without notice
-    server.experimental.tasks.registerToolTask(
-        'collect-user-info-task',
-        {
-            title: 'Collect Info with Task',
-            description: 'Collects user info via elicitation with task support using elicitInputStream',
-            inputSchema: z.object({
-                infoType: z.enum(['contact', 'preferences']).describe('Type of information to collect').default('contact')
-            })
-        },
-        {
-            async createTask({ infoType }, ctx) {
-                // Create the server-side task
-                const task = await ctx.task.store.createTask({
-                    ttl: ctx.task.requestedTtl
-                });
-
-                // Perform async work that makes a nested elicitation request using elicitInputStream
-                (async () => {
-                    try {
-                        const message = infoType === 'contact' ? 'Please provide your contact information' : 'Please set your preferences';
-
-                        // Define schemas with proper typing for PrimitiveSchemaDefinition
-                        const contactSchema: {
-                            type: 'object';
-                            properties: Record<string, PrimitiveSchemaDefinition>;
-                            required: string[];
-                        } = {
-                            type: 'object',
-                            properties: {
-                                name: { type: 'string', title: 'Full Name', description: 'Your full name' },
-                                email: { type: 'string', title: 'Email', description: 'Your email address' }
-                            },
-                            required: ['name', 'email']
-                        };
-
-                        const preferencesSchema: {
-                            type: 'object';
-                            properties: Record<string, PrimitiveSchemaDefinition>;
-                            required: string[];
-                        } = {
-                            type: 'object',
-                            properties: {
-                                theme: { type: 'string', title: 'Theme', enum: ['light', 'dark', 'auto'] },
-                                notifications: { type: 'boolean', title: 'Enable Notifications', default: true }
-                            },
-                            required: ['theme']
-                        };
-
-                        const requestedSchema = infoType === 'contact' ? contactSchema : preferencesSchema;
-
-                        // Use elicitInputStream to elicit input from client
-                        // This demonstrates the streaming elicitation API
-                        // Access via server.server to get the underlying Server instance
-                        const stream = server.server.experimental.tasks.elicitInputStream({
-                            mode: 'form',
-                            message,
-                            requestedSchema
-                        });
-
-                        let elicitResult: ElicitResult | undefined;
-                        for await (const msg of stream) {
-                            if (msg.type === 'result') {
-                                elicitResult = msg.result as ElicitResult;
-                            } else if (msg.type === 'error') {
-                                throw msg.error;
-                            }
-                        }
-
-                        if (!elicitResult) {
-                            throw new Error('No result received from elicitation');
-                        }
-
-                        let resultText: string;
-                        if (elicitResult.action === 'accept') {
-                            resultText = `Collected ${infoType} info: ${JSON.stringify(elicitResult.content, null, 2)}`;
-                        } else if (elicitResult.action === 'decline') {
-                            resultText = `User declined to provide ${infoType} information`;
-                        } else {
-                            resultText = 'User cancelled the request';
-                        }
-
-                        await taskStore.storeTaskResult(task.taskId, 'completed', {
-                            content: [{ type: 'text', text: resultText }]
-                        });
-                    } catch (error) {
-                        console.error('Error in collect-user-info-task:', error);
-                        await taskStore.storeTaskResult(task.taskId, 'failed', {
-                            content: [{ type: 'text', text: `Error: ${error}` }],
-                            isError: true
-                        });
-                    }
-                })();
-
-                return { task };
-            },
-            async getTask(_args, ctx) {
-                return await ctx.task.store.getTask(ctx.task.id);
-            },
-            async getTaskResult(_args, ctx) {
-                const result = await ctx.task.store.getTaskResult(ctx.task.id);
-                return result as CallToolResult;
-            }
-        }
-    );
+    // TODO(F3): re-add task tool examples (delay, collect-user-info-task) via tasksPlugin (SEP-2663).
+    // The experimental tasks interception was removed in R0; see docs/migration.md.
 
     return server;
 };