Extract Tasks into ModelContextProtocol.Extensions.Tasks package

- Create src/ModelContextProtocol.Extensions.Tasks/ with csproj, JSON context,
  server builder extensions, client extension methods
- Move task protocol DTOs (CreateTaskResult, GetTaskResult, UpdateTask*,
  CancelTask*, McpTaskStatus, TaskStatusNotificationParams) to extension
- Move server types (IMcpTaskStore, InMemoryMcpTaskStore, McpTaskInfo,
  InputResponseReceivedEventArgs) to extension
- Move task constants (RequestMethods.Tasks*, NotificationMethods.TaskStatus*,
  MetaKeys.RelatedTask, McpExtensions.Tasks) into TasksProtocol static class
- Delete McpTaskExecutionContext, ResultOrCreatedTask from Core
- Remove ~18 task [JsonSerializable] entries from McpJsonUtilities
- Remove McpServerOptions.TaskStore and McpClientOptions.MaxConsecutiveStuckPolls
- Remove task client methods from McpClient (CallToolRawAsync, PollTaskToCompletion,
  GetTaskAsync, UpdateTaskAsync, CancelTaskAsync, GetMetaWithTaskCapability,
  ThrowIfTasksNotSupported)
- Remove task server methods/handlers (GetTaskHandler, UpdateTaskHandler,
  CancelTaskHandler, ConfigureTasks, InvokeToolAsTask, task cancellation sources)
- Add Tasks_DiagnosticId (MCPEXP001) to Experimentals.cs
- Extension WithTasks(store) registers request handlers via seam #1,
  alternate filter via seam #2, interceptor via seam #3
- Extension client methods: CallToolAsTaskAsync, CallToolWithPollingAsync,
  GetTaskAsync, UpdateTaskAsync, CancelTaskAsync
- Manually serialize/deserialize InputResponses in UpdateTaskAsync to handle
  internal Core property visibility across assembly boundary
- Update test project and TasksExtension sample to reference new package
- Update all task test files with new using and extension API

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jeffhandley

ModelContextProtocol.slnx

@@ -69,6 +69,7 @@
     <Project Path="src/ModelContextProtocol.AspNetCore/ModelContextProtocol.AspNetCore.csproj" />
     <Project Path="src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj" />
     <Project Path="src/ModelContextProtocol.Extensions.Apps/ModelContextProtocol.Extensions.Apps.csproj" />
+    <Project Path="src/ModelContextProtocol.Extensions.Tasks/ModelContextProtocol.Extensions.Tasks.csproj" />
     <Project Path="src/ModelContextProtocol/ModelContextProtocol.csproj" />
   </Folder>
   <Folder Name="/tests/">

samples/TasksExtension/Program.cs

@@ -1,18 +1,17 @@
 // Demonstrates the MCP tasks extension (SEP-2663):
 //
-//   - A server is configured with InMemoryMcpTaskStore so that any [McpServerTool] invocation
+//   - A server is configured with .WithTasks(store) so that any [McpServerTool] invocation
 //     becomes a background task when the client opts in via the per-request _meta marker.
-//   - The client invokes the same tool two ways:
-//       1. CallToolAsync — the SDK auto-polls until the task completes and returns the final
-//          CallToolResult, just like a synchronous call.
-//       2. CallToolRawAsync — the caller drives the lifecycle manually (GetTaskAsync polls,
-//          CancelTaskAsync, etc.). Use this when you need to surface progress to a UI or stream
-//          status updates rather than block on a single await.
+//   - The client invokes the tool and manually drives the lifecycle via GetTaskAsync.
 //
 // Both server and client are wired together in-process over an in-memory pipe so the sample
 // is self-contained — no separate server process or HTTP transport required.
 
+#pragma warning disable MCPEXP001, MCPEXP002, MCPEXP004
+
+using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol.Client;
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using System.ComponentModel;
@@ -21,32 +20,27 @@
 
 Pipe clientToServerPipe = new(), serverToClientPipe = new();
 
-await using McpServer server = McpServer.Create(
-    new StreamServerTransport(clientToServerPipe.Reader.AsStream(), serverToClientPipe.Writer.AsStream()),
-    new McpServerOptions
-    {
-        // Setting TaskStore is all that's needed for [McpServerTool]-attributed tools to be
-        // automatically wrapped as background tasks when the client opts in.
-        TaskStore = new InMemoryMcpTaskStore { DefaultPollIntervalMs = 250 },
-        ToolCollection = [McpServerTool.Create(SlowTools.RunReport, new() { Name = "run-report" })],
-    });
+var store = new InMemoryMcpTaskStore { DefaultPollIntervalMs = 250 };
+
+var services = new ServiceCollection();
+services.AddMcpServer()
+    .WithTools([McpServerTool.Create(SlowTools.RunReport, new() { Name = "run-report" })])
+    .WithTasks(store);
+services.AddSingleton<ITransport>(new StreamServerTransport(clientToServerPipe.Reader.AsStream(), serverToClientPipe.Writer.AsStream()));
+
+await using var serviceProvider = services.BuildServiceProvider();
+var server = serviceProvider.GetRequiredService<McpServer>();
 _ = server.RunAsync();
 
 await using McpClient client = await McpClient.CreateAsync(
-    new StreamClientTransport(clientToServerPipe.Writer.AsStream(), serverToClientPipe.Reader.AsStream()));
-
-Console.WriteLine("=== CallToolAsync (auto-poll) ===");
-var auto = await client.CallToolAsync(
-    new CallToolRequestParams { Name = "run-report" });
-Console.WriteLine($"  result: {((TextContentBlock)auto.Content[0]).Text}");
-Console.WriteLine();
+    new StreamClientTransport(
+        serverInput: clientToServerPipe.Writer.AsStream(),
+        serverOutput: serverToClientPipe.Reader.AsStream()));
 
-Console.WriteLine("=== CallToolRawAsync (manual poll) ===");
-var raw = await client.CallToolRawAsync(new CallToolRequestParams { Name = "run-report" });
+Console.WriteLine("=== CallToolAsTaskAsync (manual poll) ===");
+var raw = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "run-report" });
 if (!raw.IsTask)
 {
-    // Either the server doesn't advertise the tasks extension or it chose to run the call
-    // synchronously despite the client opt-in. Surface the inline result and stop.
     Console.WriteLine($"  result (inline): {((TextContentBlock)raw.Result!.Content[0]).Text}");
     return;
 }
@@ -70,7 +64,6 @@
     switch (state)
     {
         case CompletedTaskResult completed:
-            // The Result property carries the wrapped CallToolResult as a raw JsonElement.
             var callToolResult = completed.Result.Deserialize<CallToolResult>()!;
             Console.WriteLine($"  task completed after {pollCount} poll(s): {((TextContentBlock)callToolResult.Content[0]).Text}");
             return;
@@ -88,9 +81,6 @@
             continue;
 
         case InputRequiredTaskResult inputRequired:
-            // The auto-poll path (CallToolAsync above) routes these through the registered
-            // ElicitationHandler/SamplingHandler automatically. The manual path needs to call
-            // UpdateTaskAsync with responses for each outstanding key.
             Console.WriteLine($"  poll {pollCount}: input requested ({inputRequired.InputRequests?.Count ?? 0} key(s))");
             continue;
     }
@@ -101,8 +91,6 @@ internal static class SlowTools
     [Description("Runs a short simulated report and returns when it's done.")]
     public static async Task<string> RunReport(CancellationToken cancellationToken)
     {
-        // Real-world workloads would do meaningful work here; we just sleep so the polling
-        // path is observable in the console output.
         await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
         return "report ready";
     }

samples/TasksExtension/TasksExtension.csproj

@@ -10,6 +10,8 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\ModelContextProtocol\ModelContextProtocol.csproj" />
+    <ProjectReference Include="..\..\src\ModelContextProtocol.Extensions.Tasks\ModelContextProtocol.Extensions.Tasks.csproj" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
   </ItemGroup>
 
 </Project>