Migrate Tasks tests and sample to extension package

- Add ProjectReference from tests and sample to ModelContextProtocol.Extensions.Tasks
- Migrate task tests to public extension API (WithTasks, CallToolAsTaskAsync, GetTaskAsync, UpdateTaskAsync, CancelTaskAsync, CallToolRawAsync)
- Rename const references to TaskMethods.Get/Update/Cancel/StatusNotification
- Rewrite McpServerTaskTests and TaskPollStuckDetectorTests to use the store-based public API with custom IMcpTaskStore doubles
- Drop manual CallToolWithTaskHandler tests (TaskStoreOrphanedTaskTests, TaskHandlerConfigurationValidationTests) that exercised configuration paths removed from Core
- Add public McpTasksJsonUtilities.DefaultOptions so the public task DTOs can be serialized under source generation when reflection is disabled
- Point task DTO serialization in tests at McpTasksJsonUtilities.DefaultOptions instead of the Core McpJsonUtilities.DefaultOptions
- Send and read tasks/update inputResponses explicitly in the extension because RequestParams serializes them through an internal backing property the extension context cannot access
- Update samples/TasksExtension to the WithTasks plus CallToolAsTaskAsync API

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

Author: jeffhandley

samples/TasksExtension/Program.cs

@@ -13,6 +13,7 @@
 // is self-contained — no separate server process or HTTP transport required.
 
 using ModelContextProtocol.Client;
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using System.ComponentModel;
@@ -21,22 +22,25 @@
 
 Pipe clientToServerPipe = new(), serverToClientPipe = new();
 
+McpServerOptions serverOptions = new()
+{
+    ToolCollection = [McpServerTool.Create(SlowTools.RunReport, new() { Name = "run-report" })],
+};
+
+// Calling WithTasks is all that's needed for [McpServerTool]-attributed tools to be
+// automatically wrapped as background tasks when the client opts in.
+serverOptions.WithTasks(new InMemoryMcpTaskStore { DefaultPollIntervalMs = 250 });
+
 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" })],
-    });
+    serverOptions);
 _ = 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(
+Console.WriteLine("=== CallToolAsTaskAsync (auto-poll) ===");
+var auto = await client.CallToolAsTaskAsync(
     new CallToolRequestParams { Name = "run-report" });
 Console.WriteLine($"  result: {((TextContentBlock)auto.Content[0]).Text}");
 Console.WriteLine();

samples/TasksExtension/TasksExtension.csproj

@@ -5,11 +5,12 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <NoWarn>$(NoWarn);MCPEXP001</NoWarn>
+    <NoWarn>$(NoWarn);MCPEXP001;MCPEXP002;MCPEXP004</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\ModelContextProtocol\ModelContextProtocol.csproj" />
+    <ProjectReference Include="..\..\src\ModelContextProtocol.Extensions.Tasks\ModelContextProtocol.Extensions.Tasks.csproj" />
   </ItemGroup>
 
 </Project>

src/ModelContextProtocol.Extensions.Tasks/Client/McpClientTasksExtensions.cs

@@ -1,6 +1,5 @@
 using ModelContextProtocol.Client;
 using ModelContextProtocol.Protocol;
-using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 
@@ -11,9 +10,9 @@ namespace ModelContextProtocol.Extensions.Tasks;
 /// </summary>
 /// <remarks>
 /// These methods let a client request task-augmented tool execution and drive the task lifecycle
-/// (<c>tasks/get</c>, <c>tasks/update</c>, <c>tasks/cancel</c>). The Tasks extension is draft-only.
+/// (<c>tasks/get</c>, <c>tasks/update</c>, <c>tasks/cancel</c>). The Tasks extension requires the
+/// <c>2026-07-28</c> or later protocol revision.
 /// </remarks>
-[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)]
 public static class McpClientTasksExtensions
 {
     /// <summary>The default number of consecutive stuck polls tolerated before a task is abandoned.</summary>
@@ -309,11 +308,19 @@ public static async ValueTask<UpdateTaskResult> UpdateTaskAsync(
         if (requestParams is null) throw new ArgumentNullException(nameof(requestParams));
         ThrowIfTasksNotSupported(client, nameof(UpdateTaskAsync));
 
+        // RequestParams serializes inputResponses via an internal backing property that this assembly's
+        // source-generated context cannot access, so attach the inputResponses node explicitly.
+        var paramsNode = JsonSerializer.SerializeToNode(requestParams, TasksJsonContext.Default.UpdateTaskRequestParams);
+        if (requestParams.InputResponses is { Count: > 0 } responses && paramsNode is JsonObject paramsObject)
+        {
+            paramsObject["inputResponses"] = JsonSerializer.SerializeToNode(responses, TasksJsonContext.Default.IDictionaryStringInputResponse);
+        }
+
         var response = await client.SendRequestAsync(
             new JsonRpcRequest
             {
                 Method = TaskMethods.Update,
-                Params = JsonSerializer.SerializeToNode(requestParams, TasksJsonContext.Default.UpdateTaskRequestParams),
+                Params = paramsNode,
             },
             cancellationToken).ConfigureAwait(false);
 
@@ -396,9 +403,8 @@ private static void ThrowIfTasksNotSupported(McpClient client, string operationN
         if (!client.IsDraftProtocol())
         {
             throw new InvalidOperationException(
-                $"'{operationName}' requires the draft protocol revision. " +
-                $"The negotiated protocol version is '{client.NegotiatedProtocolVersion ?? "(none)"}'. " +
-                "The Tasks extension is only available under the draft revision.");
+                $"'{operationName}' requires a newer protocol revision that supports tasks. " +
+                $"The negotiated protocol version is '{client.NegotiatedProtocolVersion ?? "(none)"}'.");
         }
     }
 }

src/ModelContextProtocol.Extensions.Tasks/McpTasksJsonUtilities.cs

@@ -0,0 +1,20 @@
+using System.Text.Json;
+
+namespace ModelContextProtocol.Extensions.Tasks;
+
+/// <summary>
+/// Provides serialization helpers for the SEP-2663 Tasks extension protocol types.
+/// </summary>
+public static class McpTasksJsonUtilities
+{
+    /// <summary>
+    /// Gets the <see cref="JsonSerializerOptions"/> used to serialize and deserialize the
+    /// Tasks extension protocol types (for example <see cref="ModelContextProtocol.Protocol.CreateTaskResult"/>
+    /// and <see cref="ModelContextProtocol.Protocol.GetTaskResult"/>).
+    /// </summary>
+    /// <remarks>
+    /// These options are backed by a source-generated <see cref="System.Text.Json.Serialization.JsonSerializerContext"/>,
+    /// so they are safe to use when reflection-based serialization is disabled (for example under Native AOT).
+    /// </remarks>
+    public static JsonSerializerOptions DefaultOptions { get; } = TasksJsonContext.Default.Options;
+}

src/ModelContextProtocol.Extensions.Tasks/Server/McpServerTasksExtensions.cs

@@ -3,7 +3,6 @@
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using System.Collections.Concurrent;
-using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 
@@ -17,7 +16,6 @@ namespace ModelContextProtocol.Extensions.Tasks;
 /// client poll for completion via <c>tasks/get</c>, supply input via <c>tasks/update</c>, and cancel via
 /// <c>tasks/cancel</c>. State is held in an <see cref="IMcpTaskStore"/>.
 /// </remarks>
-[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)]
 public static class McpServerTasksExtensions
 {
     /// <summary>
@@ -113,7 +111,18 @@ private static void ConfigureTaskHandlers(IMcpServerRawHandlerRegistry registry,
             EnsureDraft(registry, request, TaskMethods.Update);
 
             var requestParams = Deserialize(request.Params, TasksJsonContext.Default.UpdateTaskRequestParams);
-            var inputResponses = requestParams.InputResponses ?? new Dictionary<string, InputResponse>();
+
+            // RequestParams deserializes inputResponses via an internal backing property that this assembly's
+            // source-generated context cannot access, so read the inputResponses node explicitly.
+            IDictionary<string, InputResponse> inputResponses = new Dictionary<string, InputResponse>();
+            if (request.Params is JsonObject paramsObject &&
+                paramsObject.TryGetPropertyValue("inputResponses", out var inputResponsesNode) &&
+                inputResponsesNode is not null)
+            {
+                inputResponses = JsonSerializer.Deserialize(inputResponsesNode, TasksJsonContext.Default.IDictionaryStringInputResponse)
+                    ?? inputResponses;
+            }
+
             await store.ResolveInputRequestsAsync(requestParams.TaskId, inputResponses, cancellationToken).ConfigureAwait(false);
 
             return JsonSerializer.SerializeToNode(new UpdateTaskResult(), TasksJsonContext.Default.UpdateTaskResult);

tests/Directory.Build.props

@@ -5,6 +5,11 @@
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
     <!-- Suppress the experimental extensions warning in test projects -->
     <NoWarn>$(NoWarn);MCPEXP001</NoWarn>
+    <!-- Suppress the experimental SDK extensibility seam warning (raw handler registry, outgoing-request
+         interceptor, draft/input-resolution primitives) in test projects. -->
+    <NoWarn>$(NoWarn);MCPEXP002</NoWarn>
+    <!-- Suppress the experimental Tasks extension warning in test projects. -->
+    <NoWarn>$(NoWarn);MCPEXP004</NoWarn>
     <!-- Suppress the obsolete SSE warning in test projects that need to test legacy SSE -->
     <NoWarn>$(NoWarn);MCP9004</NoWarn>
     <!-- Suppress the Roots, Sampling, and Logging obsoletion warning (SEP-2577) in test projects

tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs

@@ -1,5 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol.Client;
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using System.Runtime.InteropServices;
@@ -27,10 +28,10 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer
     {
         mcpServerBuilder.Services.Configure<McpServerOptions>(options =>
         {
-            options.TaskStore = new InMemoryMcpTaskStore
+            options.WithTasks(new InMemoryMcpTaskStore
             {
                 DefaultPollIntervalMs = 50,
-            };
+            });
         });
 
         mcpServerBuilder.WithTools([McpServerTool.Create(

tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj

@@ -83,6 +83,7 @@
     <ProjectReference Include="..\..\src\ModelContextProtocol\ModelContextProtocol.csproj" />
     <ProjectReference Include="..\..\src\ModelContextProtocol.Core\ModelContextProtocol.Core.csproj" />
     <ProjectReference Include="..\..\src\ModelContextProtocol.Extensions.Apps\ModelContextProtocol.Extensions.Apps.csproj" />
+    <ProjectReference Include="..\..\src\ModelContextProtocol.Extensions.Tasks\ModelContextProtocol.Extensions.Tasks.csproj" />
     <ProjectReference Include="..\ModelContextProtocol.TestServer\ModelContextProtocol.TestServer.csproj" />
     <ProjectReference Include="..\..\samples\TestServerWithHosting\TestServerWithHosting.csproj" />
   </ItemGroup>