diff --git a/ModelContextProtocol.slnx b/ModelContextProtocol.slnx
index abfb430cb..9020d2fbe 100644
--- a/ModelContextProtocol.slnx
+++ b/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/">
diff --git a/samples/TasksExtension/Program.cs b/samples/TasksExtension/Program.cs
index fff353307..b10d2fde4 100644
--- a/samples/TasksExtension/Program.cs
+++ b/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();
diff --git a/samples/TasksExtension/TasksExtension.csproj b/samples/TasksExtension/TasksExtension.csproj
index 2f66badd7..e0bdd3ff7 100644
--- a/samples/TasksExtension/TasksExtension.csproj
+++ b/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>
diff --git a/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs b/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs
index bfe81d19b..8ccae6dd8 100644
--- a/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs
+++ b/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs
@@ -911,13 +911,6 @@ public Task UnsubscribeFromResourceAsync(
     /// <returns>The <see cref="CallToolResult"/> from the tool execution.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="toolName"/> is <see langword="null"/>.</exception>
     /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    /// <remarks>
-    /// This overload supports the tasks extension transparently. If the server responds with a
-    /// task handle rather than an immediate result, this method polls <c>tasks/get</c> until the
-    /// task completes, dispatching any <see cref="McpTaskStatus.InputRequired"/> entries through
-    /// the client's registered sampling and elicitation handlers along the way. Use
-    /// <see cref="CallToolRawAsync"/> to disable automatic polling.
-    /// </remarks>
     public ValueTask<CallToolResult> CallToolAsync(
         string toolName,
         IReadOnlyDictionary<string, object?>? arguments = null,
@@ -988,219 +981,18 @@ async ValueTask<CallToolResult> SendRequestWithProgressAsync(
     /// <returns>The result of the request.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="requestParams"/> is <see langword="null"/>.</exception>
     /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    /// <remarks>
-    /// This method automatically includes the <c>io.modelcontextprotocol/tasks</c> extension capability
-    /// in the request metadata. If the server returns a task handle instead of an immediate result,
-    /// this method transparently polls <c>tasks/get</c> until the task completes, fails, or is cancelled.
-    /// Use <see cref="CallToolRawAsync"/>
-    /// to receive the raw <see cref="ResultOrCreatedTask{TResult}"/> without automatic polling.
-    /// </remarks>
-    public async ValueTask<CallToolResult> CallToolAsync(
-        CallToolRequestParams requestParams,
-        CancellationToken cancellationToken = default)
-    {
-        Throw.IfNull(requestParams);
-
-        var augmented = await CallToolRawAsync(requestParams, cancellationToken).ConfigureAwait(false);
-
-        if (!augmented.IsTask)
-        {
-            return augmented.Result!;
-        }
-
-        return await PollTaskToCompletionAsync(augmented.TaskCreated!, cancellationToken).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Polls a task until it reaches a terminal state and returns the final <see cref="CallToolResult"/>.
-    /// </summary>
-    private async ValueTask<CallToolResult> PollTaskToCompletionAsync(
-        CreateTaskResult taskCreated,
-        CancellationToken cancellationToken)
-    {
-        // If the server claims InputRequired but never publishes new input requests after we have
-        // already responded to everything it asked for, treat that as a stuck task. The client
-        // can still cancel earlier via cancellationToken; this guard prevents an unbounded poll
-        // loop when the server is misbehaving. The threshold is configurable via
-        // McpClientOptions.MaxConsecutiveStuckPolls.
-        int maxConsecutiveStuckPolls = MaxConsecutiveStuckPolls;
-
-        string taskId = taskCreated.TaskId;
-        long pollIntervalMs = taskCreated.PollIntervalMs ?? 1000;
-        HashSet<string>? resolvedRequestKeys = null;
-        bool isFirstPoll = true;
-        int consecutiveStuckPolls = 0;
-
-        while (true)
-        {
-            // Skip the delay before the first poll: many tasks complete almost immediately and we
-            // don't want to pay the poll interval as gratuitous latency.
-            if (!isFirstPoll)
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(pollIntervalMs), cancellationToken).ConfigureAwait(false);
-            }
-            isFirstPoll = false;
-
-            var taskResult = await GetTaskAsync(taskId, cancellationToken).ConfigureAwait(false);
-
-            // Update poll interval if the server changed it.
-            if (taskResult.PollIntervalMs is { } newInterval)
-            {
-                pollIntervalMs = newInterval;
-            }
-
-            switch (taskResult)
-            {
-                case CompletedTaskResult completed:
-                    return JsonSerializer.Deserialize(completed.Result, McpJsonUtilities.JsonContext.Default.CallToolResult)
-                        ?? throw new JsonException("Failed to deserialize CallToolResult from completed task.");
-
-                case FailedTaskResult failed:
-                    throw new McpException($"Task '{taskId}' failed: {failed.Error}");
-
-                case CancelledTaskResult:
-                    throw new OperationCanceledException($"Task '{taskId}' was cancelled by the server.");
-
-                case InputRequiredTaskResult inputRequired:
-                    // Dedup: only resolve input requests we haven't already responded to.
-                    var newRequests = new Dictionary<string, InputRequest>();
-                    if (inputRequired.InputRequests is { } incomingRequests)
-                    {
-                        foreach (var kvp in incomingRequests)
-                        {
-                            if (resolvedRequestKeys is null || !resolvedRequestKeys.Contains(kvp.Key))
-                            {
-                                newRequests[kvp.Key] = kvp.Value;
-                            }
-                        }
-                    }
-
-                    if (newRequests.Count > 0)
-                    {
-                        consecutiveStuckPolls = 0;
-
-                        IDictionary<string, InputResponse> inputResponses;
-                        try
-                        {
-                            inputResponses = await ResolveInputRequestsAsync(newRequests, cancellationToken).ConfigureAwait(false);
-                        }
-                        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
-                        {
-                            throw;
-                        }
-                        catch
-                        {
-                            // The input handler failed (e.g., ElicitationHandler threw or no handler was registered).
-                            // Best-effort cancel of the server-side task so it doesn't stay stuck in InputRequired
-                            // until TTL expires.
-                            try
-                            {
-                                await CancelTaskAsync(taskId, CancellationToken.None).ConfigureAwait(false);
-                            }
-                            catch
-                            {
-                                // Swallow secondary failures; we're already propagating the original exception.
-                            }
-
-                            throw;
-                        }
-
-                        await UpdateTaskAsync(new UpdateTaskRequestParams
-                        {
-                            TaskId = taskId,
-                            InputResponses = inputResponses,
-                        }, cancellationToken).ConfigureAwait(false);
-
-                        resolvedRequestKeys ??= new HashSet<string>(StringComparer.Ordinal);
-                        foreach (var key in inputResponses.Keys)
-                        {
-                            resolvedRequestKeys.Add(key);
-                        }
-                    }
-                    else if (++consecutiveStuckPolls >= maxConsecutiveStuckPolls)
-                    {
-                        // Best-effort cancel of the server-side task so it doesn't leak until TTL expires.
-                        try
-                        {
-                            await CancelTaskAsync(taskId, CancellationToken.None).ConfigureAwait(false);
-                        }
-                        catch
-                        {
-                            // Swallow secondary failures; we're already propagating an exception.
-                        }
-
-                        throw new McpException(
-                            $"Task '{taskId}' has remained in '{McpTaskStatus.InputRequired}' for {maxConsecutiveStuckPolls} consecutive polls " +
-                            "without publishing new input requests after all previously requested inputs were resolved.");
-                    }
-
-                    break;
-
-                case WorkingTaskResult:
-                    // Continue polling.
-                    consecutiveStuckPolls = 0;
-                    break;
-
-                default:
-                    throw new McpException(
-                        $"Unexpected task result type '{taskResult.GetType().Name}' for task '{taskId}'.");
-            }
-        }
-    }
-
-    /// <summary>
-    /// Invokes a tool on the server with task extension support, returning the raw response
-    /// without automatic polling. The caller is responsible for handling task lifecycle.
-    /// </summary>
-    /// <param name="requestParams">The request parameters to send. The tasks extension capability will be injected into the request metadata.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
-    /// <returns>A <see cref="ResultOrCreatedTask{TResult}"/> that is either an immediate result or a task handle.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="requestParams"/> is <see langword="null"/>.</exception>
-    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    /// <remarks>
-    /// <para>
-    /// Unlike <see cref="CallToolAsync(CallToolRequestParams, CancellationToken)"/>, this method does not
-    /// automatically poll for task completion. If the server returns a <see cref="CreateTaskResult"/>,
-    /// the caller must manage polling via <see cref="GetTaskAsync(string, CancellationToken)"/>.
-    /// </para>
-    /// </remarks>
-    public async ValueTask<ResultOrCreatedTask<CallToolResult>> CallToolRawAsync(
+    public ValueTask<CallToolResult> CallToolAsync(
         CallToolRequestParams requestParams,
         CancellationToken cancellationToken = default)
     {
         Throw.IfNull(requestParams);
 
-        var paramsWithMeta = new CallToolRequestParams
-        {
-            Name = requestParams.Name,
-            Arguments = requestParams.Arguments,
-            // The SEP-2663 Tasks extension requires the 2026-07-28 or later protocol revision. On an older session, send a plain tools/call
-            // (no task capability envelope) so the server returns a direct CallToolResult and never
-            // creates a task.
-            Meta = IsJuly2026OrLaterProtocol() ? GetMetaWithTaskCapability(requestParams.Meta) : requestParams.Meta,
-        };
-
-        JsonRpcRequest jsonRpcRequest = new()
-        {
-            Method = RequestMethods.ToolsCall,
-            Params = JsonSerializer.SerializeToNode(paramsWithMeta, McpJsonUtilities.JsonContext.Default.CallToolRequestParams),
-        };
-
-        JsonRpcResponse response = await SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false);
-
-        // Discriminate based on resultType field.
-        if (response.Result is JsonObject resultObj &&
-            resultObj.TryGetPropertyValue("resultType", out var resultTypeNode) &&
-            resultTypeNode?.GetValue<string>() == "task")
-        {
-            var taskCreated = resultObj.Deserialize(McpJsonUtilities.JsonContext.Default.CreateTaskResult)
-                ?? throw new JsonException("Failed to deserialize CreateTaskResult from response.");
-            return new ResultOrCreatedTask<CallToolResult>(taskCreated);
-        }
-
-        var callToolResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.JsonContext.Default.CallToolResult)
-            ?? throw new JsonException("Failed to deserialize CallToolResult from response.");
-        return new ResultOrCreatedTask<CallToolResult>(callToolResult);
+        return SendRequestAsync(
+            RequestMethods.ToolsCall,
+            requestParams,
+            McpJsonUtilities.JsonContext.Default.CallToolRequestParams,
+            McpJsonUtilities.JsonContext.Default.CallToolResult,
+            cancellationToken: cancellationToken);
     }
 
     /// <summary>
@@ -1258,109 +1050,6 @@ public Task SetLoggingLevelAsync(
             cancellationToken: cancellationToken).AsTask();
     }
 
-    /// <summary>
-    /// Retrieves the current state of a task from the server.
-    /// </summary>
-    /// <param name="taskId">The stable identifier of the task to retrieve.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
-    /// <returns>A <see cref="GetTaskResult"/> subtype representing the current task state.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="taskId"/> is <see langword="null"/>.</exception>
-    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    public ValueTask<GetTaskResult> GetTaskAsync(
-        string taskId,
-        CancellationToken cancellationToken = default)
-    {
-        Throw.IfNull(taskId);
-
-        return GetTaskAsync(new GetTaskRequestParams { TaskId = taskId }, cancellationToken);
-    }
-
-    /// <summary>
-    /// Retrieves the current state of a task from the server.
-    /// </summary>
-    /// <param name="requestParams">The request parameters to send in the request.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
-    /// <returns>A <see cref="GetTaskResult"/> subtype representing the current task state.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="requestParams"/> is <see langword="null"/>.</exception>
-    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    public ValueTask<GetTaskResult> GetTaskAsync(
-        GetTaskRequestParams requestParams,
-        CancellationToken cancellationToken = default)
-    {
-        Throw.IfNull(requestParams);
-        ThrowIfTasksNotSupported(nameof(GetTaskAsync));
-
-        return SendRequestAsync(
-            RequestMethods.TasksGet,
-            requestParams,
-            McpJsonUtilities.JsonContext.Default.GetTaskRequestParams,
-            McpJsonUtilities.JsonContext.Default.GetTaskResult,
-            cancellationToken: cancellationToken);
-    }
-
-    /// <summary>
-    /// Provides input responses to a task that is in the <see cref="McpTaskStatus.InputRequired"/> state.
-    /// </summary>
-    /// <param name="requestParams">The request parameters containing the task ID and input responses.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
-    /// <returns>The result acknowledging the update.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="requestParams"/> is <see langword="null"/>.</exception>
-    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    public ValueTask<UpdateTaskResult> UpdateTaskAsync(
-        UpdateTaskRequestParams requestParams,
-        CancellationToken cancellationToken = default)
-    {
-        Throw.IfNull(requestParams);
-        ThrowIfTasksNotSupported(nameof(UpdateTaskAsync));
-
-        return SendRequestAsync(
-            RequestMethods.TasksUpdate,
-            requestParams,
-            McpJsonUtilities.JsonContext.Default.UpdateTaskRequestParams,
-            McpJsonUtilities.JsonContext.Default.UpdateTaskResult,
-            cancellationToken: cancellationToken);
-    }
-
-    /// <summary>
-    /// Requests cancellation of an in-progress task on the server.
-    /// </summary>
-    /// <param name="taskId">The stable identifier of the task to cancel.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
-    /// <returns>The result acknowledging the cancellation request.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="taskId"/> is <see langword="null"/>.</exception>
-    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    public ValueTask<CancelTaskResult> CancelTaskAsync(
-        string taskId,
-        CancellationToken cancellationToken = default)
-    {
-        Throw.IfNull(taskId);
-
-        return CancelTaskAsync(new CancelTaskRequestParams { TaskId = taskId }, cancellationToken);
-    }
-
-    /// <summary>
-    /// Requests cancellation of an in-progress task on the server.
-    /// </summary>
-    /// <param name="requestParams">The request parameters to send in the request.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
-    /// <returns>The result acknowledging the cancellation request.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="requestParams"/> is <see langword="null"/>.</exception>
-    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
-    public ValueTask<CancelTaskResult> CancelTaskAsync(
-        CancelTaskRequestParams requestParams,
-        CancellationToken cancellationToken = default)
-    {
-        Throw.IfNull(requestParams);
-        ThrowIfTasksNotSupported(nameof(CancelTaskAsync));
-
-        return SendRequestAsync(
-            RequestMethods.TasksCancel,
-            requestParams,
-            McpJsonUtilities.JsonContext.Default.CancelTaskRequestParams,
-            McpJsonUtilities.JsonContext.Default.CancelTaskResult,
-            cancellationToken: cancellationToken);
-    }
-
     /// <summary>Converts a dictionary with <see cref="object"/> values to a dictionary with <see cref="JsonElement"/> values.</summary>
     private static Dictionary<string, JsonElement>? ToArgumentsDictionary(
         IReadOnlyDictionary<string, object?>? arguments, JsonSerializerOptions options)
@@ -1379,44 +1068,4 @@ public ValueTask<CancelTaskResult> CancelTaskAsync(
 
         return result;
     }
-
-    // Per SEP-2663 §51, the per-request opt-in uses the SEP-2575 capabilities envelope:
-    //   _meta/io.modelcontextprotocol/clientCapabilities/extensions/io.modelcontextprotocol/tasks = {}
-    private static JsonObject GetMetaWithTaskCapability(JsonObject? existingMeta)
-    {
-        JsonObject meta = existingMeta is not null
-            ? (JsonObject)existingMeta.DeepClone()
-            : [];
-
-        if (meta[MetaKeys.ClientCapabilities] is not JsonObject capsRoot)
-        {
-            capsRoot = [];
-            meta[MetaKeys.ClientCapabilities] = capsRoot;
-        }
-
-        if (capsRoot["extensions"] is not JsonObject extensionsRoot)
-        {
-            extensionsRoot = [];
-            capsRoot["extensions"] = extensionsRoot;
-        }
-
-        extensionsRoot.TryAdd(McpExtensions.Tasks, new JsonObject());
-        return meta;
-    }
-
-    /// <summary>
-    /// Throws when the negotiated protocol version does not support the SEP-2663 Tasks extension. Tasks
-    /// require the 2026-07-28 or later protocol revision, and a task id only ever exists when the session
-    /// negotiated such a revision, so invoking <c>tasks/get</c>, <c>tasks/update</c>, or <c>tasks/cancel</c>
-    /// on an older session is a programming error rather than a recoverable protocol condition.
-    /// </summary>
-    private void ThrowIfTasksNotSupported(string operationName)
-    {
-        if (!IsJuly2026OrLaterProtocol())
-        {
-            throw new InvalidOperationException(
-                $"'{operationName}' requires a newer protocol revision that supports tasks. " +
-                $"The negotiated protocol version is '{NegotiatedProtocolVersion ?? "(none)"}'.");
-        }
-    }
 }
diff --git a/src/ModelContextProtocol.Core/Client/McpClient.cs b/src/ModelContextProtocol.Core/Client/McpClient.cs
index b238c59c3..13078e152 100644
--- a/src/ModelContextProtocol.Core/Client/McpClient.cs
+++ b/src/ModelContextProtocol.Core/Client/McpClient.cs
@@ -73,7 +73,7 @@ protected McpClient()
     public abstract Task<ClientCompletionDetails> Completion { get; }
 
     /// <summary>
-    /// Resolves input requests embedded in an <see cref="InputRequiredTaskResult"/> by dispatching
+    /// Resolves input requests embedded in a task that requires input by dispatching
     /// each request to the appropriate registered handler.
     /// </summary>
     /// <param name="inputRequests">
@@ -82,16 +82,10 @@ protected McpClient()
     /// </param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
     /// <returns>A dictionary of responses keyed by the same identifiers as the input requests.</returns>
-    private protected abstract ValueTask<IDictionary<string, InputResponse>> ResolveInputRequestsAsync(
+    [System.Diagnostics.CodeAnalysis.Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)]
+    public abstract ValueTask<IDictionary<string, InputResponse>> ResolveInputRequestsAsync(
         IDictionary<string, InputRequest> inputRequests, CancellationToken cancellationToken);
 
-    /// <summary>
-    /// Gets the maximum number of consecutive stuck-in-<see cref="McpTaskStatus.InputRequired"/> polls
-    /// allowed by <see cref="PollTaskToCompletionAsync"/> before the client cancels and throws.
-    /// Sourced from <see cref="McpClientOptions.MaxConsecutiveStuckPolls"/>.
-    /// </summary>
-    private protected abstract int MaxConsecutiveStuckPolls { get; }
-
     /// <summary>
     /// Registers one or more tool definitions in the client's tool cache, enabling the transport
     /// to send <c>Mcp-Param-*</c> headers for those tools without requiring a prior <see cref="McpClient.ListToolsAsync(RequestOptions?, CancellationToken)"/> call.
diff --git a/src/ModelContextProtocol.Core/Client/McpClientImpl.cs b/src/ModelContextProtocol.Core/Client/McpClientImpl.cs
index eb2fedc85..8b62b7b3d 100644
--- a/src/ModelContextProtocol.Core/Client/McpClientImpl.cs
+++ b/src/ModelContextProtocol.Core/Client/McpClientImpl.cs
@@ -41,7 +41,6 @@ internal sealed partial class McpClientImpl : McpClient
     /// <param name="options">Options for the client, defining protocol version and capabilities.</param>
     /// <param name="loggerFactory">The logger factory.</param>
     internal McpClientImpl(ITransport transport, string endpointName, McpClientOptions? options, ILoggerFactory? loggerFactory)
-#pragma warning restore MCPEXP002
     {
         options ??= new();
 
@@ -178,10 +177,7 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not
     public override Task<ClientCompletionDetails> Completion => _sessionHandler.CompletionTask;
 
     /// <inheritdoc/>
-    private protected override int MaxConsecutiveStuckPolls => _options.MaxConsecutiveStuckPolls;
-
-    /// <inheritdoc/>
-    private protected override async ValueTask<IDictionary<string, InputResponse>> ResolveInputRequestsAsync(
+    public override async ValueTask<IDictionary<string, InputResponse>> ResolveInputRequestsAsync(
         IDictionary<string, InputRequest> inputRequests,
         CancellationToken cancellationToken)
     {
diff --git a/src/ModelContextProtocol.Core/Client/McpClientOptions.cs b/src/ModelContextProtocol.Core/Client/McpClientOptions.cs
index aaf3cefa6..036fb2269 100644
--- a/src/ModelContextProtocol.Core/Client/McpClientOptions.cs
+++ b/src/ModelContextProtocol.Core/Client/McpClientOptions.cs
@@ -146,42 +146,4 @@ public McpClientHandlers Handlers
             field = value;
         }
     }
-
-    /// <summary>
-    /// Gets or sets the maximum number of consecutive task polls during which a task may report
-    /// <see cref="McpTaskStatus.InputRequired"/> without publishing any new input requests, before
-    /// the client treats the task as stuck, issues a best-effort <c>tasks/cancel</c>, and throws
-    /// an <see cref="McpException"/>.
-    /// </summary>
-    /// <value>
-    /// The maximum number of consecutive stuck polls allowed. The default value is <c>60</c>.
-    /// </value>
-    /// <remarks>
-    /// <para>
-    /// This guard prevents an unbounded poll loop when the server keeps a task in
-    /// <see cref="McpTaskStatus.InputRequired"/> but never publishes new input requests after the
-    /// client has already responded to every previously surfaced request. It only affects the
-    /// long-poll path used by <see cref="McpClient.CallToolAsync(CallToolRequestParams, CancellationToken)"/>;
-    /// it does not affect direct <see cref="McpClient.GetTaskAsync(string, CancellationToken)"/> calls.
-    /// </para>
-    /// <para>
-    /// Callers should size this value with the configured server-side poll interval in mind: the
-    /// effective wall-clock timeout is roughly <c>MaxConsecutiveStuckPolls * pollIntervalMs</c>.
-    /// Setting this to a very small value can cause false positives for servers that are slow to
-    /// surface follow-up input requests; setting it too large can mask misbehaving servers.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="ArgumentOutOfRangeException">The value is less than <c>1</c>.</exception>
-    public int MaxConsecutiveStuckPolls
-    {
-        get;
-        set
-        {
-            if (value < 1)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value), value, "must be greater than or equal to 1.");
-            }
-            field = value;
-        }
-    } = 60;
 }
diff --git a/src/ModelContextProtocol.Core/McpJsonUtilities.cs b/src/ModelContextProtocol.Core/McpJsonUtilities.cs
index da1b898dd..74b45a0f1 100644
--- a/src/ModelContextProtocol.Core/McpJsonUtilities.cs
+++ b/src/ModelContextProtocol.Core/McpJsonUtilities.cs
@@ -120,12 +120,6 @@ internal static bool IsValidToolOutputSchema(JsonElement element) =>
     [JsonSerializable(typeof(ResourceUpdatedNotificationParams))]
     [JsonSerializable(typeof(RootsListChangedNotificationParams))]
     [JsonSerializable(typeof(ToolListChangedNotificationParams))]
-    [JsonSerializable(typeof(TaskStatusNotificationParams))]
-    [JsonSerializable(typeof(WorkingTaskNotificationParams))]
-    [JsonSerializable(typeof(CompletedTaskNotificationParams))]
-    [JsonSerializable(typeof(FailedTaskNotificationParams))]
-    [JsonSerializable(typeof(CancelledTaskNotificationParams))]
-    [JsonSerializable(typeof(InputRequiredTaskNotificationParams))]
 
     // MCP Request Params / Results
     [JsonSerializable(typeof(CallToolRequestParams))]
@@ -174,19 +168,6 @@ internal static bool IsValidToolOutputSchema(JsonElement element) =>
     [JsonSerializable(typeof(IDictionary<string, InputRequest>))]
     [JsonSerializable(typeof(IDictionary<string, InputResponse>))]
 
-    [JsonSerializable(typeof(GetTaskRequestParams))]
-    [JsonSerializable(typeof(GetTaskResult))]
-    [JsonSerializable(typeof(WorkingTaskResult))]
-    [JsonSerializable(typeof(CompletedTaskResult))]
-    [JsonSerializable(typeof(FailedTaskResult))]
-    [JsonSerializable(typeof(CancelledTaskResult))]
-    [JsonSerializable(typeof(InputRequiredTaskResult))]
-    [JsonSerializable(typeof(UpdateTaskRequestParams))]
-    [JsonSerializable(typeof(UpdateTaskResult))]
-    [JsonSerializable(typeof(CancelTaskRequestParams))]
-    [JsonSerializable(typeof(CancelTaskResult))]
-    [JsonSerializable(typeof(CreateTaskResult))]
-
     // MCP Content
     [JsonSerializable(typeof(ContentBlock))]
     [JsonSerializable(typeof(TextContentBlock))]
diff --git a/src/ModelContextProtocol.Core/McpSession.cs b/src/ModelContextProtocol.Core/McpSession.cs
index e1bd0844b..63f1bb525 100644
--- a/src/ModelContextProtocol.Core/McpSession.cs
+++ b/src/ModelContextProtocol.Core/McpSession.cs
@@ -57,6 +57,16 @@ public abstract partial class McpSession : IAsyncDisposable
     internal bool IsJuly2026OrLaterProtocol() =>
         McpHttpHeaders.IsJuly2026OrLaterProtocolVersion(NegotiatedProtocolVersion);
 
+    /// <summary>
+    /// Gets a value indicating whether the negotiated protocol version supports the draft protocol
+    /// features (the <c>2026-07-28</c> revision or later).
+    /// </summary>
+    /// <remarks>
+    /// This is a public seam used by bolt-on extensions (such as the Tasks extension) to gate
+    /// functionality that requires the <c>2026-07-28</c> or later protocol revision.
+    /// </remarks>
+    public bool IsDraftProtocol() => IsJuly2026OrLaterProtocol();
+
     /// <summary>
     /// Sends a JSON-RPC request to the connected session and waits for a response.
     /// </summary>
diff --git a/src/ModelContextProtocol.Core/Protocol/MetaKeys.cs b/src/ModelContextProtocol.Core/Protocol/MetaKeys.cs
index 4d9139953..29db6f5ae 100644
--- a/src/ModelContextProtocol.Core/Protocol/MetaKeys.cs
+++ b/src/ModelContextProtocol.Core/Protocol/MetaKeys.cs
@@ -53,24 +53,4 @@ public static class MetaKeys
     /// belonging to different subscriptions on a shared channel (especially STDIO).
     /// </remarks>
     public const string SubscriptionId = "io.modelcontextprotocol/subscriptionId";
-
-    /// <summary>
-    /// The metadata key used to associate requests, responses, and notifications with a task.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This constant defines the key <c>"io.modelcontextprotocol/related-task"</c> used in the
-    /// <c>_meta</c> field to associate messages with their originating task across the entire
-    /// request lifecycle.
-    /// </para>
-    /// <para>
-    /// For example, an elicitation that a task-augmented tool call depends on must share the
-    /// same related task ID with that tool call's task.
-    /// </para>
-    /// <para>
-    /// For <c>tasks/get</c>, <c>tasks/list</c>, and <c>tasks/cancel</c> operations, this
-    /// metadata should not be included as the taskId is already present in the message structure.
-    /// </para>
-    /// </remarks>
-    public const string RelatedTask = "io.modelcontextprotocol/related-task";
 }
diff --git a/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs b/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs
index 0bd3348f8..7911d9e33 100644
--- a/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs
+++ b/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs
@@ -144,16 +144,6 @@ public static class NotificationMethods
     /// </remarks>
     public const string CancelledNotification = "notifications/cancelled";
 
-    /// <summary>
-    /// The name of the notification sent by the server to push task status updates to subscribed clients.
-    /// </summary>
-    /// <remarks>
-    /// Part of the <c>io.modelcontextprotocol/tasks</c> extension.
-    /// Each notification carries a complete task state for the current status, identical to what
-    /// <c>tasks/get</c> would have returned at that moment.
-    /// </remarks>
-    public const string TaskStatusNotification = "notifications/tasks/status";
-
     /// <summary>
     /// The name of the notification sent first on a <see cref="RequestMethods.SubscriptionsListen"/>
     /// response stream to indicate which notification types the server agreed to deliver.
diff --git a/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs b/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs
index 54432a4c2..fcdfcd178 100644
--- a/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs
+++ b/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs
@@ -8,8 +8,8 @@ namespace ModelContextProtocol.Protocol;
 /// </summary>
 public abstract class NotificationParams
 {
-    /// <summary>Prevent external derivations.</summary>
-    private protected NotificationParams()
+    /// <summary>Allow derivations only within the SDK and its extension packages.</summary>
+    protected NotificationParams()
     {
     }
 
diff --git a/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs b/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs
index a2884efba..29d7d3764 100644
--- a/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs
+++ b/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs
@@ -125,33 +125,6 @@ public static class RequestMethods
     /// </remarks>
     public const string Initialize = "initialize";
 
-    /// <summary>
-    /// The name of the request method sent from the client to poll for task completion.
-    /// </summary>
-    /// <remarks>
-    /// Part of the <c>io.modelcontextprotocol/tasks</c> extension.
-    /// Clients poll for task status by sending this request with the task ID.
-    /// </remarks>
-    public const string TasksGet = "tasks/get";
-
-    /// <summary>
-    /// The name of the request method sent from the client to provide input responses to a task.
-    /// </summary>
-    /// <remarks>
-    /// Part of the <c>io.modelcontextprotocol/tasks</c> extension.
-    /// Used when a task has <c>input_required</c> status and the client needs to fulfill outstanding requests.
-    /// </remarks>
-    public const string TasksUpdate = "tasks/update";
-
-    /// <summary>
-    /// The name of the request method sent from the client to signal intent to cancel a task.
-    /// </summary>
-    /// <remarks>
-    /// Part of the <c>io.modelcontextprotocol/tasks</c> extension.
-    /// Cancellation is cooperative — the server decides whether and when to honor it.
-    /// </remarks>
-    public const string TasksCancel = "tasks/cancel";
-
     /// <summary>
     /// The name of the request method sent from the client to discover the server's protocol versions,
     /// capabilities, and metadata.
diff --git a/src/ModelContextProtocol.Core/Protocol/RequestParams.cs b/src/ModelContextProtocol.Core/Protocol/RequestParams.cs
index 67a8f00ba..4597857cf 100644
--- a/src/ModelContextProtocol.Core/Protocol/RequestParams.cs
+++ b/src/ModelContextProtocol.Core/Protocol/RequestParams.cs
@@ -11,8 +11,8 @@ namespace ModelContextProtocol.Protocol;
 /// </remarks>
 public abstract class RequestParams
 {
-    /// <summary>Prevent external derivations.</summary>
-    private protected RequestParams()
+    /// <summary>Allow derivations only within the SDK and its extension packages.</summary>
+    protected RequestParams()
     {
     }
 
diff --git a/src/ModelContextProtocol.Core/Protocol/Result.cs b/src/ModelContextProtocol.Core/Protocol/Result.cs
index 15eb6fa46..a7da7e5e6 100644
--- a/src/ModelContextProtocol.Core/Protocol/Result.cs
+++ b/src/ModelContextProtocol.Core/Protocol/Result.cs
@@ -8,8 +8,8 @@ namespace ModelContextProtocol.Protocol;
 /// </summary>
 public abstract class Result
 {
-    /// <summary>Prevent external derivations.</summary>
-    private protected Result()
+    /// <summary>Allow derivations only within the SDK and its extension packages.</summary>
+    protected Result()
     {
     }
 
@@ -30,8 +30,8 @@ private protected Result()
     /// When absent or set to <c>"complete"</c>, the result is a normal completed response.
     /// When set to <c>"input_required"</c>, the result is an <see cref="InputRequiredResult"/> indicating
     /// that additional input is needed before the request can be completed.
-    /// When set to <c>"task"</c>, the result is a <see cref="CreateTaskResult"/> indicating that the server
-    /// has created a long-running task in lieu of returning the result directly.
+    /// When set to <c>"task"</c>, the server has created a long-running task in lieu of returning the
+    /// result directly.
     /// </para>
     /// </remarks>
     /// <value>Defaults to <see langword="null"/>, which is equivalent to <c>"complete"</c>.</value>
diff --git a/src/ModelContextProtocol.Core/RequestHandlers.cs b/src/ModelContextProtocol.Core/RequestHandlers.cs
index f15ce316c..97e8b95df 100644
--- a/src/ModelContextProtocol.Core/RequestHandlers.cs
+++ b/src/ModelContextProtocol.Core/RequestHandlers.cs
@@ -45,49 +45,4 @@ public void Set<TParams, TResult>(
             return JsonSerializer.SerializeToNode(result, responseTypeInfo);
         };
     }
-
-    /// <summary>
-    /// Registers a handler that may return either a standard result or a <see cref="CreateTaskResult"/>
-    /// for task-augmented execution.
-    /// </summary>
-    public void SetTaskAugmented<TParams, TResult>(
-        string method,
-        Func<TParams, JsonRpcRequest, CancellationToken, ValueTask<ResultOrCreatedTask<TResult>>> handler,
-        JsonTypeInfo<TParams> requestTypeInfo,
-        JsonTypeInfo<TResult> responseTypeInfo,
-        JsonTypeInfo<CreateTaskResult> taskResultTypeInfo)
-        where TResult : Result
-    {
-        Throw.IfNull(method);
-        Throw.IfNull(handler);
-        Throw.IfNull(requestTypeInfo);
-        Throw.IfNull(responseTypeInfo);
-        Throw.IfNull(taskResultTypeInfo);
-
-        this[method] = async (request, cancellationToken) =>
-        {
-            TParams typedRequest = JsonSerializer.Deserialize(request.Params, requestTypeInfo)!;
-            var augmented = await handler(typedRequest, request, cancellationToken).ConfigureAwait(false);
-
-            if (augmented.IsTask)
-            {
-                // Guard against a misconfiguration where a handler opts into task-augmented
-                // execution but the server has no task lifecycle handlers wired up. Without
-                // tasks/get, a client that received a CreateTaskResult would have no way to
-                // poll the task to completion. Configure McpServerOptions.TaskStore or set
-                // the task handlers explicitly via McpServerOptions.Handlers.
-                if (!ContainsKey(RequestMethods.TasksGet))
-                {
-                    throw new InvalidOperationException(
-                        $"Handler for '{method}' returned a {nameof(CreateTaskResult)}, but the server has no " +
-                        $"'{RequestMethods.TasksGet}' handler registered. Configure McpServerOptions.TaskStore " +
-                        "or set the task handlers explicitly in McpServerOptions.Handlers before starting the server.");
-                }
-
-                return JsonSerializer.SerializeToNode(augmented.TaskCreated!, taskResultTypeInfo);
-            }
-
-            return JsonSerializer.SerializeToNode(augmented.Result!, responseTypeInfo);
-        };
-    }
 }
diff --git a/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs b/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs
index b8f96237a..f6f85dcdc 100644
--- a/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs
+++ b/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs
@@ -51,8 +51,8 @@ public override Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest request, C
     {
         // When an MRTR context is active, intercept server-to-client requests (sampling, elicitation, roots)
         // and route them through the MRTR mechanism instead of sending them over the wire.
-        // Task-augmented requests (SampleAsTaskAsync/ElicitAsTaskAsync) have a "task" property on their params
-        // and expect a CreateTaskResult response, so they must bypass MRTR and go over the wire.
+        // Requests carrying a "task" property on their params are part of a bolt-on task extension flow
+        // and expect a task-creation response, so they must bypass MRTR and go over the wire.
         if (ActiveMrtrContext is { } mrtrContext &&
             !(request.Params is JsonObject paramsObj && paramsObj.ContainsKey("task")))
         {
diff --git a/src/ModelContextProtocol.Core/Server/IMcpServerRawHandlerRegistry.cs b/src/ModelContextProtocol.Core/Server/IMcpServerRawHandlerRegistry.cs
new file mode 100644
index 000000000..5431ed686
--- /dev/null
+++ b/src/ModelContextProtocol.Core/Server/IMcpServerRawHandlerRegistry.cs
@@ -0,0 +1,61 @@
+using ModelContextProtocol.Protocol;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Server;
+
+/// <summary>
+/// Represents a low-level request handler that operates directly on the JSON-RPC request and produces
+/// the serialized result node, bypassing the strongly-typed handler pipeline.
+/// </summary>
+/// <param name="request">The incoming JSON-RPC request.</param>
+/// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
+/// <returns>The serialized result node, or <see langword="null"/>.</returns>
+[Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)]
+public delegate ValueTask<JsonNode?> McpRawRequestHandler(JsonRpcRequest request, CancellationToken cancellationToken);
+
+/// <summary>
+/// Provides a low-level seam for registering and wrapping raw request handlers on an <see cref="McpServer"/>.
+/// </summary>
+/// <remarks>
+/// This is an SDK extensibility hook intended for bolt-on packages (such as the MCP Tasks extension) that
+/// need to register new request methods or wrap existing handlers without taking a compile-time dependency
+/// on the feature in the core SDK. Configure it via <see cref="McpServerOptions.RawRequestHandlerConfigurators"/>.
+/// </remarks>
+[Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)]
+public interface IMcpServerRawHandlerRegistry
+{
+    /// <summary>
+    /// Gets the <see cref="McpServer"/> these handlers are being configured for.
+    /// </summary>
+    McpServer Server { get; }
+
+    /// <summary>
+    /// Determines whether a handler is currently registered for the specified method.
+    /// </summary>
+    /// <param name="method">The request method identifier (e.g., <c>"tools/call"</c>).</param>
+    /// <returns><see langword="true"/> if a handler is registered; otherwise, <see langword="false"/>.</returns>
+    bool ContainsHandler(string method);
+
+    /// <summary>
+    /// Registers (or replaces) the raw handler for the specified method.
+    /// </summary>
+    /// <param name="method">The request method identifier (e.g., <c>"tasks/get"</c>).</param>
+    /// <param name="handler">The raw handler to register.</param>
+    void SetHandler(string method, McpRawRequestHandler handler);
+
+    /// <summary>
+    /// Wraps the existing raw handler for the specified method, if one is registered.
+    /// </summary>
+    /// <param name="method">The request method identifier (e.g., <c>"tools/call"</c>).</param>
+    /// <param name="wrap">A function that receives the existing inner handler and returns a wrapping handler.</param>
+    /// <returns><see langword="true"/> if a handler was present and wrapped; otherwise, <see langword="false"/>.</returns>
+    bool TryWrapHandler(string method, Func<McpRawRequestHandler, McpRawRequestHandler> wrap);
+
+    /// <summary>
+    /// Determines whether the specified request was negotiated under the draft protocol revision.
+    /// </summary>
+    /// <param name="request">The JSON-RPC request to inspect.</param>
+    /// <returns><see langword="true"/> if the request was negotiated under the draft revision; otherwise, <see langword="false"/>.</returns>
+    bool IsDraftProtocolRequest(JsonRpcRequest request);
+}
diff --git a/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs b/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs
index 9d9774e8b..891a86789 100644
--- a/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs
+++ b/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs
@@ -36,15 +36,9 @@ public IList<McpRequestFilter<ListToolsRequestParams, ListToolsResult>> ListTool
     /// Gets or sets the filters for the call-tool handler pipeline.
     /// </summary>
     /// <remarks>
-    /// <para>
     /// These filters wrap handlers that are invoked when a client makes a call to a tool that isn't found in the <see cref="McpServerTool"/> collection.
     /// The filters can modify, log, or perform additional operations on requests and responses for
     /// <see cref="RequestMethods.ToolsCall"/> requests. The handler should implement logic to execute the requested tool and return appropriate results.
-    /// </para>
-    /// <para>
-    /// Cannot be used together with <see cref="CallToolWithTaskFilters"/>. If both are non-empty at configuration time,
-    /// an <see cref="InvalidOperationException"/> will be thrown.
-    /// </para>
     /// </remarks>
     public IList<McpRequestFilter<CallToolRequestParams, CallToolResult>> CallToolFilters
     {
@@ -56,31 +50,6 @@ public IList<McpRequestFilter<CallToolRequestParams, CallToolResult>> CallToolFi
         }
     }
 
-    /// <summary>
-    /// Gets or sets the filters for the call-tool handler pipeline with task support.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// These filters wrap the task-augmented call-tool handler whose return type is
-    /// <see cref="ResultOrCreatedTask{TResult}"/>. Use these filters when the server's tool pipeline
-    /// supports returning either an immediate <see cref="CallToolResult"/> or a <see cref="CreateTaskResult"/>
-    /// for asynchronous execution.
-    /// </para>
-    /// <para>
-    /// Cannot be used together with <see cref="CallToolFilters"/>. If both are non-empty at configuration time,
-    /// an <see cref="InvalidOperationException"/> will be thrown.
-    /// </para>
-    /// </remarks>
-    public IList<McpRequestFilter<CallToolRequestParams, ResultOrCreatedTask<CallToolResult>>> CallToolWithTaskFilters
-    {
-        get => field ??= [];
-        set
-        {
-            Throw.IfNull(value);
-            field = value;
-        }
-    }
-
     /// <summary>
     /// Gets or sets the filters for the list-prompts handler pipeline.
     /// </summary>
diff --git a/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs b/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs
index 4f739c28a..0100a56ca 100644
--- a/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs
+++ b/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs
@@ -11,6 +11,8 @@
 
 namespace ModelContextProtocol.Server;
 
+#pragma warning disable MCPEXP002 // Outgoing-request interceptor seam is consumed internally by the server pipeline.
+
 /// <summary>
 /// Represents an instance of a Model Context Protocol (MCP) server that connects to and communicates with an MCP client.
 /// </summary>
@@ -63,8 +65,8 @@ public static McpServer Create(
     /// </para>
     /// <para>
     /// When called during task-augmented tool execution, this method automatically updates the task
-    /// status to <see cref="McpTaskStatus.InputRequired"/> while waiting for the client response,
-    /// then returns to <see cref="McpTaskStatus.Working"/> when the response is received.
+    /// status to input-required while waiting for the client response,
+    /// then returns to the working status when the response is received.
     /// </para>
     /// </remarks>
     [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)]
@@ -74,14 +76,12 @@ public ValueTask<CreateMessageResult> SampleAsync(
     {
         Throw.IfNull(requestParams);
 
-        // If executing inside a background task, redirect sampling through the task store.
-        // Capability checks (ThrowIfSamplingUnsupported) are intentionally skipped here because the
-        // client opted into the tasks extension when submitting the originating request, and input
-        // requests are delivered through the tasks/get response channel rather than as direct
-        // server->client requests. See SendRequestViaTaskAsync remarks.
-        if (McpTaskExecutionContext.Current.Value is { } taskContext)
+        // If an outgoing-request interceptor is active (e.g., background task execution), redirect
+        // sampling through it. Capability checks (ThrowIfSamplingUnsupported) are intentionally skipped
+        // here because the interceptor owns delivery through its own channel.
+        if (CurrentOutgoingRequestInterceptor is { } interceptor)
         {
-            return SendRequestViaTaskAsync(taskContext, RequestMethods.SamplingCreateMessage, requestParams,
+            return InterceptOutgoingRequestAsync(interceptor, RequestMethods.SamplingCreateMessage, requestParams,
                 McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams,
                 McpJsonUtilities.JsonContext.Default.CreateMessageResult,
                 cancellationToken);
@@ -282,14 +282,12 @@ public ValueTask<ListRootsResult> RequestRootsAsync(
     {
         Throw.IfNull(requestParams);
 
-        // If executing inside a background task, redirect through the task store.
-        // Capability checks (ThrowIfRootsUnsupported) are intentionally skipped here because the
-        // client opted into the tasks extension when submitting the originating request, and input
-        // requests are delivered through the tasks/get response channel rather than as direct
-        // server->client requests. See SendRequestViaTaskAsync remarks.
-        if (McpTaskExecutionContext.Current.Value is { } taskContext)
+        // If an outgoing-request interceptor is active (e.g., background task execution), redirect
+        // through it. Capability checks (ThrowIfRootsUnsupported) are intentionally skipped here because
+        // the interceptor owns delivery through its own channel.
+        if (CurrentOutgoingRequestInterceptor is { } interceptor)
         {
-            return SendRequestViaTaskAsync(taskContext, RequestMethods.RootsList, requestParams,
+            return InterceptOutgoingRequestAsync(interceptor, RequestMethods.RootsList, requestParams,
                 McpJsonUtilities.JsonContext.Default.ListRootsRequestParams,
                 McpJsonUtilities.JsonContext.Default.ListRootsResult,
                 cancellationToken);
@@ -324,8 +322,8 @@ public ValueTask<ListRootsResult> RequestRootsAsync(
     /// </para>
     /// <para>
     /// When called during task-augmented tool execution, this method automatically updates the task
-    /// status to <see cref="McpTaskStatus.InputRequired"/> while waiting for user input,
-    /// then returns to <see cref="McpTaskStatus.Working"/> when the response is received.
+    /// status to input-required while waiting for user input,
+    /// then returns to the working status when the response is received.
     /// </para>
     /// </remarks>
     public async ValueTask<ElicitResult> ElicitAsync(
@@ -334,17 +332,15 @@ public async ValueTask<ElicitResult> ElicitAsync(
     {
         Throw.IfNull(requestParams);
 
-        // If executing inside a background task, redirect elicitation through the task store.
-        // Capability checks (ThrowIfElicitationUnsupported) are intentionally skipped here because
-        // the client opted into the tasks extension when submitting the originating request, and
-        // input requests are delivered through the tasks/get response channel rather than as
-        // direct server->client requests. See SendRequestViaTaskAsync remarks.
-        if (McpTaskExecutionContext.Current.Value is { } taskContext)
+        // If an outgoing-request interceptor is active (e.g., background task execution), redirect
+        // elicitation through it. Capability checks (ThrowIfElicitationUnsupported) are intentionally
+        // skipped here because the interceptor owns delivery through its own channel.
+        if (CurrentOutgoingRequestInterceptor is { } interceptor)
         {
-            var taskResult = await SendRequestViaTaskAsync(taskContext, RequestMethods.ElicitationCreate, requestParams,
-                McpJsonUtilities.JsonContext.Default.ElicitRequestParams,
-                McpJsonUtilities.JsonContext.Default.ElicitResult,
+            var node = await interceptor(RequestMethods.ElicitationCreate,
+                JsonSerializer.SerializeToNode(requestParams, McpJsonUtilities.JsonContext.Default.ElicitRequestParams),
                 cancellationToken).ConfigureAwait(false);
+            var taskResult = node is null ? null : JsonSerializer.Deserialize(node, McpJsonUtilities.JsonContext.Default.ElicitResult);
             return taskResult ?? new ElicitResult { Action = "cancel" };
         }
 
@@ -422,26 +418,6 @@ public async ValueTask<ElicitResult<T>> ElicitAsync<T>(
         return new ElicitResult<T> { Action = raw.Action, Content = typed };
     }
 
-    /// <summary>
-    /// Sends a task status notification to the connected client.
-    /// </summary>
-    /// <param name="notificationParams">The task status notification parameters to send.</param>
-    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
-    /// <returns>A task that represents the asynchronous send operation.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="notificationParams"/> is <see langword="null"/>.</exception>
-    public Task SendTaskStatusNotificationAsync(
-        TaskStatusNotificationParams notificationParams,
-        CancellationToken cancellationToken = default)
-    {
-        Throw.IfNull(notificationParams);
-
-        return SendNotificationAsync(
-            NotificationMethods.TaskStatusNotification,
-            notificationParams,
-            McpJsonUtilities.JsonContext.Default.TaskStatusNotificationParams,
-            cancellationToken);
-    }
-
     /// <summary>
     /// Builds a request schema for elicitation based on the public serializable properties of <paramref name="type"/>.
     /// </summary>
@@ -592,84 +568,20 @@ private void ThrowIfRootsUnsupported()
     }
 
     /// <summary>
-    /// Creates a scope that redirects server-initiated requests (elicitation, sampling, list roots) through
-    /// the task store as input requests for the duration of the scope. Use this when executing tool logic
-    /// in the background as a task, so that any server-to-client requests are surfaced to the client via
-    /// the task's <see cref="McpTaskStatus.InputRequired"/> state instead of direct JSON-RPC messages.
+    /// Sends a server-initiated request through the active <see cref="CurrentOutgoingRequestInterceptor"/>
+    /// and deserializes the result.
     /// </summary>
-    /// <param name="taskId">The task ID in the store.</param>
-    /// <param name="store">The task store to write input requests to.</param>
-    /// <returns>An <see cref="IDisposable"/> that restores the previous context when disposed.</returns>
-    public IDisposable CreateMcpTaskScope(
-        string taskId,
-        IMcpTaskStore store)
-    {
-        Throw.IfNull(taskId);
-        Throw.IfNull(store);
-
-        var previous = McpTaskExecutionContext.Current.Value;
-        McpTaskExecutionContext.Current.Value = new McpTaskExecutionContext
-        {
-            TaskId = taskId,
-            Store = store,
-        };
-        return new McpTaskExecutionContext.Scope(previous);
-    }
-
-    /// <summary>
-    /// Sends a server-initiated request through the task store as an input request, then awaits the response.
-    /// </summary>
-    /// <remarks>
-    /// When executing inside a task scope, capability negotiation checks (such as
-    /// <see cref="ThrowIfSamplingUnsupported"/>, <see cref="ThrowIfRootsUnsupported"/>, and
-    /// <see cref="ThrowIfElicitationUnsupported"/>) are intentionally skipped by the callers
-    /// of this helper. The task channel itself is the negotiated capability: the client opted
-    /// in to the tasks extension when it submitted the originating request, and is responsible
-    /// for handling or rejecting the input requests surfaced through <c>tasks/get</c>.
-    /// </remarks>
-    private async ValueTask<TResponse> SendRequestViaTaskAsync<TRequest, TResponse>(
-        McpTaskExecutionContext taskContext,
+    private async ValueTask<TResponse> InterceptOutgoingRequestAsync<TRequest, TResponse>(
+        McpOutgoingRequestInterceptor interceptor,
         string method,
         TRequest request,
         JsonTypeInfo<TRequest> requestTypeInfo,
         JsonTypeInfo<TResponse> responseTypeInfo,
         CancellationToken cancellationToken)
     {
-        var requestId = Guid.NewGuid().ToString("N");
-        var paramsJson = JsonSerializer.SerializeToElement(request, requestTypeInfo);
-
-        var inputRequest = new InputRequest
-        {
-            Method = method,
-            Params = paramsJson,
-        };
-
-        var tcs = new TaskCompletionSource<InputResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-        void handler(InputResponseReceivedEventArgs args)
-        {
-            if (args.TaskId == taskContext.TaskId && args.RequestId == requestId)
-            {
-                tcs.TrySetResult(args.Response);
-            }
-        }
-
-        taskContext.Store.InputResponseReceived += handler;
-        try
-        {
-            await taskContext.Store.SetInputRequestsAsync(
-                taskContext.TaskId,
-                new Dictionary<string, InputRequest> { [requestId] = inputRequest },
-                cancellationToken).ConfigureAwait(false);
-
-            var response = await tcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
-
-            return response.Deserialize(responseTypeInfo)!;
-        }
-        finally
-        {
-            taskContext.Store.InputResponseReceived -= handler;
-        }
+        var paramsNode = JsonSerializer.SerializeToNode(request, requestTypeInfo);
+        var resultNode = await interceptor(method, paramsNode, cancellationToken).ConfigureAwait(false);
+        return JsonSerializer.Deserialize(resultNode, responseTypeInfo)!;
     }
 
     private void ThrowIfElicitationUnsupported(ElicitRequestParams request)
diff --git a/src/ModelContextProtocol.Core/Server/McpServer.cs b/src/ModelContextProtocol.Core/Server/McpServer.cs
index 5f8ebf69a..b69240f04 100644
--- a/src/ModelContextProtocol.Core/Server/McpServer.cs
+++ b/src/ModelContextProtocol.Core/Server/McpServer.cs
@@ -1,13 +1,48 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Nodes;
 using ModelContextProtocol.Protocol;
 
 namespace ModelContextProtocol.Server;
 
+/// <summary>
+/// Intercepts a server-initiated outgoing request (sampling, elicitation, or roots) so that it can be
+/// redirected through an alternate channel instead of being sent directly to the client.
+/// </summary>
+/// <param name="method">The request method identifier (e.g., <c>"sampling/createMessage"</c>).</param>
+/// <param name="params">The serialized request parameters.</param>
+/// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
+/// <returns>The serialized result node for the request.</returns>
+[Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)]
+public delegate ValueTask<JsonNode?> McpOutgoingRequestInterceptor(string method, JsonNode? @params, CancellationToken cancellationToken);
+
 /// <summary>
 /// Represents an instance of a Model Context Protocol (MCP) server that connects to and communicates with an MCP client.
 /// </summary>
 public abstract partial class McpServer : McpSession
 {
+#pragma warning disable MCPEXP002
+    private static readonly AsyncLocal<McpOutgoingRequestInterceptor?> s_currentOutgoingRequestInterceptor = new();
+#pragma warning restore MCPEXP002
+
+    /// <summary>
+    /// Gets or sets the ambient interceptor that redirects server-initiated outgoing requests
+    /// (sampling, elicitation, roots) for the current asynchronous flow.
+    /// </summary>
+    /// <remarks>
+    /// This is an SDK extensibility hook intended for bolt-on packages (such as the MCP Tasks extension)
+    /// that run tool logic in the background and need to surface server-to-client requests through an
+    /// alternate channel. When set, <see cref="ElicitAsync(ModelContextProtocol.Protocol.ElicitRequestParams, CancellationToken)"/>,
+    /// <see cref="SampleAsync(ModelContextProtocol.Protocol.CreateMessageRequestParams, CancellationToken)"/>, and
+    /// <see cref="RequestRootsAsync(ModelContextProtocol.Protocol.ListRootsRequestParams, CancellationToken)"/> route
+    /// through the interceptor instead of sending directly to the client.
+    /// </remarks>
+    [Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)]
+    public static McpOutgoingRequestInterceptor? CurrentOutgoingRequestInterceptor
+    {
+        get => s_currentOutgoingRequestInterceptor.Value;
+        set => s_currentOutgoingRequestInterceptor.Value = value;
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="McpServer"/> class.
     /// </summary>
diff --git a/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs b/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs
index 4f9509b9d..e07100e0e 100644
--- a/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs
+++ b/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs
@@ -42,53 +42,8 @@ public sealed class McpServerHandlers
     /// <remarks>
     /// This handler is invoked when a client makes a call to a tool that isn't found in the <see cref="McpServerTool"/> collection.
     /// The handler should implement logic to execute the requested tool and return appropriate results.
-    /// Use <see cref="CallToolWithTaskHandler"/> instead if the tool may return a <see cref="CreateTaskResult"/>
-    /// for asynchronous execution.
     /// </remarks>
-    /// <exception cref="InvalidOperationException"><see cref="CallToolWithTaskHandler"/> is already set.</exception>
-    public McpRequestHandler<CallToolRequestParams, CallToolResult>? CallToolHandler
-    {
-        get;
-        set
-        {
-            if (value is not null && CallToolWithTaskHandler is not null)
-            {
-                throw new InvalidOperationException(
-                    $"Cannot set {nameof(CallToolHandler)} when {nameof(CallToolWithTaskHandler)} is already set. Only one call tool handler may be configured.");
-            }
-
-            field = value;
-        }
-    }
-
-    /// <summary>
-    /// Gets or sets the handler for <see cref="RequestMethods.ToolsCall"/> requests with task support.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This handler is invoked when a client makes a call to a tool, allowing the tool to return either
-    /// a <see cref="CallToolResult"/> for immediate results or a <see cref="CreateTaskResult"/> for
-    /// long-running asynchronous operations.
-    /// </para>
-    /// <para>
-    /// Cannot be set if <see cref="CallToolHandler"/> is already set.
-    /// </para>
-    /// </remarks>
-    /// <exception cref="InvalidOperationException"><see cref="CallToolHandler"/> is already set.</exception>
-    public McpRequestHandler<CallToolRequestParams, ResultOrCreatedTask<CallToolResult>>? CallToolWithTaskHandler
-    {
-        get;
-        set
-        {
-            if (value is not null && CallToolHandler is not null)
-            {
-                throw new InvalidOperationException(
-                    $"Cannot set {nameof(CallToolWithTaskHandler)} when {nameof(CallToolHandler)} is already set. Only one call tool handler may be configured.");
-            }
-
-            field = value;
-        }
-    }
+    public McpRequestHandler<CallToolRequestParams, CallToolResult>? CallToolHandler { get; set; }
 
     /// <summary>
     /// Gets or sets the handler for <see cref="RequestMethods.PromptsList"/> requests.
@@ -202,74 +157,6 @@ public McpRequestHandler<CallToolRequestParams, ResultOrCreatedTask<CallToolResu
     [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)]
     public McpRequestHandler<SetLevelRequestParams, EmptyResult>? SetLoggingLevelHandler { get; set; }
 
-    /// <summary>
-    /// Gets or sets the handler for <see cref="RequestMethods.TasksGet"/> requests.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This handler is invoked when a client polls for the current state of a task.
-    /// The handler should return the appropriate <see cref="GetTaskResult"/> subtype
-    /// based on the task's current status (for example, <see cref="WorkingTaskResult"/>,
-    /// <see cref="InputRequiredTaskResult"/>, <see cref="CompletedTaskResult"/>,
-    /// <see cref="CancelledTaskResult"/>, or <see cref="FailedTaskResult"/>).
-    /// </para>
-    /// <para>
-    /// Setting <see cref="McpServerOptions.TaskStore"/> is the recommended way to wire all three
-    /// task lifecycle handlers (<see cref="GetTaskHandler"/>, <see cref="UpdateTaskHandler"/>,
-    /// and <see cref="CancelTaskHandler"/>) from a single source while still allowing explicit
-    /// handlers to override any slot. If <see cref="CallToolWithTaskHandler"/> can return a
-    /// <see cref="CreateTaskResult"/> but no <see cref="GetTaskHandler"/> is configured (either
-    /// directly or via a task store), the server throws <see cref="InvalidOperationException"/>
-    /// when processing the request so misconfigured deployments fail loudly instead of producing
-    /// unpollable tasks.
-    /// </para>
-    /// </remarks>
-    public McpRequestHandler<GetTaskRequestParams, GetTaskResult>? GetTaskHandler { get; set; }
-
-    /// <summary>
-    /// Gets or sets the handler for <see cref="RequestMethods.TasksUpdate"/> requests.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This handler is invoked when a client provides input responses for a task
-    /// that is in the <see cref="McpTaskStatus.InputRequired"/> state. Responses keyed
-    /// by an identifier that does not currently correspond to an outstanding input request
-    /// (including responses for tasks in a terminal state) should be silently ignored per
-    /// SEP-2663.
-    /// </para>
-    /// <para>
-    /// Prefer configuring <see cref="McpServerOptions.TaskStore"/> instead of setting this
-    /// handler directly; the default implementation built from the store dispatches to
-    /// <see cref="IMcpTaskStore.ResolveInputRequestsAsync"/> and raises
-    /// <see cref="IMcpTaskStore.InputResponseReceived"/> to wake any pending
-    /// <see cref="McpServer.ElicitAsync(ModelContextProtocol.Protocol.ElicitRequestParams, CancellationToken)"/>
-    /// or <see cref="McpServer.SampleAsync(ModelContextProtocol.Protocol.CreateMessageRequestParams, CancellationToken)"/>
-    /// calls executing inside a task scope.
-    /// </para>
-    /// </remarks>
-    public McpRequestHandler<UpdateTaskRequestParams, UpdateTaskResult>? UpdateTaskHandler { get; set; }
-
-    /// <summary>
-    /// Gets or sets the handler for <see cref="RequestMethods.TasksCancel"/> requests.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This handler is invoked when a client requests cancellation of an in-progress task.
-    /// Per SEP-2663, cancellation is cooperative and eventually consistent: the handler should
-    /// always acknowledge the request with <see cref="CancelTaskResult"/>, even if the task is
-    /// unknown, already terminal, or cannot actually be stopped. Whether the task transitions
-    /// to <see cref="McpTaskStatus.Cancelled"/> is up to the implementation.
-    /// </para>
-    /// <para>
-    /// Prefer configuring <see cref="McpServerOptions.TaskStore"/> instead of setting this
-    /// handler directly; the default implementation built from the store calls
-    /// <see cref="IMcpTaskStore.SetCancelledAsync"/> and signals the per-task
-    /// <see cref="CancellationTokenSource"/> so the tool's <see cref="CancellationToken"/>
-    /// observes cancellation.
-    /// </para>
-    /// </remarks>
-    public McpRequestHandler<CancelTaskRequestParams, CancelTaskResult>? CancelTaskHandler { get; set; }
-
     /// <summary>Gets or sets notification handlers to register with the server.</summary>
     /// <remarks>
     /// <para>
diff --git a/src/ModelContextProtocol.Core/Server/McpServerImpl.cs b/src/ModelContextProtocol.Core/Server/McpServerImpl.cs
index f6eb0d60e..161316f18 100644
--- a/src/ModelContextProtocol.Core/Server/McpServerImpl.cs
+++ b/src/ModelContextProtocol.Core/Server/McpServerImpl.cs
@@ -28,7 +28,6 @@ internal sealed partial class McpServerImpl : McpServer
     private readonly RequestHandlers _requestHandlers;
     private readonly McpSessionHandler _sessionHandler;
     private readonly SemaphoreSlim _disposeLock = new(1, 1);
-    private readonly ConcurrentDictionary<string, CancellationTokenSource> _taskCancellationSources = new();
     private readonly ConcurrentDictionary<string, MrtrContinuation> _mrtrContinuations = new();
     private readonly ConcurrentDictionary<RequestId, MrtrContext> _mrtrContextsByRequestId = new();
 
@@ -64,7 +63,6 @@ internal sealed partial class McpServerImpl : McpServer
     /// <param name="serviceProvider">Optional service provider to use for dependency injection</param>
     /// <exception cref="McpException">The server was incorrectly configured.</exception>
     public McpServerImpl(ITransport transport, McpServerOptions options, ILoggerFactory? loggerFactory, IServiceProvider? serviceProvider)
-#pragma warning restore MCPEXP002
     {
         Throw.IfNull(transport);
         Throw.IfNull(options);
@@ -95,7 +93,7 @@ public McpServerImpl(ITransport transport, McpServerOptions options, ILoggerFact
         ConfigureCompletion(options);
         ConfigureSubscriptions(options);
         ConfigureExperimentalAndExtensions(options);
-        ConfigureTasks(options);
+        ConfigureRawRequestHandlers(options);
         ConfigureMrtr();
 
         // Register any notification handlers that were provided.
@@ -312,13 +310,6 @@ public override async ValueTask DisposeAsync()
 
         _disposed = true;
 
-        foreach (var kvp in _taskCancellationSources)
-        {
-            kvp.Value.Cancel();
-            kvp.Value.Dispose();
-        }
-        _taskCancellationSources.Clear();
-
         // Dispose the session handler - cancels message processing and waits for all
         // in-flight request handlers (including retries in AwaitMrtrHandlerAsync) to complete.
         // After this returns, no new requests can be processed and no new MRTR continuations
@@ -754,110 +745,56 @@ private void ConfigureCompletion(McpServerOptions options)
         return result;
     }
 
-    private void ConfigureTasks(McpServerOptions options)
+    private void ConfigureRawRequestHandlers(McpServerOptions options)
     {
-        var getTaskHandler = options.Handlers.GetTaskHandler;
-        var updateTaskHandler = options.Handlers.UpdateTaskHandler;
-        var cancelTaskHandler = options.Handlers.CancelTaskHandler;
-        var taskStore = options.TaskStore;
-
-        // If a task store is provided, wire up handlers from it for any that aren't explicitly set.
-        if (taskStore is not null)
+        if (options.RawRequestHandlerConfigurators is not { Count: > 0 } configurators)
         {
-            getTaskHandler ??= async (request, cancellationToken) =>
-            {
-                var info = await taskStore.GetTaskAsync(request.Params!.TaskId, cancellationToken).ConfigureAwait(false);
-                return info is null
-                    ? throw new McpProtocolException($"Unknown task: '{request.Params.TaskId}'", McpErrorCode.InvalidParams)
-                    : ToGetTaskResult(info);
-            };
-
-            updateTaskHandler ??= async (request, cancellationToken) =>
-            {
-                var inputResponses = request.Params!.InputResponses ?? new Dictionary<string, InputResponse>();
-                await taskStore.ResolveInputRequestsAsync(request.Params.TaskId, inputResponses, cancellationToken).ConfigureAwait(false);
-
-                return new UpdateTaskResult();
-            };
-
-            cancelTaskHandler ??= async (request, cancellationToken) =>
-            {
-                // Idempotent ack per SEP-2663: always return CancelTaskResult regardless of whether
-                // the task was known/cancellable. The store's SetCancelledAsync no-ops for unknown
-                // or already-terminal tasks; we still surface a success response to the client.
-                await taskStore.SetCancelledAsync(request.Params!.TaskId, cancellationToken).ConfigureAwait(false);
-
-                // Signal the task's CancellationTokenSource if one exists. Whichever side
-                // (this handler or the background runner's finally block) wins TryRemove owns disposal,
-                // which prevents the runner from observing ObjectDisposedException through cts.Token.
-                if (_taskCancellationSources.TryRemove(request.Params.TaskId, out var cts))
-                {
-                    cts.Cancel();
-                    cts.Dispose();
-                }
-
-                return new CancelTaskResult();
-            };
+            return;
         }
 
-        if (getTaskHandler is null && updateTaskHandler is null && cancelTaskHandler is null)
+        var registry = new RawHandlerRegistry(this);
+        foreach (var configurator in configurators)
         {
-            return;
+            configurator(registry);
         }
+    }
 
-        getTaskHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown task: '{request.Params?.TaskId}'", McpErrorCode.InvalidParams));
-        updateTaskHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown task: '{request.Params?.TaskId}'", McpErrorCode.InvalidParams));
-        cancelTaskHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown task: '{request.Params?.TaskId}'", McpErrorCode.InvalidParams));
-
-        // The tasks/* methods do not exist before the 2026-07-28 revision (SEP-2663). Reject them with
-        // MethodNotFound when the request was negotiated under a legacy protocol version. The handlers
-        // stay registered so a dual-era server still serves them for 2026-07-28 requests.
-        getTaskHandler = GateTaskMethodToJuly2026OrLaterProtocol(getTaskHandler, RequestMethods.TasksGet);
-        updateTaskHandler = GateTaskMethodToJuly2026OrLaterProtocol(updateTaskHandler, RequestMethods.TasksUpdate);
-        cancelTaskHandler = GateTaskMethodToJuly2026OrLaterProtocol(cancelTaskHandler, RequestMethods.TasksCancel);
-
-        // Advertise tasks extension in server capabilities.
-        ServerCapabilities.Extensions ??= new Dictionary<string, object>();
-        ServerCapabilities.Extensions[McpExtensions.Tasks] = new JsonObject();
+    /// <summary>
+    /// Adapts the internal <see cref="RequestHandlers"/> dictionary to the public
+    /// <see cref="IMcpServerRawHandlerRegistry"/> seam used by bolt-on extensions.
+    /// </summary>
+    private sealed class RawHandlerRegistry(McpServerImpl server) : IMcpServerRawHandlerRegistry
+    {
+        public McpServer Server => server;
 
-        SetHandler(
-            RequestMethods.TasksGet,
-            getTaskHandler,
-            McpJsonUtilities.JsonContext.Default.GetTaskRequestParams,
-            McpJsonUtilities.JsonContext.Default.GetTaskResult);
+        public bool ContainsHandler(string method) => server._requestHandlers.ContainsKey(method);
 
-        SetHandler(
-            RequestMethods.TasksUpdate,
-            updateTaskHandler,
-            McpJsonUtilities.JsonContext.Default.UpdateTaskRequestParams,
-            McpJsonUtilities.JsonContext.Default.UpdateTaskResult);
+        public void SetHandler(string method, McpRawRequestHandler handler)
+        {
+            Throw.IfNull(method);
+            Throw.IfNull(handler);
 
-        SetHandler(
-            RequestMethods.TasksCancel,
-            cancelTaskHandler,
-            McpJsonUtilities.JsonContext.Default.CancelTaskRequestParams,
-            McpJsonUtilities.JsonContext.Default.CancelTaskResult);
-    }
+            server._requestHandlers[method] = (request, cancellationToken) => handler(request, cancellationToken).AsTask();
+        }
 
-    /// <summary>
-    /// Wraps a tasks/* request handler so it throws <see cref="McpErrorCode.MethodNotFound"/> unless the
-    /// request was negotiated under the 2026-07-28 or later revision. The tasks extension (SEP-2663) only
-    /// interoperates on the 2026-07-28 revision, and these methods don't exist on older peers.
-    /// </summary>
-    private McpRequestHandler<TParams, TResult> GateTaskMethodToJuly2026OrLaterProtocol<TParams, TResult>(
-        McpRequestHandler<TParams, TResult> inner, string method)
-        => (request, cancellationToken) =>
+        public bool TryWrapHandler(string method, Func<McpRawRequestHandler, McpRawRequestHandler> wrap)
         {
-            if (!IsJuly2026OrLaterProtocolRequest(request.JsonRpcRequest))
+            Throw.IfNull(method);
+            Throw.IfNull(wrap);
+
+            if (!server._requestHandlers.TryGetValue(method, out var existing))
             {
-                throw new McpProtocolException(
-                    $"The method '{method}' requires a newer protocol revision that supports tasks; " +
-                    $"the negotiated protocol version is '{NegotiatedProtocolVersion ?? "(none)"}'.",
-                    McpErrorCode.MethodNotFound);
+                return false;
             }
 
-            return inner(request, cancellationToken);
-        };
+            McpRawRequestHandler inner = (request, cancellationToken) => new ValueTask<JsonNode?>(existing(request, cancellationToken));
+            var wrapped = wrap(inner);
+            server._requestHandlers[method] = (request, cancellationToken) => wrapped(request, cancellationToken).AsTask();
+            return true;
+        }
+
+        public bool IsDraftProtocolRequest(JsonRpcRequest request) => server.IsJuly2026OrLaterProtocolRequest(request);
+    }
 
     private void ConfigureExperimentalAndExtensions(McpServerOptions options)
     {
@@ -1134,11 +1071,10 @@ private void ConfigureTools(McpServerOptions options)
     {
         var listToolsHandler = options.Handlers.ListToolsHandler;
         var callToolHandler = options.Handlers.CallToolHandler;
-        var callToolWithTaskHandler = options.Handlers.CallToolWithTaskHandler;
         var tools = options.ToolCollection;
         var toolsCapability = options.Capabilities?.Tools;
 
-        if (listToolsHandler is null && callToolHandler is null && callToolWithTaskHandler is null && tools is null &&
+        if (listToolsHandler is null && callToolHandler is null && tools is null &&
             toolsCapability is null)
         {
             return;
@@ -1150,18 +1086,6 @@ private void ConfigureTools(McpServerOptions options)
         var listChanged = toolsCapability?.ListChanged;
 
         var callToolFilters = options.Filters.Request.CallToolFilters;
-        var callToolWithTaskFilters = options.Filters.Request.CallToolWithTaskFilters;
-
-        // Validate: cannot mix non-task filters/handler with task filters/handler.
-        bool hasNonTaskPath = callToolHandler is not null || callToolFilters.Count > 0;
-        bool hasTaskPath = callToolWithTaskHandler is not null || callToolWithTaskFilters.Count > 0;
-
-        if (hasNonTaskPath && hasTaskPath)
-        {
-            throw new InvalidOperationException(
-                $"Cannot mix non-task ({nameof(McpServerHandlers.CallToolHandler)}/{nameof(McpRequestFilters.CallToolFilters)}) " +
-                $"with task-based ({nameof(McpServerHandlers.CallToolWithTaskHandler)}/{nameof(McpRequestFilters.CallToolWithTaskFilters)}). Use one style or the other.");
-        }
 
         // Handle tools provided via DI by augmenting the list handler.
         if (tools is not null)
@@ -1202,159 +1126,26 @@ await originalListToolsHandler(request, cancellationToken).ConfigureAwait(false)
 
         listToolsHandler = BuildFilterPipeline(listToolsHandler, options.Filters.Request.ListToolsFilters);
 
-        // Build the unified task-augmented handler from one of the two paths.
-        if (hasTaskPath)
-        {
-            // Case 2: task filter + task handler
-            callToolWithTaskHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown tool: '{request.Params?.Name}'", McpErrorCode.InvalidParams));
-
-            // Augment with DI tools.
-            if (tools is not null)
-            {
-                var originalHandler = callToolWithTaskHandler;
-                callToolWithTaskHandler = (request, cancellationToken) =>
-                {
-                    if (request.MatchedPrimitive is McpServerTool tool)
-                    {
-                        return InvokeToolAsTask(tool, request, cancellationToken);
-                    }
-
-                    return originalHandler(request, cancellationToken);
-                };
-            }
-
-            callToolWithTaskHandler = BuildFilterPipeline(callToolWithTaskHandler, callToolWithTaskFilters, BuildInitialTaskToolFilter(tools));
-        }
-        else
-        {
-            // Case 1: non-task filter + non-task handler → apply filters, then convert to task-based
-            callToolHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown tool: '{request.Params?.Name}'", McpErrorCode.InvalidParams));
-
-            // Augment with DI tools.
-            if (tools is not null)
-            {
-                var originalHandler = callToolHandler;
-                callToolHandler = (request, cancellationToken) =>
-                {
-                    if (request.MatchedPrimitive is McpServerTool tool)
-                    {
-                        return tool.InvokeAsync(request, cancellationToken);
-                    }
-
-                    return originalHandler(request, cancellationToken);
-                };
-            }
-
-            callToolHandler = BuildFilterPipeline(callToolHandler, callToolFilters, BuildInitialCallToolFilter(tools));
-
-            // Convert to task-based.
-            var finalCallToolHandler = callToolHandler;
-            callToolWithTaskHandler = async (request, cancellationToken) =>
-                await finalCallToolHandler(request, cancellationToken).ConfigureAwait(false);
-        }
+        // Build the call-tool handler: dispatch to DI tools, then apply filters.
+        callToolHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown tool: '{request.Params?.Name}'", McpErrorCode.InvalidParams));
 
-        // If a task store is configured, wrap so that when the client signals task support
-        // the tool execution is offloaded to the background via the store.
-        if (options.TaskStore is { } taskStore)
+        // Augment with DI tools.
+        if (tools is not null)
         {
-            var innerTaskHandler = callToolWithTaskHandler;
-            callToolWithTaskHandler = async (request, cancellationToken) =>
+            var originalHandler = callToolHandler;
+            callToolHandler = (request, cancellationToken) =>
             {
-                // The SEP-2663 Tasks extension requires the 2026-07-28 or later revision: the task wire shapes we ship do not
-                // interoperate with legacy (<= 2025-11-25) peers. Only materialize a task when the
-                // request was negotiated under the 2026-07-28 or later revision AND the client opted in; otherwise
-                // run the inner handler and return the direct result (best-effort downgrade, which also
-                // defends against a non-conformant legacy client that forges the opt-in envelope).
-                if (IsJuly2026OrLaterProtocolRequest(request.JsonRpcRequest) && HasTaskExtensionOptIn(request.Params?.Meta))
+                if (request.MatchedPrimitive is McpServerTool tool)
                 {
-                    var taskInfo = await taskStore.CreateTaskAsync(cancellationToken).ConfigureAwait(false);
-                    var taskId = taskInfo.TaskId;
-
-                    var cts = new CancellationTokenSource();
-                    _taskCancellationSources[taskId] = cts;
-
-                    // Capture the token synchronously before Task.Run dispatches the work.
-                    // The cancel handler may race with the background runner: whichever side wins
-                    // the TryRemove call owns disposal. If we accessed cts.Token from inside the
-                    // lambda after the handler had already disposed cts, we'd hit ObjectDisposedException.
-                    var taskCancellationToken = cts.Token;
-
-                    _ = Task.Run(async () =>
-                    {
-                        using (CreateMcpTaskScope(taskId, taskStore))
-                        {
-                            try
-                            {
-                                var augmented = await innerTaskHandler(request, taskCancellationToken).ConfigureAwait(false);
-                                if (augmented.IsTask)
-                                {
-                                    // The handler created its own task externally, but the client already holds
-                                    // the store's taskId from the synchronous return below — we can't redirect.
-                                    // Fail the store's task so the client sees a clear error instead of polling forever.
-                                    var error = new JsonRpcErrorDetail
-                                    {
-                                        Code = (int)McpErrorCode.InternalError,
-                                        Message = $"{nameof(McpServerOptions.TaskStore)} is configured and the {nameof(McpServerHandlers.CallToolWithTaskHandler)} returned IsTask = true. Use only one mechanism to create the task.",
-                                    };
-                                    var errorJson = JsonSerializer.SerializeToElement(error, McpJsonUtilities.JsonContext.Default.JsonRpcErrorDetail);
-                                    await taskStore.SetFailedAsync(taskId, errorJson).ConfigureAwait(false);
-                                    return;
-                                }
-
-                                var resultJson = JsonSerializer.SerializeToElement(augmented.Result!, McpJsonUtilities.JsonContext.Default.CallToolResult);
-                                await taskStore.SetCompletedAsync(taskId, resultJson).ConfigureAwait(false);
-                            }
-                            catch (OperationCanceledException) when (taskCancellationToken.IsCancellationRequested)
-                            {
-                                await taskStore.SetCancelledAsync(taskId, CancellationToken.None).ConfigureAwait(false);
-                            }
-                            catch (InputRequiredException)
-                            {
-                                // MRTR (input requests) cannot be composed with the task-store wrapper for
-                                // [McpServerTool] methods today: the task ID was already returned synchronously,
-                                // so we have no way to surface InputRequiredResult to the client retroactively.
-                                // Fail the task with a clear, actionable error instead of leaking the raw
-                                // InputRequiredException through the generic catch below.
-                                var error = new JsonRpcErrorDetail
-                                {
-                                    Code = (int)McpErrorCode.InvalidRequest,
-                                    Message = "MRTR (input requests) and tasks cannot be composed via [McpServerTool] yet; " +
-                                              $"use {nameof(McpServerHandlers.CallToolWithTaskHandler)} to manage the input-request loop manually within the task body.",
-                                };
-                                var errorJson = JsonSerializer.SerializeToElement(error, McpJsonUtilities.JsonContext.Default.JsonRpcErrorDetail);
-                                await taskStore.SetFailedAsync(taskId, errorJson).ConfigureAwait(false);
-                            }
-                            catch (Exception ex)
-                            {
-                                // SEP-2663 §186: failed.error MUST be a JSON-RPC error object {code, message, data?}.
-                                // McpProtocolException carries a JSON-RPC ErrorCode and is documented as safe to
-                                // propagate (Message + ErrorCode). For any other exception type, redact the message
-                                // and use InternalError (mirrors the redaction in BuildInitialCallToolFilter).
-                                var error = ex is McpProtocolException mcpEx
-                                    ? new JsonRpcErrorDetail { Code = (int)mcpEx.ErrorCode, Message = mcpEx.Message }
-                                    : new JsonRpcErrorDetail { Code = (int)McpErrorCode.InternalError, Message = "An error occurred while executing the task." };
-                                var errorJson = JsonSerializer.SerializeToElement(error, McpJsonUtilities.JsonContext.Default.JsonRpcErrorDetail);
-                                await taskStore.SetFailedAsync(taskId, errorJson).ConfigureAwait(false);
-                            }
-                            finally
-                            {
-                                // Only the side that wins TryRemove disposes cts. This prevents a
-                                // double-dispose race with the default tasks/cancel handler.
-                                if (_taskCancellationSources.TryRemove(taskId, out var registeredCts))
-                                {
-                                    registeredCts.Dispose();
-                                }
-                            }
-                        }
-                    }, CancellationToken.None);
-
-                    return ToCreateTaskResult(taskInfo);
+                    return tool.InvokeAsync(request, cancellationToken);
                 }
 
-                return await innerTaskHandler(request, cancellationToken).ConfigureAwait(false);
+                return originalHandler(request, cancellationToken);
             };
         }
 
+        callToolHandler = BuildFilterPipeline(callToolHandler, callToolFilters, BuildInitialCallToolFilter(tools));
+
         ServerCapabilities.Tools.ListChanged = listChanged;
 
         SetHandler(
@@ -1363,99 +1154,11 @@ await originalListToolsHandler(request, cancellationToken).ConfigureAwait(false)
             McpJsonUtilities.JsonContext.Default.ListToolsRequestParams,
             McpJsonUtilities.JsonContext.Default.ListToolsResult);
 
-        SetTaskAugmentedHandler(
+        SetHandler(
             RequestMethods.ToolsCall,
-            callToolWithTaskHandler,
+            callToolHandler,
             McpJsonUtilities.JsonContext.Default.CallToolRequestParams,
-            McpJsonUtilities.JsonContext.Default.CallToolResult,
-            McpJsonUtilities.JsonContext.Default.CreateTaskResult);
-    }
-
-    private static CreateTaskResult ToCreateTaskResult(McpTaskInfo info) => new()
-    {
-        TaskId = info.TaskId,
-        Status = info.Status,
-        CreatedAt = info.CreatedAt,
-        LastUpdatedAt = info.LastUpdatedAt,
-        TimeToLive = info.TimeToLive,
-        PollIntervalMs = info.PollIntervalMs,
-        StatusMessage = info.StatusMessage,
-        ResultType = "task",
-    };
-
-    private static GetTaskResult ToGetTaskResult(McpTaskInfo info) => info.Status switch
-    {
-        McpTaskStatus.Working => new WorkingTaskResult
-        {
-            TaskId = info.TaskId,
-            CreatedAt = info.CreatedAt,
-            LastUpdatedAt = info.LastUpdatedAt,
-            TimeToLive = info.TimeToLive,
-            PollIntervalMs = info.PollIntervalMs,
-            StatusMessage = info.StatusMessage,
-            ResultType = "complete",
-        },
-        McpTaskStatus.Completed => new CompletedTaskResult
-        {
-            TaskId = info.TaskId,
-            CreatedAt = info.CreatedAt,
-            LastUpdatedAt = info.LastUpdatedAt,
-            TimeToLive = info.TimeToLive,
-            PollIntervalMs = info.PollIntervalMs,
-            StatusMessage = info.StatusMessage,
-            Result = info.Result ?? throw new InvalidOperationException($"Task '{info.TaskId}' is completed but has no result."),
-            ResultType = "complete",
-        },
-        McpTaskStatus.Failed => new FailedTaskResult
-        {
-            TaskId = info.TaskId,
-            CreatedAt = info.CreatedAt,
-            LastUpdatedAt = info.LastUpdatedAt,
-            TimeToLive = info.TimeToLive,
-            PollIntervalMs = info.PollIntervalMs,
-            StatusMessage = info.StatusMessage,
-            Error = info.Error ?? throw new InvalidOperationException($"Task '{info.TaskId}' is failed but has no error."),
-            ResultType = "complete",
-        },
-        McpTaskStatus.Cancelled => new CancelledTaskResult
-        {
-            TaskId = info.TaskId,
-            CreatedAt = info.CreatedAt,
-            LastUpdatedAt = info.LastUpdatedAt,
-            TimeToLive = info.TimeToLive,
-            PollIntervalMs = info.PollIntervalMs,
-            StatusMessage = info.StatusMessage,
-            ResultType = "complete",
-        },
-        McpTaskStatus.InputRequired => new InputRequiredTaskResult
-        {
-            TaskId = info.TaskId,
-            CreatedAt = info.CreatedAt,
-            LastUpdatedAt = info.LastUpdatedAt,
-            TimeToLive = info.TimeToLive,
-            PollIntervalMs = info.PollIntervalMs,
-            StatusMessage = info.StatusMessage,
-            // McpTaskInfo.InputRequests is IReadOnlyDictionary (covers immutable store
-            // implementations like InMemoryMcpTaskStore's ImmutableDictionary), while the wire
-            // DTO uses IDictionary like every other Protocol type. Most concrete stores back
-            // their dictionaries with a type that implements both interfaces (Dictionary,
-            // ImmutableDictionary, ConcurrentDictionary), so the cast usually succeeds and we
-            // only allocate a copy as a fallback.
-            InputRequests = info.InputRequests is IDictionary<string, InputRequest> dict
-                ? dict
-                : info.InputRequests?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)
-                    ?? new Dictionary<string, InputRequest>(),
-            ResultType = "complete",
-        },
-        _ => throw new InvalidOperationException($"Unknown task status: {info.Status}"),
-    };
-
-    private static async ValueTask<ResultOrCreatedTask<CallToolResult>> InvokeToolAsTask(
-        McpServerTool tool,
-        RequestContext<CallToolRequestParams> request,
-        CancellationToken cancellationToken)
-    {
-        return await tool.InvokeAsync(request, cancellationToken).ConfigureAwait(false);
+            McpJsonUtilities.JsonContext.Default.CallToolResult);
     }
 
     private McpRequestFilter<CallToolRequestParams, CallToolResult> BuildInitialCallToolFilter(
@@ -1501,53 +1204,6 @@ private McpRequestFilter<CallToolRequestParams, CallToolResult> BuildInitialCall
             }
         };
 
-    private McpRequestFilter<CallToolRequestParams, ResultOrCreatedTask<CallToolResult>> BuildInitialTaskToolFilter(
-        McpServerPrimitiveCollection<McpServerTool>? tools) => handler =>
-        async (request, cancellationToken) =>
-        {
-            if (request.Params?.Name is { } toolName && tools is not null &&
-                tools.TryGetPrimitive(toolName, out var tool))
-            {
-                request.MatchedPrimitive = tool;
-            }
-
-            try
-            {
-                var result = await handler(request, cancellationToken).ConfigureAwait(false);
-                if (!result.IsTask)
-                {
-                    ToolCallCompleted(request.Params?.Name ?? string.Empty, result.Result!.IsError is true);
-                }
-
-                return result;
-            }
-            catch (Exception e)
-            {
-                // Skip logging for InputRequiredException - it's normal MRTR control flow,
-                // not an error (tools throw it to signal an InputRequiredResult).
-                if (!(e is OperationCanceledException && cancellationToken.IsCancellationRequested) && e is not InputRequiredException)
-                {
-                    ToolCallError(request.Params?.Name ?? string.Empty, e);
-                }
-
-                if ((e is OperationCanceledException && cancellationToken.IsCancellationRequested) || e is McpProtocolException || e is InputRequiredException)
-                {
-                    throw;
-                }
-
-                return new CallToolResult
-                {
-                    IsError = true,
-                    Content = [new TextContentBlock
-                    {
-                        Text = e is McpException ?
-                            $"An error occurred invoking '{request.Params?.Name}': {e.Message}" :
-                            $"An error occurred invoking '{request.Params?.Name}'.",
-                    }],
-                };
-            }
-        };
-
     private void ConfigureLogging(McpServerOptions options)
     {
         // We don't require that the handler be provided, as we always store the provided log level to the server.
@@ -1670,20 +1326,6 @@ private void SetHandler<TParams, TResult>(
             requestTypeInfo, responseTypeInfo);
     }
 
-    private void SetTaskAugmentedHandler<TParams, TResult>(
-        string method,
-        McpRequestHandler<TParams, ResultOrCreatedTask<TResult>> handler,
-        JsonTypeInfo<TParams> requestTypeInfo,
-        JsonTypeInfo<TResult> responseTypeInfo,
-        JsonTypeInfo<CreateTaskResult> taskResultTypeInfo)
-        where TResult : Result
-    {
-        _requestHandlers.SetTaskAugmented(method,
-            (request, jsonRpcRequest, cancellationToken) =>
-                InvokeHandlerAsync(handler, request, jsonRpcRequest, cancellationToken),
-            requestTypeInfo, responseTypeInfo, taskResultTypeInfo);
-    }
-
     private static McpRequestHandler<TParams, TResult> BuildFilterPipeline<TParams, TResult>(
         McpRequestHandler<TParams, TResult> baseHandler,
         IList<McpRequestFilter<TParams, TResult>> filters,
@@ -1704,15 +1346,6 @@ private static McpRequestHandler<TParams, TResult> BuildFilterPipeline<TParams,
         return current;
     }
 
-    // Per SEP-2663 §51, the client opts in to the tasks extension on a per-request basis
-    // via the SEP-2575 capabilities envelope:
-    //   _meta/io.modelcontextprotocol/clientCapabilities/extensions/io.modelcontextprotocol/tasks = {}
-    private static bool HasTaskExtensionOptIn(JsonObject? meta) =>
-        meta is not null &&
-        meta[MetaKeys.ClientCapabilities] is JsonObject caps &&
-        caps["extensions"] is JsonObject exts &&
-        exts.ContainsKey(McpExtensions.Tasks);
-
     private JsonRpcMessageFilter BuildMessageFilterPipeline(IList<McpMessageFilter> filters)
     {
         if (filters.Count == 0)
diff --git a/src/ModelContextProtocol.Core/Server/McpServerOptions.cs b/src/ModelContextProtocol.Core/Server/McpServerOptions.cs
index eb99913d5..157d9cbf9 100644
--- a/src/ModelContextProtocol.Core/Server/McpServerOptions.cs
+++ b/src/ModelContextProtocol.Core/Server/McpServerOptions.cs
@@ -191,17 +191,14 @@ public McpServerFilters Filters
     public int MaxSamplingOutputTokens { get; set; } = 1000;
 
     /// <summary>
-    /// Gets or sets the task store for managing asynchronous task executions.
+    /// Gets or sets a list of configurators that register or wrap low-level raw request handlers
+    /// after the strongly-typed handlers have been configured.
     /// </summary>
     /// <remarks>
-    /// <para>
-    /// When set, the server automatically enables the <c>io.modelcontextprotocol/tasks</c> extension
-    /// and wires up <c>tasks/get</c>, <c>tasks/update</c>, and <c>tasks/cancel</c> handlers backed by this store.
-    /// Tool executions from clients that signal task support will be wrapped in tasks via the store.
-    /// </para>
-    /// <para>
-    /// If explicit task handlers are also set on <see cref="Handlers"/>, the explicit handlers take precedence.
-    /// </para>
+    /// This is an SDK extensibility hook intended for bolt-on packages (such as the MCP Tasks extension)
+    /// that need to register new request methods or wrap existing handlers. Each configurator receives an
+    /// <see cref="IMcpServerRawHandlerRegistry"/> for the server being constructed.
     /// </remarks>
-    public IMcpTaskStore? TaskStore { get; set; }
+    [Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)]
+    public IList<Action<IMcpServerRawHandlerRegistry>>? RawRequestHandlerConfigurators { get; set; }
 }
diff --git a/src/ModelContextProtocol.Core/Server/McpTaskExecutionContext.cs b/src/ModelContextProtocol.Core/Server/McpTaskExecutionContext.cs
deleted file mode 100644
index 749f36517..000000000
--- a/src/ModelContextProtocol.Core/Server/McpTaskExecutionContext.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-namespace ModelContextProtocol.Server;
-
-/// <summary>
-/// Provides ambient context when a tool is executing as a background task.
-/// When established, calls to <see cref="McpServer.ElicitAsync(ModelContextProtocol.Protocol.ElicitRequestParams, CancellationToken)"/>,
-/// <see cref="McpServer.SampleAsync(ModelContextProtocol.Protocol.CreateMessageRequestParams, CancellationToken)"/>,
-/// and <see cref="McpServer.RequestRootsAsync(ModelContextProtocol.Protocol.ListRootsRequestParams, CancellationToken)"/>
-/// are redirected through the task store as input requests rather than sent directly to the client.
-/// </summary>
-internal sealed class McpTaskExecutionContext
-{
-    internal static readonly AsyncLocal<McpTaskExecutionContext?> Current = new();
-
-    public required string TaskId { get; init; }
-    public required IMcpTaskStore Store { get; init; }
-
-    internal sealed class Scope(McpTaskExecutionContext? previous) : IDisposable
-    {
-        public void Dispose() => Current.Value = previous;
-    }
-}
diff --git a/src/ModelContextProtocol.Extensions.Tasks/Client/McpClientTasksExtensions.cs b/src/ModelContextProtocol.Extensions.Tasks/Client/McpClientTasksExtensions.cs
new file mode 100644
index 000000000..4729a5c8a
--- /dev/null
+++ b/src/ModelContextProtocol.Extensions.Tasks/Client/McpClientTasksExtensions.cs
@@ -0,0 +1,410 @@
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Extensions.Tasks;
+
+/// <summary>
+/// Provides extension methods that add MCP Tasks extension (SEP-2663) support to an MCP client.
+/// </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 requires the
+/// <c>2026-07-28</c> or later protocol revision.
+/// </remarks>
+public static class McpClientTasksExtensions
+{
+    /// <summary>The default number of consecutive stuck polls tolerated before a task is abandoned.</summary>
+    public const int DefaultMaxConsecutiveStuckPolls = 60;
+
+    /// <summary>
+    /// Invokes a tool on the server with task extension support, transparently polling to completion.
+    /// </summary>
+    /// <param name="client">The client to invoke the tool on.</param>
+    /// <param name="requestParams">The request parameters to send in the request.</param>
+    /// <param name="maxConsecutiveStuckPolls">
+    /// The maximum number of consecutive polls in which the task remains in <see cref="McpTaskStatus.InputRequired"/>
+    /// without publishing new input requests before the task is abandoned. Must be positive.
+    /// </param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>The result of the tool invocation.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="client"/> or <paramref name="requestParams"/> is <see langword="null"/>.</exception>
+    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
+    /// <remarks>
+    /// This method includes the <c>io.modelcontextprotocol/tasks</c> extension capability in the request
+    /// metadata. If the server returns a task handle, this method transparently polls <c>tasks/get</c> until
+    /// the task completes, fails, or is cancelled. Use <see cref="CallToolRawAsync"/> to disable polling.
+    /// </remarks>
+    public static async ValueTask<CallToolResult> CallToolAsTaskAsync(
+        this McpClient client,
+        CallToolRequestParams requestParams,
+        int maxConsecutiveStuckPolls = DefaultMaxConsecutiveStuckPolls,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        if (requestParams is null) throw new ArgumentNullException(nameof(requestParams));
+        if (maxConsecutiveStuckPolls <= 0) throw new ArgumentOutOfRangeException(nameof(maxConsecutiveStuckPolls));
+
+        var augmented = await client.CallToolRawAsync(requestParams, cancellationToken).ConfigureAwait(false);
+
+        if (!augmented.IsTask)
+        {
+            return augmented.Result!;
+        }
+
+        return await client.PollTaskToCompletionAsync(augmented.TaskCreated!, maxConsecutiveStuckPolls, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Invokes a tool on the server with task extension support, returning the raw response without polling.
+    /// </summary>
+    /// <param name="client">The client to invoke the tool on.</param>
+    /// <param name="requestParams">The request parameters to send. The tasks extension capability is injected into the request metadata.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>A <see cref="ResultOrCreatedTask{TResult}"/> that is either an immediate result or a task handle.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="client"/> or <paramref name="requestParams"/> is <see langword="null"/>.</exception>
+    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
+    public static async ValueTask<ResultOrCreatedTask<CallToolResult>> CallToolRawAsync(
+        this McpClient client,
+        CallToolRequestParams requestParams,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        if (requestParams is null) throw new ArgumentNullException(nameof(requestParams));
+
+        var paramsWithMeta = new CallToolRequestParams
+        {
+            Name = requestParams.Name,
+            Arguments = requestParams.Arguments,
+            // The SEP-2663 Tasks extension is draft-only. On a legacy session, send a plain tools/call
+            // (no task capability envelope) so the server returns a direct CallToolResult.
+            Meta = client.IsDraftProtocol() ? GetMetaWithTaskCapability(requestParams.Meta) : requestParams.Meta,
+        };
+
+        JsonRpcRequest jsonRpcRequest = new()
+        {
+            Method = RequestMethods.ToolsCall,
+            Params = JsonSerializer.SerializeToNode(paramsWithMeta, TasksJsonContext.Default.CallToolRequestParams),
+        };
+
+        JsonRpcResponse response = await client.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false);
+
+        // Discriminate based on resultType field.
+        if (response.Result is JsonObject resultObj &&
+            resultObj.TryGetPropertyValue("resultType", out var resultTypeNode) &&
+            resultTypeNode?.GetValue<string>() == "task")
+        {
+            var taskCreated = resultObj.Deserialize(TasksJsonContext.Default.CreateTaskResult)
+                ?? throw new JsonException("Failed to deserialize CreateTaskResult from response.");
+            return new ResultOrCreatedTask<CallToolResult>(taskCreated);
+        }
+
+        var callToolResult = JsonSerializer.Deserialize(response.Result, TasksJsonContext.Default.CallToolResult)
+            ?? throw new JsonException("Failed to deserialize CallToolResult from response.");
+        return new ResultOrCreatedTask<CallToolResult>(callToolResult);
+    }
+
+    /// <summary>
+    /// Polls a task until it reaches a terminal state and returns the final <see cref="CallToolResult"/>.
+    /// </summary>
+    /// <param name="client">The client polling the task.</param>
+    /// <param name="taskCreated">The task handle returned by the server.</param>
+    /// <param name="maxConsecutiveStuckPolls">
+    /// The maximum number of consecutive polls in which the task remains in <see cref="McpTaskStatus.InputRequired"/>
+    /// without publishing new input requests before the task is abandoned. Must be positive.
+    /// </param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>The final result of the completed task.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="client"/> or <paramref name="taskCreated"/> is <see langword="null"/>.</exception>
+    /// <exception cref="McpException">The task failed or remained stuck.</exception>
+    /// <exception cref="OperationCanceledException">The task was cancelled by the server.</exception>
+    public static async ValueTask<CallToolResult> PollTaskToCompletionAsync(
+        this McpClient client,
+        CreateTaskResult taskCreated,
+        int maxConsecutiveStuckPolls = DefaultMaxConsecutiveStuckPolls,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        if (taskCreated is null) throw new ArgumentNullException(nameof(taskCreated));
+        if (maxConsecutiveStuckPolls <= 0) throw new ArgumentOutOfRangeException(nameof(maxConsecutiveStuckPolls));
+
+        string taskId = taskCreated.TaskId;
+        long pollIntervalMs = taskCreated.PollIntervalMs ?? 1000;
+        HashSet<string>? resolvedRequestKeys = null;
+        bool isFirstPoll = true;
+        int consecutiveStuckPolls = 0;
+
+        while (true)
+        {
+            // Skip the delay before the first poll: many tasks complete almost immediately.
+            if (!isFirstPoll)
+            {
+                await Task.Delay(TimeSpan.FromMilliseconds(pollIntervalMs), cancellationToken).ConfigureAwait(false);
+            }
+            isFirstPoll = false;
+
+            var taskResult = await client.GetTaskAsync(taskId, cancellationToken).ConfigureAwait(false);
+
+            if (taskResult.PollIntervalMs is { } newInterval)
+            {
+                pollIntervalMs = newInterval;
+            }
+
+            switch (taskResult)
+            {
+                case CompletedTaskResult completed:
+                    return JsonSerializer.Deserialize(completed.Result, TasksJsonContext.Default.CallToolResult)
+                        ?? throw new JsonException("Failed to deserialize CallToolResult from completed task.");
+
+                case FailedTaskResult failed:
+                    throw new McpException($"Task '{taskId}' failed: {failed.Error}");
+
+                case CancelledTaskResult:
+                    throw new OperationCanceledException($"Task '{taskId}' was cancelled by the server.");
+
+                case InputRequiredTaskResult inputRequired:
+                    var newRequests = new Dictionary<string, InputRequest>();
+                    if (inputRequired.InputRequests is { } incomingRequests)
+                    {
+                        foreach (var kvp in incomingRequests)
+                        {
+                            if (resolvedRequestKeys is null || !resolvedRequestKeys.Contains(kvp.Key))
+                            {
+                                newRequests[kvp.Key] = kvp.Value;
+                            }
+                        }
+                    }
+
+                    if (newRequests.Count > 0)
+                    {
+                        consecutiveStuckPolls = 0;
+
+                        IDictionary<string, InputResponse> inputResponses;
+                        try
+                        {
+                            inputResponses = await client.ResolveInputRequestsAsync(newRequests, cancellationToken).ConfigureAwait(false);
+                        }
+                        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+                        {
+                            throw;
+                        }
+                        catch
+                        {
+                            // The input handler failed. Best-effort cancel of the server-side task so it
+                            // doesn't stay stuck in InputRequired until TTL expires.
+                            try
+                            {
+                                await client.CancelTaskAsync(taskId, CancellationToken.None).ConfigureAwait(false);
+                            }
+                            catch
+                            {
+                                // Swallow secondary failures; we're already propagating the original exception.
+                            }
+
+                            throw;
+                        }
+
+                        await client.UpdateTaskAsync(new UpdateTaskRequestParams
+                        {
+                            TaskId = taskId,
+                            InputResponses = inputResponses,
+                        }, cancellationToken).ConfigureAwait(false);
+
+                        resolvedRequestKeys ??= new HashSet<string>(StringComparer.Ordinal);
+                        foreach (var key in inputResponses.Keys)
+                        {
+                            resolvedRequestKeys.Add(key);
+                        }
+                    }
+                    else if (++consecutiveStuckPolls >= maxConsecutiveStuckPolls)
+                    {
+                        try
+                        {
+                            await client.CancelTaskAsync(taskId, CancellationToken.None).ConfigureAwait(false);
+                        }
+                        catch
+                        {
+                            // Swallow secondary failures; we're already propagating an exception.
+                        }
+
+                        throw new McpException(
+                            $"Task '{taskId}' has remained in '{McpTaskStatus.InputRequired}' for {maxConsecutiveStuckPolls} consecutive polls " +
+                            "without publishing new input requests after all previously requested inputs were resolved.");
+                    }
+
+                    break;
+
+                case WorkingTaskResult:
+                    consecutiveStuckPolls = 0;
+                    break;
+
+                default:
+                    throw new McpException(
+                        $"Unexpected task result type '{taskResult.GetType().Name}' for task '{taskId}'.");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Retrieves the current state of a task from the server.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="taskId">The stable identifier of the task to retrieve.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>A <see cref="GetTaskResult"/> subtype representing the current task state.</returns>
+    public static ValueTask<GetTaskResult> GetTaskAsync(
+        this McpClient client,
+        string taskId,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        if (taskId is null) throw new ArgumentNullException(nameof(taskId));
+
+        return client.GetTaskAsync(new GetTaskRequestParams { TaskId = taskId }, cancellationToken);
+    }
+
+    /// <summary>
+    /// Retrieves the current state of a task from the server.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="requestParams">The request parameters to send in the request.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>A <see cref="GetTaskResult"/> subtype representing the current task state.</returns>
+    public static async ValueTask<GetTaskResult> GetTaskAsync(
+        this McpClient client,
+        GetTaskRequestParams requestParams,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        if (requestParams is null) throw new ArgumentNullException(nameof(requestParams));
+        ThrowIfTasksNotSupported(client, nameof(GetTaskAsync));
+
+        var response = await client.SendRequestAsync(
+            new JsonRpcRequest
+            {
+                Method = TaskMethods.Get,
+                Params = JsonSerializer.SerializeToNode(requestParams, TasksJsonContext.Default.GetTaskRequestParams),
+            },
+            cancellationToken).ConfigureAwait(false);
+
+        return JsonSerializer.Deserialize(response.Result, TasksJsonContext.Default.GetTaskResult)
+            ?? throw new JsonException("Failed to deserialize GetTaskResult from response.");
+    }
+
+    /// <summary>
+    /// Provides input responses to a task that is in the <see cref="McpTaskStatus.InputRequired"/> state.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="requestParams">The request parameters containing the task ID and input responses.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>The result acknowledging the update.</returns>
+    public static async ValueTask<UpdateTaskResult> UpdateTaskAsync(
+        this McpClient client,
+        UpdateTaskRequestParams requestParams,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        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 = paramsNode,
+            },
+            cancellationToken).ConfigureAwait(false);
+
+        return JsonSerializer.Deserialize(response.Result, TasksJsonContext.Default.UpdateTaskResult)
+            ?? throw new JsonException("Failed to deserialize UpdateTaskResult from response.");
+    }
+
+    /// <summary>
+    /// Requests cancellation of an in-progress task on the server.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="taskId">The stable identifier of the task to cancel.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>The result acknowledging the cancellation request.</returns>
+    public static ValueTask<CancelTaskResult> CancelTaskAsync(
+        this McpClient client,
+        string taskId,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        if (taskId is null) throw new ArgumentNullException(nameof(taskId));
+
+        return client.CancelTaskAsync(new CancelTaskRequestParams { TaskId = taskId }, cancellationToken);
+    }
+
+    /// <summary>
+    /// Requests cancellation of an in-progress task on the server.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="requestParams">The request parameters to send in the request.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>The result acknowledging the cancellation request.</returns>
+    public static async ValueTask<CancelTaskResult> CancelTaskAsync(
+        this McpClient client,
+        CancelTaskRequestParams requestParams,
+        CancellationToken cancellationToken = default)
+    {
+        if (client is null) throw new ArgumentNullException(nameof(client));
+        if (requestParams is null) throw new ArgumentNullException(nameof(requestParams));
+        ThrowIfTasksNotSupported(client, nameof(CancelTaskAsync));
+
+        var response = await client.SendRequestAsync(
+            new JsonRpcRequest
+            {
+                Method = TaskMethods.Cancel,
+                Params = JsonSerializer.SerializeToNode(requestParams, TasksJsonContext.Default.CancelTaskRequestParams),
+            },
+            cancellationToken).ConfigureAwait(false);
+
+        return JsonSerializer.Deserialize(response.Result, TasksJsonContext.Default.CancelTaskResult)
+            ?? throw new JsonException("Failed to deserialize CancelTaskResult from response.");
+    }
+
+    // Per SEP-2663 51, the per-request opt-in uses the SEP-2575 capabilities envelope:
+    //   _meta/io.modelcontextprotocol/clientCapabilities/extensions/io.modelcontextprotocol/tasks = {}
+    private static JsonObject GetMetaWithTaskCapability(JsonObject? existingMeta)
+    {
+        JsonObject meta = existingMeta is not null
+            ? (JsonObject)existingMeta.DeepClone()
+            : [];
+
+        if (meta[MetaKeys.ClientCapabilities] is not JsonObject capsRoot)
+        {
+            capsRoot = [];
+            meta[MetaKeys.ClientCapabilities] = capsRoot;
+        }
+
+        if (capsRoot["extensions"] is not JsonObject extensionsRoot)
+        {
+            extensionsRoot = [];
+            capsRoot["extensions"] = extensionsRoot;
+        }
+
+        extensionsRoot.TryAdd(McpExtensions.Tasks, new JsonObject());
+        return meta;
+    }
+
+    private static void ThrowIfTasksNotSupported(McpClient client, string operationName)
+    {
+        if (!client.IsDraftProtocol())
+        {
+            throw new InvalidOperationException(
+                $"'{operationName}' requires a newer protocol revision that supports tasks. " +
+                $"The negotiated protocol version is '{client.NegotiatedProtocolVersion ?? "(none)"}'.");
+        }
+    }
+}
diff --git a/src/ModelContextProtocol.Extensions.Tasks/McpTasksJsonUtilities.cs b/src/ModelContextProtocol.Extensions.Tasks/McpTasksJsonUtilities.cs
new file mode 100644
index 000000000..ac711cff9
--- /dev/null
+++ b/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;
+}
diff --git a/src/ModelContextProtocol.Extensions.Tasks/ModelContextProtocol.Extensions.Tasks.csproj b/src/ModelContextProtocol.Extensions.Tasks/ModelContextProtocol.Extensions.Tasks.csproj
new file mode 100644
index 000000000..29ad0e6a7
--- /dev/null
+++ b/src/ModelContextProtocol.Extensions.Tasks/ModelContextProtocol.Extensions.Tasks.csproj
@@ -0,0 +1,54 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net10.0;net9.0;net8.0;netstandard2.0</TargetFrameworks>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <IsPackable>true</IsPackable>
+    <PackageId>ModelContextProtocol.Extensions.Tasks</PackageId>
+    <Description>MCP Tasks extension for the .NET Model Context Protocol (MCP) SDK</Description>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <!-- Suppress the experimental MCP warnings for internal usage -->
+    <NoWarn>$(NoWarn);MCPEXP001;MCPEXP002;MCPEXP003;MCPEXP004</NoWarn>
+    <!-- New package with no published baseline yet -->
+    <EnablePackageValidation>false</EnablePackageValidation>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
+    <IsAotCompatible>true</IsAotCompatible>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <!-- CS0436: Allow ObsoleteAttribute to be redefined internally -->
+    <NoWarn>$(NoWarn);CS0436</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\Common\Experimentals.cs" Link="Experimentals.cs" />
+  </ItemGroup>
+
+  <!-- Exclude polyfills inherited from Directory.Build.props; include only the attribute polyfills these DTOs need. -->
+  <ItemGroup>
+    <Compile Remove="..\Common\Polyfills\**\*.cs" />
+    <Compile Include="..\Common\Polyfills\System\Diagnostics\CodeAnalysis\ExperimentalAttribute.cs"
+             Link="Polyfills\ExperimentalAttribute.cs" />
+    <Compile Include="..\Common\Polyfills\System\Diagnostics\CodeAnalysis\NullableAttributes.cs"
+             Link="Polyfills\NullableAttributes.cs" />
+    <Compile Include="..\Common\Polyfills\System\Diagnostics\CodeAnalysis\SetsRequiredMembersAttribute.cs"
+             Link="Polyfills\SetsRequiredMembersAttribute.cs" />
+    <Compile Include="..\Common\Polyfills\System\Runtime\CompilerServices\CompilerFeatureRequiredAttribute.cs"
+             Link="Polyfills\CompilerFeatureRequiredAttribute.cs" />
+    <Compile Include="..\Common\Polyfills\System\Runtime\CompilerServices\RequiredMemberAttribute.cs"
+             Link="Polyfills\RequiredMemberAttribute.cs" />
+    <Compile Include="..\Common\Polyfills\System\Runtime\CompilerServices\IsExternalInit.cs"
+             Link="Polyfills\IsExternalInit.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ModelContextProtocol\ModelContextProtocol.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\PACKAGE.md" Pack="true" PackagePath="\README.md" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/ModelContextProtocol.Core/Protocol/CancelTaskRequestParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskRequestParams.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/CancelTaskRequestParams.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskRequestParams.cs
diff --git a/src/ModelContextProtocol.Core/Protocol/CancelTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskResult.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/CancelTaskResult.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskResult.cs
diff --git a/src/ModelContextProtocol.Core/Protocol/CreateTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CreateTaskResult.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/CreateTaskResult.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/CreateTaskResult.cs
diff --git a/src/ModelContextProtocol.Core/Protocol/GetTaskRequestParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskRequestParams.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/GetTaskRequestParams.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskRequestParams.cs
diff --git a/src/ModelContextProtocol.Core/Protocol/GetTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskResult.cs
similarity index 98%
rename from src/ModelContextProtocol.Core/Protocol/GetTaskResult.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskResult.cs
index 3fea8cc6b..f7d294039 100644
--- a/src/ModelContextProtocol.Core/Protocol/GetTaskResult.cs
+++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskResult.cs
@@ -1,3 +1,4 @@
+using ModelContextProtocol.Extensions.Tasks;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -143,7 +144,7 @@ internal sealed class Converter : JsonConverter<GetTaskResult>
                         resultType = reader.GetString();
                         break;
                     case "_meta":
-                        meta = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo<JsonObject>());
+                        meta = JsonSerializer.Deserialize(ref reader, TasksJsonContext.Default.JsonObject);
                         break;
                     case "result":
                         result = JsonElement.ParseValue(ref reader);
@@ -169,7 +170,7 @@ internal sealed class Converter : JsonConverter<GetTaskResult>
                             }
                             string requestKey = reader.GetString()!;
                             reader.Read();
-                            var inputRequest = JsonSerializer.Deserialize(ref reader, McpJsonUtilities.JsonContext.Default.InputRequest)
+                            var inputRequest = JsonSerializer.Deserialize(ref reader, TasksJsonContext.Default.InputRequest)
                                 ?? throw new JsonException($"Failed to deserialize InputRequest for key '{requestKey}'.");
                             inputRequests[requestKey] = inputRequest;
                         }
@@ -265,7 +266,7 @@ public override void Write(Utf8JsonWriter writer, GetTaskResult value, JsonSeria
             if (value.Meta is not null)
             {
                 writer.WritePropertyName("_meta");
-                JsonSerializer.Serialize(writer, value.Meta, options.GetTypeInfo<JsonObject>());
+                JsonSerializer.Serialize(writer, value.Meta, TasksJsonContext.Default.JsonObject);
             }
 
             writer.WriteString("taskId", value.TaskId);
@@ -315,7 +316,7 @@ public override void Write(Utf8JsonWriter writer, GetTaskResult value, JsonSeria
                         foreach (var kvp in reqs)
                         {
                             writer.WritePropertyName(kvp.Key);
-                            JsonSerializer.Serialize(writer, kvp.Value, McpJsonUtilities.JsonContext.Default.InputRequest);
+                            JsonSerializer.Serialize(writer, kvp.Value, TasksJsonContext.Default.InputRequest);
                         }
                     }
                     writer.WriteEndObject();
diff --git a/src/ModelContextProtocol.Core/Protocol/McpExtensions.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/McpExtensions.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/McpExtensions.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/McpExtensions.cs
diff --git a/src/ModelContextProtocol.Core/Protocol/McpTaskStatus.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/McpTaskStatus.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/McpTaskStatus.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/McpTaskStatus.cs
diff --git a/src/ModelContextProtocol.Core/Protocol/ResultOrCreatedTask.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/ResultOrCreatedTask.cs
similarity index 94%
rename from src/ModelContextProtocol.Core/Protocol/ResultOrCreatedTask.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/ResultOrCreatedTask.cs
index 87b857470..4d703c930 100644
--- a/src/ModelContextProtocol.Core/Protocol/ResultOrCreatedTask.cs
+++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/ResultOrCreatedTask.cs
@@ -31,8 +31,7 @@ public class ResultOrCreatedTask<TResult> where TResult : Result
     /// <param name="result">The standard result returned by the server.</param>
     public ResultOrCreatedTask(TResult result)
     {
-        Throw.IfNull(result);
-        _result = result;
+        _result = result ?? throw new ArgumentNullException(nameof(result));
     }
 
     /// <summary>
@@ -41,8 +40,7 @@ public ResultOrCreatedTask(TResult result)
     /// <param name="taskCreated">The task creation result returned by the server.</param>
     public ResultOrCreatedTask(CreateTaskResult taskCreated)
     {
-        Throw.IfNull(taskCreated);
-        _taskCreated = taskCreated;
+        _taskCreated = taskCreated ?? throw new ArgumentNullException(nameof(taskCreated));
     }
 
     /// <summary>
diff --git a/src/ModelContextProtocol.Core/Protocol/TaskStatusNotificationParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/TaskStatusNotificationParams.cs
similarity index 98%
rename from src/ModelContextProtocol.Core/Protocol/TaskStatusNotificationParams.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/TaskStatusNotificationParams.cs
index 4e859a22c..13f96e058 100644
--- a/src/ModelContextProtocol.Core/Protocol/TaskStatusNotificationParams.cs
+++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/TaskStatusNotificationParams.cs
@@ -1,3 +1,4 @@
+using ModelContextProtocol.Extensions.Tasks;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -145,7 +146,7 @@ internal sealed class Converter : JsonConverter<TaskStatusNotificationParams>
                         pollIntervalMs = reader.GetInt64();
                         break;
                     case "_meta":
-                        meta = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo<JsonObject>());
+                        meta = JsonSerializer.Deserialize(ref reader, TasksJsonContext.Default.JsonObject);
                         break;
                     case "result":
                         result = JsonElement.ParseValue(ref reader);
@@ -171,7 +172,7 @@ internal sealed class Converter : JsonConverter<TaskStatusNotificationParams>
                             }
                             string requestKey = reader.GetString()!;
                             reader.Read();
-                            var inputRequest = JsonSerializer.Deserialize(ref reader, McpJsonUtilities.JsonContext.Default.InputRequest)
+                            var inputRequest = JsonSerializer.Deserialize(ref reader, TasksJsonContext.Default.InputRequest)
                                 ?? throw new JsonException($"Failed to deserialize InputRequest for key '{requestKey}'.");
                             inputRequests[requestKey] = inputRequest;
                         }
@@ -261,7 +262,7 @@ public override void Write(Utf8JsonWriter writer, TaskStatusNotificationParams v
             if (value.Meta is not null)
             {
                 writer.WritePropertyName("_meta");
-                JsonSerializer.Serialize(writer, value.Meta, options.GetTypeInfo<JsonObject>());
+                JsonSerializer.Serialize(writer, value.Meta, TasksJsonContext.Default.JsonObject);
             }
 
             writer.WriteString("taskId", value.TaskId);
@@ -311,7 +312,7 @@ public override void Write(Utf8JsonWriter writer, TaskStatusNotificationParams v
                         foreach (var kvp in reqs)
                         {
                             writer.WritePropertyName(kvp.Key);
-                            JsonSerializer.Serialize(writer, kvp.Value, McpJsonUtilities.JsonContext.Default.InputRequest);
+                            JsonSerializer.Serialize(writer, kvp.Value, TasksJsonContext.Default.InputRequest);
                         }
                     }
                     writer.WriteEndObject();
diff --git a/src/ModelContextProtocol.Core/Protocol/UpdateTaskRequestParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskRequestParams.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/UpdateTaskRequestParams.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskRequestParams.cs
diff --git a/src/ModelContextProtocol.Core/Protocol/UpdateTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskResult.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Protocol/UpdateTaskResult.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskResult.cs
diff --git a/src/ModelContextProtocol.Core/Server/IMcpTaskStore.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/IMcpTaskStore.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Server/IMcpTaskStore.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Server/IMcpTaskStore.cs
diff --git a/src/ModelContextProtocol.Core/Server/InMemoryMcpTaskStore.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/InMemoryMcpTaskStore.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Server/InMemoryMcpTaskStore.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Server/InMemoryMcpTaskStore.cs
diff --git a/src/ModelContextProtocol.Core/Server/InputResponseReceivedEventArgs.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/InputResponseReceivedEventArgs.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Server/InputResponseReceivedEventArgs.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Server/InputResponseReceivedEventArgs.cs
diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/McpServerTasksExtensions.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/McpServerTasksExtensions.cs
new file mode 100644
index 000000000..84151afb6
--- /dev/null
+++ b/src/ModelContextProtocol.Extensions.Tasks/Server/McpServerTasksExtensions.cs
@@ -0,0 +1,386 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+using System.Collections.Concurrent;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace ModelContextProtocol.Extensions.Tasks;
+
+/// <summary>
+/// Provides extension methods that add MCP Tasks extension (SEP-2663) support to an MCP server.
+/// </summary>
+/// <remarks>
+/// The Tasks extension lets a server offload long-running tool executions to the background and lets a
+/// 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>
+public static class McpServerTasksExtensions
+{
+    /// <summary>
+    /// Enables the MCP Tasks extension on the supplied <paramref name="options"/> using the given task store.
+    /// </summary>
+    /// <param name="options">The server options to configure.</param>
+    /// <param name="store">The task store that backs task state.</param>
+    /// <returns>The <paramref name="options"/> instance, for chaining.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="options"/> or <paramref name="store"/> is <see langword="null"/>.</exception>
+    public static McpServerOptions WithTasks(this McpServerOptions options, IMcpTaskStore store)
+    {
+        if (options is null) throw new ArgumentNullException(nameof(options));
+        if (store is null) throw new ArgumentNullException(nameof(store));
+
+        // Advertise the tasks extension in server capabilities.
+        options.Capabilities ??= new ServerCapabilities();
+        options.Capabilities.Extensions ??= new Dictionary<string, object>();
+        options.Capabilities.Extensions[McpExtensions.Tasks] = new JsonObject();
+
+        options.RawRequestHandlerConfigurators ??= new List<Action<IMcpServerRawHandlerRegistry>>();
+        options.RawRequestHandlerConfigurators.Add(registry => ConfigureTaskHandlers(registry, store));
+
+        return options;
+    }
+
+    /// <summary>
+    /// Enables the MCP Tasks extension on the server built by <paramref name="builder"/> using the given task store.
+    /// </summary>
+    /// <param name="builder">The server builder.</param>
+    /// <param name="store">The task store that backs task state.</param>
+    /// <returns>The <paramref name="builder"/> instance, for chaining.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="builder"/> or <paramref name="store"/> is <see langword="null"/>.</exception>
+    public static IMcpServerBuilder WithTasks(this IMcpServerBuilder builder, IMcpTaskStore store)
+    {
+        if (builder is null) throw new ArgumentNullException(nameof(builder));
+        if (store is null) throw new ArgumentNullException(nameof(store));
+
+        builder.Services.AddSingleton<IPostConfigureOptions<McpServerOptions>>(
+            new TasksPostConfigureOptions(store));
+        return builder;
+    }
+
+    /// <summary>
+    /// Sends a task status notification (<c>notifications/tasks/status</c>) to the connected client.
+    /// </summary>
+    /// <param name="server">The server sending the notification.</param>
+    /// <param name="notificationParams">The task status notification parameters to send.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>A task that represents the asynchronous send operation.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="server"/> or <paramref name="notificationParams"/> is <see langword="null"/>.</exception>
+    public static Task SendTaskStatusNotificationAsync(
+        this McpServer server,
+        TaskStatusNotificationParams notificationParams,
+        CancellationToken cancellationToken = default)
+    {
+        if (server is null) throw new ArgumentNullException(nameof(server));
+        if (notificationParams is null) throw new ArgumentNullException(nameof(notificationParams));
+
+        var paramsNode = JsonSerializer.SerializeToNode(notificationParams, TasksJsonContext.Default.TaskStatusNotificationParams);
+        return server.SendNotificationAsync(
+            TaskMethods.StatusNotification,
+            paramsNode,
+            McpJsonUtilities.DefaultOptions,
+            cancellationToken);
+    }
+
+    private sealed class TasksPostConfigureOptions(IMcpTaskStore store) : IPostConfigureOptions<McpServerOptions>
+    {
+        public void PostConfigure(string? name, McpServerOptions options) => options.WithTasks(store);
+    }
+
+    private static void ConfigureTaskHandlers(IMcpServerRawHandlerRegistry registry, IMcpTaskStore store)
+    {
+        // Per-task cancellation sources shared between the tools/call task wrapper and the tasks/cancel handler.
+        var cancellationSources = new ConcurrentDictionary<string, CancellationTokenSource>();
+
+        registry.SetHandler(TaskMethods.Get, async (request, cancellationToken) =>
+        {
+            EnsureDraft(registry, request, TaskMethods.Get);
+
+            var requestParams = Deserialize(request.Params, TasksJsonContext.Default.GetTaskRequestParams);
+            var info = await store.GetTaskAsync(requestParams.TaskId, cancellationToken).ConfigureAwait(false);
+            if (info is null)
+            {
+                throw new McpProtocolException($"Unknown task: '{requestParams.TaskId}'", McpErrorCode.InvalidParams);
+            }
+
+            return JsonSerializer.SerializeToNode(ToGetTaskResult(info), TasksJsonContext.Default.GetTaskResult);
+        });
+
+        registry.SetHandler(TaskMethods.Update, async (request, cancellationToken) =>
+        {
+            EnsureDraft(registry, request, TaskMethods.Update);
+
+            var requestParams = Deserialize(request.Params, TasksJsonContext.Default.UpdateTaskRequestParams);
+
+            // 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);
+        });
+
+        registry.SetHandler(TaskMethods.Cancel, async (request, cancellationToken) =>
+        {
+            EnsureDraft(registry, request, TaskMethods.Cancel);
+
+            var requestParams = Deserialize(request.Params, TasksJsonContext.Default.CancelTaskRequestParams);
+
+            // Idempotent ack per SEP-2663: always return CancelTaskResult regardless of whether the task
+            // was known/cancellable. The store's SetCancelledAsync no-ops for unknown or terminal tasks.
+            await store.SetCancelledAsync(requestParams.TaskId, cancellationToken).ConfigureAwait(false);
+
+            // Signal the task's CancellationTokenSource if one exists. Whichever side (this handler or the
+            // background runner's finally block) wins TryRemove owns disposal.
+            if (cancellationSources.TryRemove(requestParams.TaskId, out var cts))
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
+
+            return JsonSerializer.SerializeToNode(new CancelTaskResult(), TasksJsonContext.Default.CancelTaskResult);
+        });
+
+        // Wrap tools/call so that when the client opts in (and the session negotiated draft), the tool
+        // execution is offloaded to the background via the store.
+        registry.TryWrapHandler(RequestMethods.ToolsCall, inner => async (request, cancellationToken) =>
+        {
+            var callToolParams = request.Params is null
+                ? null
+                : JsonSerializer.Deserialize(request.Params, TasksJsonContext.Default.CallToolRequestParams);
+
+            // The SEP-2663 Tasks extension is draft-only. Only materialize a task when the request was
+            // negotiated under the draft revision AND the client opted in; otherwise run the inner handler
+            // and return the direct result.
+            if (registry.IsDraftProtocolRequest(request) && HasTaskExtensionOptIn(callToolParams?.Meta))
+            {
+                var taskInfo = await store.CreateTaskAsync(cancellationToken).ConfigureAwait(false);
+                var taskId = taskInfo.TaskId;
+
+                var cts = new CancellationTokenSource();
+                cancellationSources[taskId] = cts;
+
+                // Capture the token synchronously before Task.Run dispatches the work. The cancel handler
+                // may race with the background runner: whichever side wins TryRemove owns disposal.
+                var taskCancellationToken = cts.Token;
+
+                _ = Task.Run(async () =>
+                {
+                    var previousInterceptor = McpServer.CurrentOutgoingRequestInterceptor;
+                    McpServer.CurrentOutgoingRequestInterceptor = BuildTaskInterceptor(store, taskId);
+                    try
+                    {
+                        var resultNode = await inner(request, taskCancellationToken).ConfigureAwait(false);
+                        var resultElement = ToElement(resultNode);
+                        await store.SetCompletedAsync(taskId, resultElement).ConfigureAwait(false);
+                    }
+                    catch (OperationCanceledException) when (taskCancellationToken.IsCancellationRequested)
+                    {
+                        await store.SetCancelledAsync(taskId, CancellationToken.None).ConfigureAwait(false);
+                    }
+                    catch (InputRequiredException)
+                    {
+                        // MRTR (input requests) cannot be composed with the task-store wrapper for
+                        // [McpServerTool] methods today: the task ID was already returned synchronously,
+                        // so we have no way to surface InputRequiredResult to the client retroactively.
+                        var error = new JsonRpcErrorDetail
+                        {
+                            Code = (int)McpErrorCode.InvalidRequest,
+                            Message = "MRTR (input requests) and tasks cannot be composed via [McpServerTool] yet; " +
+                                      "drive the input-request loop manually from within the task body.",
+                        };
+                        await store.SetFailedAsync(taskId, ToElement(error, TasksJsonContext.Default.JsonRpcErrorDetail)).ConfigureAwait(false);
+                    }
+                    catch (Exception ex)
+                    {
+                        // SEP-2663 186: failed.error MUST be a JSON-RPC error object {code, message, data?}.
+                        // McpProtocolException carries a JSON-RPC ErrorCode and is documented as safe to
+                        // propagate. For any other exception type, redact the message and use InternalError.
+                        var error = ex is McpProtocolException mcpEx
+                            ? new JsonRpcErrorDetail { Code = (int)mcpEx.ErrorCode, Message = mcpEx.Message }
+                            : new JsonRpcErrorDetail { Code = (int)McpErrorCode.InternalError, Message = "An error occurred while executing the task." };
+                        await store.SetFailedAsync(taskId, ToElement(error, TasksJsonContext.Default.JsonRpcErrorDetail)).ConfigureAwait(false);
+                    }
+                    finally
+                    {
+                        McpServer.CurrentOutgoingRequestInterceptor = previousInterceptor;
+
+                        // Only the side that wins TryRemove disposes cts, preventing a double-dispose race
+                        // with the default tasks/cancel handler.
+                        if (cancellationSources.TryRemove(taskId, out var registeredCts))
+                        {
+                            registeredCts.Dispose();
+                        }
+                    }
+                }, CancellationToken.None);
+
+                return JsonSerializer.SerializeToNode(ToCreateTaskResult(taskInfo), TasksJsonContext.Default.CreateTaskResult);
+            }
+
+            return await inner(request, cancellationToken).ConfigureAwait(false);
+        });
+    }
+
+    private static McpOutgoingRequestInterceptor BuildTaskInterceptor(IMcpTaskStore store, string taskId) =>
+        async (method, paramsNode, cancellationToken) =>
+        {
+            var requestId = Guid.NewGuid().ToString("N");
+            JsonElement? paramsElement = paramsNode is null
+                ? null
+                : JsonSerializer.SerializeToElement(paramsNode, TasksJsonContext.Default.JsonNode);
+
+            var inputRequest = new InputRequest
+            {
+                Method = method,
+                Params = paramsElement,
+            };
+
+            var tcs = new TaskCompletionSource<InputResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            void Handler(InputResponseReceivedEventArgs args)
+            {
+                if (args.TaskId == taskId && args.RequestId == requestId)
+                {
+                    tcs.TrySetResult(args.Response);
+                }
+            }
+
+            store.InputResponseReceived += Handler;
+            try
+            {
+                await store.SetInputRequestsAsync(
+                    taskId,
+                    new Dictionary<string, InputRequest> { [requestId] = inputRequest },
+                    cancellationToken).ConfigureAwait(false);
+
+#if NET
+                var response = await tcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
+#else
+                InputResponse response;
+                using (cancellationToken.Register(static s => ((TaskCompletionSource<InputResponse>)s!).TrySetCanceled(), tcs))
+                {
+                    response = await tcs.Task.ConfigureAwait(false);
+                }
+#endif
+
+                return response.RawValue.ValueKind == JsonValueKind.Undefined
+                    ? null
+                    : JsonNode.Parse(response.RawValue.GetRawText());
+            }
+            finally
+            {
+                store.InputResponseReceived -= Handler;
+            }
+        };
+
+    private static bool HasTaskExtensionOptIn(JsonObject? meta) =>
+        meta is not null &&
+        meta[MetaKeys.ClientCapabilities] is JsonObject caps &&
+        caps["extensions"] is JsonObject exts &&
+        exts.ContainsKey(McpExtensions.Tasks);
+
+    private static void EnsureDraft(IMcpServerRawHandlerRegistry registry, JsonRpcRequest request, string method)
+    {
+        // The tasks/* methods do not exist before the draft revision (SEP-2663). Reject them with
+        // MethodNotFound when the request was negotiated under a legacy protocol version.
+        if (!registry.IsDraftProtocolRequest(request))
+        {
+            throw new McpProtocolException(
+                $"The method '{method}' requires the draft protocol revision.",
+                McpErrorCode.MethodNotFound);
+        }
+    }
+
+    private static T Deserialize<T>(JsonNode? node, System.Text.Json.Serialization.Metadata.JsonTypeInfo<T> typeInfo) =>
+        (node is null ? default : JsonSerializer.Deserialize(node, typeInfo))
+            ?? throw new McpProtocolException("Invalid or missing request parameters.", McpErrorCode.InvalidParams);
+
+    private static JsonElement ToElement(JsonNode? node) =>
+        node is null
+            ? default
+            : JsonSerializer.SerializeToElement(node, TasksJsonContext.Default.JsonNode);
+
+    private static JsonElement ToElement<T>(T value, System.Text.Json.Serialization.Metadata.JsonTypeInfo<T> typeInfo) =>
+        JsonSerializer.SerializeToElement(value, typeInfo);
+
+    internal static CreateTaskResult ToCreateTaskResult(McpTaskInfo info) => new()
+    {
+        TaskId = info.TaskId,
+        Status = info.Status,
+        CreatedAt = info.CreatedAt,
+        LastUpdatedAt = info.LastUpdatedAt,
+        TimeToLive = info.TimeToLive,
+        PollIntervalMs = info.PollIntervalMs,
+        StatusMessage = info.StatusMessage,
+        ResultType = "task",
+    };
+
+    internal static GetTaskResult ToGetTaskResult(McpTaskInfo info) => info.Status switch
+    {
+        McpTaskStatus.Working => new WorkingTaskResult
+        {
+            TaskId = info.TaskId,
+            CreatedAt = info.CreatedAt,
+            LastUpdatedAt = info.LastUpdatedAt,
+            TimeToLive = info.TimeToLive,
+            PollIntervalMs = info.PollIntervalMs,
+            StatusMessage = info.StatusMessage,
+            ResultType = "complete",
+        },
+        McpTaskStatus.Completed => new CompletedTaskResult
+        {
+            TaskId = info.TaskId,
+            CreatedAt = info.CreatedAt,
+            LastUpdatedAt = info.LastUpdatedAt,
+            TimeToLive = info.TimeToLive,
+            PollIntervalMs = info.PollIntervalMs,
+            StatusMessage = info.StatusMessage,
+            Result = info.Result ?? throw new InvalidOperationException($"Task '{info.TaskId}' is completed but has no result."),
+            ResultType = "complete",
+        },
+        McpTaskStatus.Failed => new FailedTaskResult
+        {
+            TaskId = info.TaskId,
+            CreatedAt = info.CreatedAt,
+            LastUpdatedAt = info.LastUpdatedAt,
+            TimeToLive = info.TimeToLive,
+            PollIntervalMs = info.PollIntervalMs,
+            StatusMessage = info.StatusMessage,
+            Error = info.Error ?? throw new InvalidOperationException($"Task '{info.TaskId}' is failed but has no error."),
+            ResultType = "complete",
+        },
+        McpTaskStatus.Cancelled => new CancelledTaskResult
+        {
+            TaskId = info.TaskId,
+            CreatedAt = info.CreatedAt,
+            LastUpdatedAt = info.LastUpdatedAt,
+            TimeToLive = info.TimeToLive,
+            PollIntervalMs = info.PollIntervalMs,
+            StatusMessage = info.StatusMessage,
+            ResultType = "complete",
+        },
+        McpTaskStatus.InputRequired => new InputRequiredTaskResult
+        {
+            TaskId = info.TaskId,
+            CreatedAt = info.CreatedAt,
+            LastUpdatedAt = info.LastUpdatedAt,
+            TimeToLive = info.TimeToLive,
+            PollIntervalMs = info.PollIntervalMs,
+            StatusMessage = info.StatusMessage,
+            InputRequests = info.InputRequests is IDictionary<string, InputRequest> dict
+                ? dict
+                : info.InputRequests?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)
+                    ?? new Dictionary<string, InputRequest>(),
+            ResultType = "complete",
+        },
+        _ => throw new InvalidOperationException($"Unknown task status: {info.Status}"),
+    };
+}
diff --git a/src/ModelContextProtocol.Core/Server/McpTaskInfo.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskInfo.cs
similarity index 100%
rename from src/ModelContextProtocol.Core/Server/McpTaskInfo.cs
rename to src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskInfo.cs
diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/TasksJsonContext.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/TasksJsonContext.cs
new file mode 100644
index 000000000..b9ca27f5e
--- /dev/null
+++ b/src/ModelContextProtocol.Extensions.Tasks/Server/TasksJsonContext.cs
@@ -0,0 +1,44 @@
+using ModelContextProtocol.Protocol;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+namespace ModelContextProtocol.Extensions.Tasks;
+
+/// <summary>
+/// Provides source-generated JSON serialization metadata for MCP Tasks extension types.
+/// </summary>
+[JsonSourceGenerationOptions(
+    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
+[JsonSerializable(typeof(CreateTaskResult))]
+[JsonSerializable(typeof(GetTaskRequestParams))]
+[JsonSerializable(typeof(GetTaskResult))]
+[JsonSerializable(typeof(WorkingTaskResult))]
+[JsonSerializable(typeof(CompletedTaskResult))]
+[JsonSerializable(typeof(FailedTaskResult))]
+[JsonSerializable(typeof(CancelledTaskResult))]
+[JsonSerializable(typeof(InputRequiredTaskResult))]
+[JsonSerializable(typeof(UpdateTaskRequestParams))]
+[JsonSerializable(typeof(UpdateTaskResult))]
+[JsonSerializable(typeof(CancelTaskRequestParams))]
+[JsonSerializable(typeof(CancelTaskResult))]
+[JsonSerializable(typeof(TaskStatusNotificationParams))]
+[JsonSerializable(typeof(WorkingTaskNotificationParams))]
+[JsonSerializable(typeof(CompletedTaskNotificationParams))]
+[JsonSerializable(typeof(FailedTaskNotificationParams))]
+[JsonSerializable(typeof(CancelledTaskNotificationParams))]
+[JsonSerializable(typeof(InputRequiredTaskNotificationParams))]
+[JsonSerializable(typeof(CallToolRequestParams))]
+[JsonSerializable(typeof(CallToolResult))]
+[JsonSerializable(typeof(InputRequest))]
+[JsonSerializable(typeof(InputResponse))]
+[JsonSerializable(typeof(IDictionary<string, InputRequest>))]
+[JsonSerializable(typeof(IDictionary<string, InputResponse>))]
+[JsonSerializable(typeof(JsonObject))]
+[JsonSerializable(typeof(JsonNode))]
+[JsonSerializable(typeof(JsonElement))]
+[JsonSerializable(typeof(JsonRpcErrorDetail))]
+internal sealed partial class TasksJsonContext : JsonSerializerContext
+{
+}
diff --git a/src/ModelContextProtocol.Extensions.Tasks/TaskMethods.cs b/src/ModelContextProtocol.Extensions.Tasks/TaskMethods.cs
new file mode 100644
index 000000000..3c3f47774
--- /dev/null
+++ b/src/ModelContextProtocol.Extensions.Tasks/TaskMethods.cs
@@ -0,0 +1,28 @@
+namespace ModelContextProtocol.Extensions.Tasks;
+
+/// <summary>
+/// Provides constants for the JSON-RPC methods defined by the MCP Tasks extension (SEP-2663).
+/// </summary>
+public static class TaskMethods
+{
+    /// <summary>The <c>tasks/get</c> request method, used to retrieve the current state of a task.</summary>
+    public const string Get = "tasks/get";
+
+    /// <summary>The <c>tasks/update</c> request method, used to provide input responses to a task.</summary>
+    public const string Update = "tasks/update";
+
+    /// <summary>The <c>tasks/cancel</c> request method, used to request cancellation of a task.</summary>
+    public const string Cancel = "tasks/cancel";
+
+    /// <summary>The <c>notifications/tasks/status</c> notification method, used to push task status updates.</summary>
+    public const string StatusNotification = "notifications/tasks/status";
+}
+
+/// <summary>
+/// Provides constants for the <c>_meta</c> keys defined by the MCP Tasks extension (SEP-2663).
+/// </summary>
+public static class TaskMetaKeys
+{
+    /// <summary>The <c>_meta</c> key carrying the related task identifier.</summary>
+    public const string RelatedTask = "io.modelcontextprotocol/related-task";
+}
diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props
index b4a79a31e..fa7670f03 100644
--- a/tests/Directory.Build.props
+++ b/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
diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs
index 879173819..4e3649d0a 100644
--- a/tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs
+++ b/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(
diff --git a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
index 4b782cd64..c9fdff85f 100644
--- a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj
+++ b/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>
diff --git a/tests/ModelContextProtocol.Tests/Protocol/TaskSerializationTests.cs b/tests/ModelContextProtocol.Tests/Protocol/TaskSerializationTests.cs
index 86acc57f6..4340b82a3 100644
--- a/tests/ModelContextProtocol.Tests/Protocol/TaskSerializationTests.cs
+++ b/tests/ModelContextProtocol.Tests/Protocol/TaskSerializationTests.cs
@@ -1,3 +1,4 @@
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -27,8 +28,8 @@ public static void CreateTaskResult_SerializationRoundTrip_PreservesAllPropertie
             Meta = new JsonObject { ["key"] = "value" }
         };
 
-        string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<CreateTaskResult>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<CreateTaskResult>(json, McpTasksJsonUtilities.DefaultOptions);
 
         Assert.NotNull(deserialized);
         Assert.Equal("task-123", deserialized.TaskId);
@@ -57,7 +58,7 @@ public static void CreateTaskResult_UsesCorrectWireFieldNames()
             ResultType = "task",
         };
 
-        string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize(result, McpTasksJsonUtilities.DefaultOptions);
 
         // Must use camelCase wire names
         Assert.Contains("\"ttlMs\":", json);
@@ -82,7 +83,7 @@ public static void CreateTaskResult_ResultType_SerializesAsTask()
             ResultType = "task",
         };
 
-        string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize(result, McpTasksJsonUtilities.DefaultOptions);
         var node = JsonNode.Parse(json)!;
 
         Assert.Equal("task", (string)node["resultType"]!);
@@ -104,8 +105,8 @@ public static void GetTaskResult_Working_RoundTrip()
             PollIntervalMs = 2000,
         };
 
-        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var working = Assert.IsType<WorkingTaskResult>(deserialized);
         Assert.Equal("w1", working.TaskId);
@@ -126,8 +127,8 @@ public static void GetTaskResult_Completed_RoundTrip_IncludesResult()
             Result = resultPayload,
         };
 
-        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var completed = Assert.IsType<CompletedTaskResult>(deserialized);
         Assert.Equal("c1", completed.TaskId);
@@ -147,8 +148,8 @@ public static void GetTaskResult_Failed_RoundTrip_IncludesError()
             Error = errorPayload,
         };
 
-        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var failed = Assert.IsType<FailedTaskResult>(deserialized);
         Assert.Equal("f1", failed.TaskId);
@@ -167,8 +168,8 @@ public static void GetTaskResult_Cancelled_RoundTrip()
             StatusMessage = "User cancelled",
         };
 
-        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var cancelled = Assert.IsType<CancelledTaskResult>(deserialized);
         Assert.Equal("x1", cancelled.TaskId);
@@ -195,8 +196,8 @@ public static void GetTaskResult_InputRequired_RoundTrip_IncludesInputRequests()
             InputRequests = inputRequests,
         };
 
-        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<GetTaskResult>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var inputRequired = Assert.IsType<InputRequiredTaskResult>(deserialized);
         Assert.Equal("i1", inputRequired.TaskId);
@@ -228,7 +229,7 @@ public static void GetTaskResult_Converter_DispatchesToCorrectSubtypeByStatus()
                 _ => $$$"""{"taskId":"t","status":"{{{status}}}","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""",
             };
 
-            var result = JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions);
+            var result = JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions);
             Assert.NotNull(result);
             Assert.IsType(expectedType, result);
         }
@@ -238,42 +239,42 @@ public static void GetTaskResult_Converter_DispatchesToCorrectSubtypeByStatus()
     public static void GetTaskResult_MissingTaskId_ThrowsJsonException()
     {
         var json = """{"status":"working","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""";
-        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions));
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions));
     }
 
     [Fact]
     public static void GetTaskResult_MissingStatus_ThrowsJsonException()
     {
         var json = """{"taskId":"t","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""";
-        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions));
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions));
     }
 
     [Fact]
     public static void GetTaskResult_UnknownStatus_ThrowsJsonException()
     {
         var json = """{"taskId":"t","status":"exploded","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""";
-        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions));
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions));
     }
 
     [Fact]
     public static void GetTaskResult_CompletedMissingResult_ThrowsJsonException()
     {
         var json = """{"taskId":"t","status":"completed","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""";
-        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions));
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions));
     }
 
     [Fact]
     public static void GetTaskResult_FailedMissingError_ThrowsJsonException()
     {
         var json = """{"taskId":"t","status":"failed","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""";
-        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions));
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions));
     }
 
     [Fact]
     public static void GetTaskResult_InputRequiredMissingInputRequests_ThrowsJsonException()
     {
         var json = """{"taskId":"t","status":"input_required","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""";
-        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpJsonUtilities.DefaultOptions));
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<GetTaskResult>(json, McpTasksJsonUtilities.DefaultOptions));
     }
 
     [Theory]
@@ -303,14 +304,14 @@ public static void GetTaskResult_WireResultType_IsComplete_WhenSet(Type subType)
                     ["k"] = new InputRequest
                     {
                         Method = "test/method",
-                        Params = JsonSerializer.SerializeToElement("ask", McpJsonUtilities.DefaultOptions),
+                        Params = JsonSerializer.SerializeToElement("ask", McpTasksJsonUtilities.DefaultOptions),
                     },
                 },
             },
             _ => throw new InvalidOperationException()
         };
 
-        string json = JsonSerializer.Serialize(value, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize(value, McpTasksJsonUtilities.DefaultOptions);
         var node = JsonNode.Parse(json)!;
 
         Assert.Equal("complete", (string?)node["resultType"]);
@@ -328,10 +329,10 @@ public static void GetTaskResult_WireResultType_IsComplete_WhenSet(Type subType)
     [InlineData(McpTaskStatus.Failed, "failed")]
     public static void McpTaskStatus_SerializesAsSnakeCase(McpTaskStatus status, string expectedWireValue)
     {
-        string json = JsonSerializer.Serialize(status, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize(status, McpTasksJsonUtilities.DefaultOptions);
         Assert.Equal($"\"{expectedWireValue}\"", json);
 
-        var deserialized = JsonSerializer.Deserialize<McpTaskStatus>(json, McpJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<McpTaskStatus>(json, McpTasksJsonUtilities.DefaultOptions);
         Assert.Equal(status, deserialized);
     }
 
@@ -350,8 +351,8 @@ public static void TaskStatusNotificationParams_Working_RoundTrip()
             StatusMessage = "Working on it",
         };
 
-        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var working = Assert.IsType<WorkingTaskNotificationParams>(deserialized);
         Assert.Equal("n1", working.TaskId);
@@ -370,8 +371,8 @@ public static void TaskStatusNotificationParams_Completed_RoundTrip()
             Result = resultPayload,
         };
 
-        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var completed = Assert.IsType<CompletedTaskNotificationParams>(deserialized);
         Assert.Equal("n2", completed.TaskId);
@@ -390,8 +391,8 @@ public static void TaskStatusNotificationParams_Failed_RoundTrip()
             Error = errorPayload,
         };
 
-        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var failed = Assert.IsType<FailedTaskNotificationParams>(deserialized);
         Assert.Equal("n3", failed.TaskId);
@@ -408,8 +409,8 @@ public static void TaskStatusNotificationParams_Cancelled_RoundTrip()
             LastUpdatedAt = DateTimeOffset.UtcNow,
         };
 
-        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpTasksJsonUtilities.DefaultOptions);
 
         Assert.IsType<CancelledTaskNotificationParams>(deserialized);
     }
@@ -429,8 +430,8 @@ public static void TaskStatusNotificationParams_InputRequired_RoundTrip()
             InputRequests = inputRequests,
         };
 
-        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpJsonUtilities.DefaultOptions);
-        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize<TaskStatusNotificationParams>(original, McpTasksJsonUtilities.DefaultOptions);
+        var deserialized = JsonSerializer.Deserialize<TaskStatusNotificationParams>(json, McpTasksJsonUtilities.DefaultOptions);
 
         var inputRequired = Assert.IsType<InputRequiredTaskNotificationParams>(deserialized);
         Assert.NotNull(inputRequired.InputRequests);
@@ -496,7 +497,7 @@ public static void UpdateTaskResult_WireResultType_IsComplete_WhenSet()
     {
         // SEP-2663: tasks/update responses use resultType="complete".
         var result = new UpdateTaskResult { ResultType = "complete" };
-        string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize(result, McpTasksJsonUtilities.DefaultOptions);
         var node = JsonNode.Parse(json)!;
 
         Assert.Equal("complete", (string?)node["resultType"]);
@@ -507,7 +508,7 @@ public static void CancelTaskResult_WireResultType_IsComplete_WhenSet()
     {
         // SEP-2663: tasks/cancel responses use resultType="complete".
         var result = new CancelTaskResult { ResultType = "complete" };
-        string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions);
+        string json = JsonSerializer.Serialize(result, McpTasksJsonUtilities.DefaultOptions);
         var node = JsonNode.Parse(json)!;
 
         Assert.Equal("complete", (string?)node["resultType"]);
diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTaskTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTaskTests.cs
index 9708722f3..e5d160841 100644
--- a/tests/ModelContextProtocol.Tests/Server/McpServerTaskTests.cs
+++ b/tests/ModelContextProtocol.Tests/Server/McpServerTaskTests.cs
@@ -1,18 +1,22 @@
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using Microsoft.Extensions.DependencyInjection;
 using System.Runtime.InteropServices;
-using System.Text.Json;
 using System.Text.Json.Nodes;
 
+#pragma warning disable MCPEXP001
+
 namespace ModelContextProtocol.Tests.Server;
 
 /// <summary>
-/// Tests for the MCP tasks extension (SEP-2663) end-to-end using a simple in-memory task store.
+/// Tests for the MCP tasks extension (SEP-2663) end-to-end using the store-backed
+/// <c>WithTasks</c> public API and the client-side task extension methods.
 /// </summary>
 public class McpServerTaskTests : ClientServerTestBase
 {
-    private readonly InMemoryTaskStore _taskStore = new();
+    private readonly InMemoryMcpTaskStore _taskStore = new() { DefaultPollIntervalMs = 50 };
     private JsonObject? _capturedMeta;
 
     public McpServerTaskTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
@@ -24,90 +28,52 @@ public McpServerTaskTests(ITestOutputHelper testOutputHelper) : base(testOutputH
 
     protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder)
     {
-        services.AddSingleton(_taskStore);
-
         mcpServerBuilder.Services.Configure<McpServerOptions>(options =>
         {
             options.Capabilities ??= new ServerCapabilities();
+            options.WithTasks(_taskStore);
+        });
 
-            options.Handlers.CallToolWithTaskHandler = async (context, cancellationToken) =>
-            {
-                _capturedMeta = context.Params?.Meta;
-                var store = context.Server.Services!.GetRequiredService<InMemoryTaskStore>();
-                var toolName = context.Params!.Name;
-
-                if (toolName == "immediate-tool")
+        mcpServerBuilder.WithTools([
+            // Captures the _meta the server received so the SEP-2575 opt-in envelope can be asserted.
+            McpServerTool.Create(
+                (RequestContext<CallToolRequestParams> context) =>
                 {
-                    return new CallToolResult()
-                    {
-                        Content = [new TextContentBlock { Text = "immediate result" }],
-                    };
-                }
+                    _capturedMeta = context.Params?.Meta;
+                    return "immediate result";
+                },
+                new() { Name = "immediate-tool" }),
 
-                if (toolName == "async-tool")
-                {
-                    var taskId = store.CreateTask();
-                    return new CreateTaskResult
-                    {
-                        TaskId = taskId,
-                        Status = McpTaskStatus.Working,
-                        CreatedAt = DateTimeOffset.UtcNow,
-                        LastUpdatedAt = DateTimeOffset.UtcNow,
-                        PollIntervalMs = 50,
-                        ResultType = "task",
-                    };
-                }
-
-                if (toolName == "input-required-tool")
+            McpServerTool.Create(
+                async (CancellationToken cancellationToken) =>
                 {
-                    var taskId = store.CreateTask(McpTaskStatus.InputRequired);
-                    return new CreateTaskResult
-                    {
-                        TaskId = taskId,
-                        Status = McpTaskStatus.InputRequired,
-                        CreatedAt = DateTimeOffset.UtcNow,
-                        LastUpdatedAt = DateTimeOffset.UtcNow,
-                        PollIntervalMs = 50,
-                        ResultType = "task",
-                    };
-                }
-
-                throw new McpException($"Unknown tool: {toolName}");
-            };
-
-            options.Handlers.GetTaskHandler = async (context, cancellationToken) =>
-            {
-                var store = context.Server.Services!.GetRequiredService<InMemoryTaskStore>();
-                var taskId = context.Params!.TaskId;
-                return store.GetTask(taskId);
-            };
+                    await Task.Delay(100, cancellationToken);
+                    return "async result";
+                },
+                new() { Name = "slow-tool" }),
 
-            options.Handlers.UpdateTaskHandler = async (context, cancellationToken) =>
-            {
-                var store = context.Server.Services!.GetRequiredService<InMemoryTaskStore>();
-                var taskId = context.Params!.TaskId;
-                store.ProvideInput(taskId, context.Params.InputResponses ?? new Dictionary<string, InputResponse>());
-                return new UpdateTaskResult();
-            };
+            McpServerTool.Create(
+                string (CancellationToken cancellationToken) => throw new McpException("something went wrong"),
+                new() { Name = "failing-tool" }),
 
-            options.Handlers.CancelTaskHandler = async (context, cancellationToken) =>
-            {
-                var store = context.Server.Services!.GetRequiredService<InMemoryTaskStore>();
-                var taskId = context.Params!.TaskId;
-                store.CancelTask(taskId);
-                return new CancelTaskResult();
-            };
-        });
+            McpServerTool.Create(
+                async (CancellationToken cancellationToken) =>
+                {
+                    await Task.Delay(Timeout.Infinite, cancellationToken);
+                    return "never";
+                },
+                new() { Name = "blocking-tool" }),
+        ]);
     }
 
     [Fact]
-    public async Task CallToolAsync_ImmediateResult_ReturnsDirectly()
+    public async Task CallToolAsTaskAsync_ImmediateTool_PollsToResult()
     {
         await using var client = await CreateMcpClientForServer();
 
-        var result = await client.CallToolAsync(
+        var result = await client.CallToolAsTaskAsync(
             new CallToolRequestParams { Name = "immediate-tool" },
-            TestContext.Current.CancellationToken);
+            cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.NotNull(result);
         Assert.Single(result.Content);
@@ -115,7 +81,7 @@ public async Task CallToolAsync_ImmediateResult_ReturnsDirectly()
     }
 
     [Fact]
-    public async Task CallToolRawAsync_ImmediateResult_ReturnsResultNotTask()
+    public async Task CallToolRawAsync_OptedIn_ReturnsTaskCreated()
     {
         await using var client = await CreateMcpClientForServer();
 
@@ -123,21 +89,6 @@ public async Task CallToolRawAsync_ImmediateResult_ReturnsResultNotTask()
             new CallToolRequestParams { Name = "immediate-tool" },
             TestContext.Current.CancellationToken);
 
-        Assert.False(augmented.IsTask);
-        Assert.NotNull(augmented.Result);
-        Assert.Null(augmented.TaskCreated);
-        Assert.Equal("immediate result", Assert.IsType<TextContentBlock>(augmented.Result.Content[0]).Text);
-    }
-
-    [Fact]
-    public async Task CallToolRawAsync_AsyncTool_ReturnsTaskCreated()
-    {
-        await using var client = await CreateMcpClientForServer();
-
-        var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "async-tool" },
-            TestContext.Current.CancellationToken);
-
         Assert.True(augmented.IsTask);
         Assert.NotNull(augmented.TaskCreated);
         Assert.Null(augmented.Result);
@@ -146,26 +97,14 @@ public async Task CallToolRawAsync_AsyncTool_ReturnsTaskCreated()
     }
 
     [Fact]
-    public async Task CallToolAsync_AsyncTool_PollsUntilCompleted()
+    public async Task CallToolAsTaskAsync_SlowTool_PollsUntilCompleted()
     {
         await using var client = await CreateMcpClientForServer();
         var ct = TestContext.Current.CancellationToken;
 
-        // Complete the task after a brief delay so polling finds it.
-        _ = Task.Run(async () =>
-        {
-            await Task.Delay(100, ct);
-            // The store should have exactly one task by now
-            var taskId = _taskStore.GetAllTaskIds().Single();
-            _taskStore.CompleteTask(taskId, new CallToolResult
-            {
-                Content = [new TextContentBlock { Text = "async result" }],
-            });
-        }, ct);
-
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "async-tool" },
-            ct);
+        var result = await client.CallToolAsTaskAsync(
+            new CallToolRequestParams { Name = "slow-tool" },
+            cancellationToken: ct);
 
         Assert.NotNull(result);
         Assert.Single(result.Content);
@@ -173,95 +112,65 @@ public async Task CallToolAsync_AsyncTool_PollsUntilCompleted()
     }
 
     [Fact]
-    public async Task CallToolAsync_AsyncTool_FailedTask_ThrowsMcpException()
+    public async Task CallToolAsTaskAsync_FailingTool_ReturnsErrorResult()
     {
         await using var client = await CreateMcpClientForServer();
         var ct = TestContext.Current.CancellationToken;
 
-        var failedTask = new TaskCompletionSource<bool>();
-
-        // Run failure task once the task from the tool call is created
-        _taskStore.OnTaskCreated += taskId =>
-        {
-            _ = Task.Run(async () =>
-            {
-                await Task.Delay(100, ct);
-                _taskStore.FailTask(taskId, JsonElement.Parse("""{"code":-32000,"message":"something went wrong"}"""));
-                failedTask.SetResult(true);
-            }, ct);
-        };
-
-        await Assert.ThrowsAsync<McpException>(async () =>
-            await client.CallToolAsync(
-                new CallToolRequestParams { Name = "async-tool" },
-                ct));
+        var result = await client.CallToolAsTaskAsync(
+            new CallToolRequestParams { Name = "failing-tool" },
+            cancellationToken: ct);
 
-        Assert.True(await failedTask.Task);
-    }
-
-    [Fact]
-    public async Task CallToolAsync_AsyncTool_CancelledTask_ThrowsOperationCancelled()
-    {
-        await using var client = await CreateMcpClientForServer();
-        var ct = TestContext.Current.CancellationToken;
-
-        var cancelledTask = new TaskCompletionSource<bool>();
-
-        // Run cancellation task once the task from the tool call is created
-        _taskStore.OnTaskCreated += taskId =>
-        {
-            Task.Run(async () =>
-            {
-                await Task.Delay(100, ct);
-                _taskStore.CancelTask(taskId);
-                cancelledTask.SetResult(true);
-            }, ct);
-        };
-
-        await Assert.ThrowsAsync<OperationCanceledException>(async () =>
-            await client.CallToolAsync(
-                new CallToolRequestParams { Name = "async-tool" },
-                ct));
-
-        Assert.True(await cancelledTask.Task);
+        Assert.NotNull(result);
+        Assert.True(result.IsError);
     }
 
     [Fact]
     public async Task GetTaskAsync_ReturnsCurrentState()
     {
         await using var client = await CreateMcpClientForServer();
+        var ct = TestContext.Current.CancellationToken;
 
-        // Create a task via CallToolRawAsync
         var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "async-tool" },
-            TestContext.Current.CancellationToken);
+            new CallToolRequestParams { Name = "blocking-tool" }, ct);
 
         var taskId = augmented.TaskCreated!.TaskId;
 
-        // Should be working
-        var taskResult = await client.GetTaskAsync(taskId, TestContext.Current.CancellationToken);
+        var taskResult = await client.GetTaskAsync(taskId, ct);
         Assert.IsType<WorkingTaskResult>(taskResult);
         Assert.Equal(taskId, taskResult.TaskId);
         Assert.Equal(McpTaskStatus.Working, taskResult.Status);
+
+        // Release the blocking task so it doesn't linger in the background.
+        await client.CancelTaskAsync(taskId, ct);
     }
 
     [Fact]
     public async Task CancelTaskAsync_CancelsTask()
     {
         await using var client = await CreateMcpClientForServer();
+        var ct = TestContext.Current.CancellationToken;
 
         var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "async-tool" },
-            TestContext.Current.CancellationToken);
+            new CallToolRequestParams { Name = "blocking-tool" }, ct);
 
         var taskId = augmented.TaskCreated!.TaskId;
 
-        // Cancel via client
-        var cancelResult = await client.CancelTaskAsync(taskId, TestContext.Current.CancellationToken);
+        var cancelResult = await client.CancelTaskAsync(taskId, ct);
         Assert.NotNull(cancelResult);
 
-        // Verify state changed
-        var taskResult = await client.GetTaskAsync(taskId, TestContext.Current.CancellationToken);
+        GetTaskResult? taskResult = null;
+        for (int i = 0; i < 40; i++)
+        {
+            taskResult = await client.GetTaskAsync(taskId, ct);
+            if (taskResult is CancelledTaskResult)
+            {
+                break;
+            }
+
+            await Task.Delay(50, ct);
+        }
+
         Assert.IsType<CancelledTaskResult>(taskResult);
     }
 
@@ -285,7 +194,7 @@ public async Task CreateTaskResult_HasResultTypeTask()
         await using var client = await CreateMcpClientForServer();
 
         var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "async-tool" },
+            new CallToolRequestParams { Name = "immediate-tool" },
             TestContext.Current.CancellationToken);
 
         Assert.True(augmented.IsTask);
@@ -297,17 +206,19 @@ public async Task GetTaskAsync_ImmediatelyAfterCreate_Resolves()
     {
         // Strong consistency: tasks/get immediately after CreateTaskResult must resolve.
         await using var client = await CreateMcpClientForServer();
+        var ct = TestContext.Current.CancellationToken;
 
         var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "async-tool" },
-            TestContext.Current.CancellationToken);
+            new CallToolRequestParams { Name = "blocking-tool" }, ct);
 
         var taskId = augmented.TaskCreated!.TaskId;
 
         // No delay — immediate get
-        var taskResult = await client.GetTaskAsync(taskId, TestContext.Current.CancellationToken);
+        var taskResult = await client.GetTaskAsync(taskId, ct);
         Assert.NotNull(taskResult);
         Assert.Equal(taskId, taskResult.TaskId);
+
+        await client.CancelTaskAsync(taskId, ct);
     }
 
     [Fact]
@@ -329,7 +240,7 @@ public async Task CancelTask_AlreadyTerminal_AcknowledgesIdempotently()
         var ct = TestContext.Current.CancellationToken;
 
         var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "async-tool" }, ct);
+            new CallToolRequestParams { Name = "blocking-tool" }, ct);
         var taskId = augmented.TaskCreated!.TaskId;
 
         // Cancel once
@@ -340,55 +251,6 @@ public async Task CancelTask_AlreadyTerminal_AcknowledgesIdempotently()
         Assert.NotNull(ack);
     }
 
-    [Fact]
-    public async Task UpdateTaskAsync_TransitionsFromInputRequired()
-    {
-        await using var client = await CreateMcpClientForServer();
-        var ct = TestContext.Current.CancellationToken;
-
-        // Create an input-required task
-        var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "input-required-tool" }, ct);
-
-        var taskId = augmented.TaskCreated!.TaskId;
-
-        // Verify it's input_required
-        var taskResult = await client.GetTaskAsync(taskId, ct);
-        Assert.IsType<InputRequiredTaskResult>(taskResult);
-
-        // Provide input
-        var inputResponses = new Dictionary<string, InputResponse>
-        {
-            ["resp-1"] = new InputResponse { RawValue = JsonElement.Parse("""{"answer":"yes"}""") }
-        };
-        await client.UpdateTaskAsync(new UpdateTaskRequestParams
-        {
-            TaskId = taskId,
-            InputResponses = inputResponses,
-        }, ct);
-
-        // Verify it transitioned back to working
-        taskResult = await client.GetTaskAsync(taskId, ct);
-        Assert.IsType<WorkingTaskResult>(taskResult);
-    }
-
-    [Fact]
-    public async Task CallToolRawAsync_InjectsTaskCapabilityInMeta()
-    {
-        // Verify the server receives the task extension in _meta by intercepting
-        // the handler. The CallToolWithTaskHandler already receives the request,
-        // so we can observe the meta there. We test the client-side injection indirectly
-        // by confirming the server returns a task result (which requires the capability signal).
-        await using var client = await CreateMcpClientForServer();
-
-        var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "async-tool" },
-            TestContext.Current.CancellationToken);
-
-        // If the capability wasn't injected, the server couldn't have returned a task
-        Assert.True(augmented.IsTask);
-    }
-
     [Fact]
     public async Task CallToolRawAsync_OptIn_UsesSep2575CapabilitiesEnvelope()
     {
@@ -397,9 +259,11 @@ public async Task CallToolRawAsync_OptIn_UsesSep2575CapabilitiesEnvelope()
         // This test pins the literal wire path so future refactors can't regress.
         await using var client = await CreateMcpClientForServer();
 
-        await client.CallToolRawAsync(
+        // CallToolAsTaskAsync runs the tool to completion, ensuring the server-side tool has
+        // observed the request _meta before we assert on the captured value.
+        await client.CallToolAsTaskAsync(
             new CallToolRequestParams { Name = "immediate-tool" },
-            TestContext.Current.CancellationToken);
+            cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.NotNull(_capturedMeta);
 
@@ -431,13 +295,13 @@ public async Task CallToolRawAsync_OptIn_PreservesExistingMetaSiblings()
             },
         };
 
-        await client.CallToolRawAsync(
+        await client.CallToolAsTaskAsync(
             new CallToolRequestParams
             {
                 Name = "immediate-tool",
                 Meta = userMeta,
             },
-            TestContext.Current.CancellationToken);
+            cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.NotNull(_capturedMeta);
 
@@ -450,250 +314,4 @@ await client.CallToolRawAsync(
         Assert.True(extensions.ContainsKey("some.other/extension"));
         Assert.True(extensions.ContainsKey("io.modelcontextprotocol/tasks"));
     }
-
-    [Fact]
-    public async Task CallToolRawAsync_PreservesExistingUserMeta()
-    {
-        // Verify that user-supplied meta fields are not clobbered
-        await using var client = await CreateMcpClientForServer();
-
-        var userMeta = new JsonObject { ["customKey"] = "customValue" };
-        var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams
-            {
-                Name = "immediate-tool",
-                Meta = userMeta,
-            },
-            TestContext.Current.CancellationToken);
-
-        // Should still work — the meta was cloned, not destructively modified
-        Assert.False(augmented.IsTask);
-        Assert.Equal("immediate result", Assert.IsType<TextContentBlock>(augmented.Result!.Content[0]).Text);
-
-        // Original user meta should not be mutated
-        Assert.Single(userMeta);
-        Assert.Equal("customValue", (string)userMeta["customKey"]!);
-    }
-
-    [Fact]
-    public async Task CallToolAsync_RespectsServerPollInterval()
-    {
-        await using var client = await CreateMcpClientForServer();
-        var ct = TestContext.Current.CancellationToken;
-
-        var startTime = DateTime.UtcNow;
-
-        // Complete the task after a brief delay
-        _ = Task.Run(async () =>
-        {
-            await Task.Delay(200, ct);
-            var taskId = _taskStore.GetAllTaskIds().Single();
-            _taskStore.CompleteTask(taskId, new CallToolResult
-            {
-                Content = [new TextContentBlock { Text = "polled" }],
-            });
-        }, ct);
-
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "async-tool" }, ct);
-
-        var elapsed = DateTime.UtcNow - startTime;
-
-        // The server sets pollIntervalMs=50. The task completes after 200ms.
-        // So we expect at least 1 poll interval to have passed.
-        Assert.True(elapsed.TotalMilliseconds >= 50, $"Expected at least 50ms, got {elapsed.TotalMilliseconds}ms");
-        Assert.Equal("polled", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
-    }
-
-    [Fact]
-    public async Task CallToolWithTaskHandler_ImplicitConversion_ReturnCallToolResult()
-    {
-        // Verify that the implicit conversion from CallToolResult to ResultOrCreatedTask works
-        // in the handler context — this is already tested by "immediate-tool" working correctly.
-        await using var client = await CreateMcpClientForServer();
-
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "immediate-tool" },
-            TestContext.Current.CancellationToken);
-
-        Assert.Equal("immediate result", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
-    }
-
-    [Fact]
-    public async Task CallToolHandler_And_CallToolWithTaskHandler_AreMutuallyExclusive()
-    {
-        var handlers = new McpServerHandlers();
-
-        handlers.CallToolWithTaskHandler = async (ctx, ct) => new CallToolResult();
-        Assert.Throws<InvalidOperationException>(() =>
-            handlers.CallToolHandler = async (ctx, ct) => new CallToolResult());
-
-        handlers = new McpServerHandlers();
-
-        handlers.CallToolHandler = async (ctx, ct) => new CallToolResult();
-        Assert.Throws<InvalidOperationException>(() =>
-            handlers.CallToolWithTaskHandler = async (ctx, ct) => new CallToolResult());
-    }
-
-    [Fact]
-    public async Task CallToolHandler_CanBeSetToNull_ThenOtherCanBeSet()
-    {
-        var handlers = new McpServerHandlers();
-
-        handlers.CallToolHandler = async (ctx, ct) => new CallToolResult();
-        handlers.CallToolHandler = null;
-
-        // Now setting the other should work
-        handlers.CallToolWithTaskHandler = async (ctx, ct) => new CallToolResult();
-        Assert.NotNull(handlers.CallToolWithTaskHandler);
-    }
-
-    /// <summary>
-    /// Simple in-memory task store for testing.
-    /// </summary>
-    private sealed class InMemoryTaskStore
-    {
-        private readonly Dictionary<string, TaskEntry> _tasks = new();
-
-        internal Action<string>? OnTaskCreated;
-
-        public string CreateTask(McpTaskStatus initialStatus = McpTaskStatus.Working)
-        {
-            var taskId = Guid.NewGuid().ToString("N");
-            lock (_tasks)
-            {
-                _tasks[taskId] = new TaskEntry
-                {
-                    Status = initialStatus,
-                    CreatedAt = DateTimeOffset.UtcNow,
-                    LastUpdatedAt = DateTimeOffset.UtcNow,
-                };
-            }
-
-            OnTaskCreated?.Invoke(taskId);
-
-            return taskId;
-        }
-
-        public IEnumerable<string> GetAllTaskIds()
-        {
-            lock (_tasks)
-            {
-                return _tasks.Keys.ToArray();
-            }
-        }
-
-        public GetTaskResult GetTask(string taskId)
-        {
-            lock (_tasks)
-            {
-                if (!_tasks.TryGetValue(taskId, out var entry))
-                {
-                    throw new McpException($"Unknown task: '{taskId}'");
-                }
-
-                return entry.Status switch
-                {
-                    McpTaskStatus.Working => new WorkingTaskResult
-                    {
-                        TaskId = taskId,
-                        CreatedAt = entry.CreatedAt,
-                        LastUpdatedAt = entry.LastUpdatedAt,
-                        PollIntervalMs = 50,
-                    },
-                    McpTaskStatus.Completed => new CompletedTaskResult
-                    {
-                        TaskId = taskId,
-                        CreatedAt = entry.CreatedAt,
-                        LastUpdatedAt = entry.LastUpdatedAt,
-                        Result = JsonSerializer.SerializeToElement(entry.Result, McpJsonUtilities.DefaultOptions),
-                    },
-                    McpTaskStatus.Failed => new FailedTaskResult
-                    {
-                        TaskId = taskId,
-                        CreatedAt = entry.CreatedAt,
-                        LastUpdatedAt = entry.LastUpdatedAt,
-                        Error = entry.Error!.Value,
-                    },
-                    McpTaskStatus.Cancelled => new CancelledTaskResult
-                    {
-                        TaskId = taskId,
-                        CreatedAt = entry.CreatedAt,
-                        LastUpdatedAt = entry.LastUpdatedAt,
-                    },
-                    McpTaskStatus.InputRequired => new InputRequiredTaskResult
-                    {
-                        TaskId = taskId,
-                        CreatedAt = entry.CreatedAt,
-                        LastUpdatedAt = entry.LastUpdatedAt,
-                        InputRequests = entry.InputRequests ?? new Dictionary<string, InputRequest>(),
-                    },
-                    _ => throw new InvalidOperationException($"Unexpected status: {entry.Status}")
-                };
-            }
-        }
-
-        public void CompleteTask(string taskId, CallToolResult result)
-        {
-            lock (_tasks)
-            {
-                if (_tasks.TryGetValue(taskId, out var entry))
-                {
-                    entry.Result = result;
-                    entry.LastUpdatedAt = DateTimeOffset.UtcNow;
-                    entry.Status = McpTaskStatus.Completed;
-                }
-            }
-        }
-
-        public void FailTask(string taskId, JsonElement error)
-        {
-            lock (_tasks)
-            {
-                if (_tasks.TryGetValue(taskId, out var entry))
-                {
-                    entry.Error = error;
-                    entry.LastUpdatedAt = DateTimeOffset.UtcNow;
-                    entry.Status = McpTaskStatus.Failed;
-                }
-            }
-        }
-
-        public void CancelTask(string taskId)
-        {
-            lock (_tasks)
-            {
-                if (_tasks.TryGetValue(taskId, out var entry))
-                {
-                    entry.LastUpdatedAt = DateTimeOffset.UtcNow;
-                    entry.Status = McpTaskStatus.Cancelled;
-                }
-            }
-        }
-
-        public void ProvideInput(string taskId, IDictionary<string, InputResponse> inputResponses)
-        {
-            lock (_tasks)
-            {
-                if (_tasks.TryGetValue(taskId, out var entry))
-                {
-                    entry.InputResponses = inputResponses;
-                    entry.LastUpdatedAt = DateTimeOffset.UtcNow;
-                    // Transition back to working after receiving input
-                    entry.Status = McpTaskStatus.Working;
-                }
-            }
-        }
-
-        private sealed class TaskEntry
-        {
-            public McpTaskStatus Status { get; set; }
-            public DateTimeOffset CreatedAt { get; set; }
-            public DateTimeOffset LastUpdatedAt { get; set; }
-            public CallToolResult? Result { get; set; }
-            public JsonElement? Error { get; set; }
-            public IDictionary<string, InputRequest>? InputRequests { get; set; }
-            public IDictionary<string, InputResponse>? InputResponses { get; set; }
-        }
-    }
 }
diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTasksNoStoreTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTasksNoStoreTests.cs
index 9e264af78..11e8a8674 100644
--- a/tests/ModelContextProtocol.Tests/Server/McpServerTasksNoStoreTests.cs
+++ b/tests/ModelContextProtocol.Tests/Server/McpServerTasksNoStoreTests.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;
diff --git a/tests/ModelContextProtocol.Tests/Server/McpTaskStoreTests.cs b/tests/ModelContextProtocol.Tests/Server/McpTaskStoreTests.cs
index 09a501ab8..a06da2fc0 100644
--- a/tests/ModelContextProtocol.Tests/Server/McpTaskStoreTests.cs
+++ b/tests/ModelContextProtocol.Tests/Server/McpTaskStoreTests.cs
@@ -1,5 +1,6 @@
 using Microsoft.Extensions.AI;
 using ModelContextProtocol.Client;
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using Microsoft.Extensions.DependencyInjection;
@@ -31,10 +32,10 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer
 
         mcpServerBuilder.Services.Configure<McpServerOptions>(options =>
         {
-            options.TaskStore = new InMemoryMcpTaskStore
+            options.WithTasks(new InMemoryMcpTaskStore
             {
                 DefaultPollIntervalMs = 50,
-            };
+            });
         });
     }
 
@@ -60,9 +61,7 @@ public async Task CallToolAsync_WithTaskStore_PollsToCompletion()
         await using var client = await CreateMcpClientForServer();
 
         // CallToolAsync should poll until the background execution completes.
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "slow-tool" },
-            TestContext.Current.CancellationToken);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "slow-tool" }, cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.NotNull(result);
         Assert.Single(result.Content);
@@ -233,7 +232,7 @@ public async Task InputRequiredException_FromTool_FailsTaskWithActionableMessage
         var message = failed.Error.GetProperty("message").GetString();
         Assert.NotNull(message);
         Assert.Contains("MRTR", message);
-        Assert.Contains(nameof(McpServerHandlers.CallToolWithTaskHandler), message);
+        Assert.Contains("tasks", message, StringComparison.OrdinalIgnoreCase);
     }
 
     [Fact]
@@ -253,8 +252,7 @@ public async Task ElicitTool_ViaTask_RedirectsThroughStore()
         var ct = TestContext.Current.CancellationToken;
 
         // CallToolAsync will poll and resolve input requests automatically.
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "elicit-tool" }, ct);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "elicit-tool" }, cancellationToken: ct);
 
         Assert.NotNull(result);
         Assert.Equal("accepted", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
@@ -279,8 +277,7 @@ public async Task SampleTool_ViaTask_RedirectsThroughStore()
         });
         var ct = TestContext.Current.CancellationToken;
 
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "sample-tool" }, ct);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "sample-tool" }, cancellationToken: ct);
 
         Assert.NotNull(result);
         Assert.Equal("sampled response", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
@@ -309,8 +306,7 @@ public async Task RootsTool_ViaTask_RedirectsThroughStore()
         });
         var ct = TestContext.Current.CancellationToken;
 
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "roots-tool" }, ct);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "roots-tool" }, cancellationToken: ct);
 
         Assert.NotNull(result);
         Assert.Equal("file:///workspace,file:///other", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
@@ -328,12 +324,12 @@ public async Task SendTaskStatusNotificationAsync_FromTool_DeliversTypedNotifica
         var ct = TestContext.Current.CancellationToken;
 
         await using var registration = client.RegisterNotificationHandler(
-            NotificationMethods.TaskStatusNotification,
+            TaskMethods.StatusNotification,
             (notification, _) =>
             {
                 var typed = JsonSerializer.Deserialize<TaskStatusNotificationParams>(
                     notification.Params,
-                    McpJsonUtilities.DefaultOptions);
+                    McpTasksJsonUtilities.DefaultOptions);
                 if (typed is not null)
                 {
                     notifications.Writer.TryWrite(typed);
@@ -342,8 +338,7 @@ public async Task SendTaskStatusNotificationAsync_FromTool_DeliversTypedNotifica
                 return default;
             });
 
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "notifying-tool" }, ct);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "notifying-tool" }, cancellationToken: ct);
 
         Assert.Equal("notified", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
 
@@ -377,12 +372,12 @@ public async Task SendTaskStatusNotificationAsync_Failed_DeliversTypedNotificati
         var ct = TestContext.Current.CancellationToken;
 
         await using var registration = client.RegisterNotificationHandler(
-            NotificationMethods.TaskStatusNotification,
+            TaskMethods.StatusNotification,
             (notification, _) =>
             {
                 var typed = JsonSerializer.Deserialize<TaskStatusNotificationParams>(
                     notification.Params,
-                    McpJsonUtilities.DefaultOptions);
+                    McpTasksJsonUtilities.DefaultOptions);
                 if (typed is FailedTaskNotificationParams)
                 {
                     notifications.Writer.TryWrite(typed);
@@ -393,8 +388,7 @@ public async Task SendTaskStatusNotificationAsync_Failed_DeliversTypedNotificati
 
         // The tool emits a Failed notification then returns a normal result, so we isolate the
         // notification round-trip from the task-store's own failure handling.
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "failing-notify-tool" }, ct);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "failing-notify-tool" }, cancellationToken: ct);
 
         Assert.Equal("emitted-failed", Assert.IsType<TextContentBlock>(result.Content[0]).Text);
 
@@ -426,8 +420,7 @@ public async Task ElicitTool_ViaTask_ClientDedups_InputRequests()
         });
         var ct = TestContext.Current.CancellationToken;
 
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "elicit-tool" }, ct);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "elicit-tool" }, cancellationToken: ct);
 
         // The handler should be called exactly once despite potential multiple polls
         Assert.Equal(1, elicitCallCount);
@@ -516,7 +509,7 @@ public async Task CallToolAsync_ElicitHandlerThrows_PropagatesAndDoesNotLeaveCli
 
         var sw = System.Diagnostics.Stopwatch.StartNew();
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
-            await client.CallToolAsync(new CallToolRequestParams { Name = "elicit-tool" }, ct));
+            await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "elicit-tool" }, cancellationToken: ct));
         sw.Stop();
 
         Assert.Equal("handler-failed", ex.Message);
@@ -602,8 +595,7 @@ public async Task MultiElicit_ViaTask_HandlerCalledExactlyOncePerUniqueKey_Acros
         });
         var ct = TestContext.Current.CancellationToken;
 
-        var result = await client.CallToolAsync(
-            new CallToolRequestParams { Name = "multi-elicit-tool" }, ct);
+        var result = await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "multi-elicit-tool" }, cancellationToken: ct);
 
         // Exactly two handler invocations — one per unique input request key.
         Assert.Equal(2, elicitCount);
diff --git a/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs
index 0e8693353..2b7490966 100644
--- a/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs
+++ b/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs
@@ -1,5 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol.Client;
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using ModelContextProtocol.Tests.Utils;
@@ -31,11 +32,11 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer
     {
         mcpServerBuilder.Services.Configure<McpServerOptions>(options =>
         {
-            options.TaskStore = new InMemoryMcpTaskStore
+            options.WithTasks(new InMemoryMcpTaskStore
             {
                 DefaultPollIntervalMs = 50,
                 DefaultTimeToLive = TimeSpan.FromSeconds(5),
-            };
+            });
         });
 
         mcpServerBuilder.WithTools([McpServerTool.Create(
@@ -132,10 +133,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(
@@ -275,10 +276,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([
diff --git a/tests/ModelContextProtocol.Tests/Server/TaskHandlerConfigurationValidationTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskHandlerConfigurationValidationTests.cs
deleted file mode 100644
index 8cd2f7839..000000000
--- a/tests/ModelContextProtocol.Tests/Server/TaskHandlerConfigurationValidationTests.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using ModelContextProtocol.Protocol;
-using ModelContextProtocol.Server;
-using System.Runtime.InteropServices;
-
-namespace ModelContextProtocol.Tests.Server;
-
-/// <summary>
-/// Verifies the runtime validation that fires when a handler opts into task-augmented execution
-/// (returns a <see cref="CreateTaskResult"/>) without the server having any <c>tasks/get</c>
-/// handler registered.
-/// </summary>
-public class TaskHandlerConfigurationValidationTests : ClientServerTestBase
-{
-    public TaskHandlerConfigurationValidationTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
-    {
-#if !NET
-        Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587");
-#endif
-    }
-
-    protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder)
-    {
-        mcpServerBuilder.Services.Configure<McpServerOptions>(options =>
-        {
-            options.Capabilities ??= new ServerCapabilities();
-
-            // Intentionally configure a task-augmented handler without TaskStore or any of the
-            // task lifecycle handlers (GetTaskHandler/UpdateTaskHandler/CancelTaskHandler).
-            options.Handlers.CallToolWithTaskHandler = (context, cancellationToken) =>
-                new ValueTask<ResultOrCreatedTask<CallToolResult>>(new CreateTaskResult
-                {
-                    TaskId = "orphan-task",
-                    Status = McpTaskStatus.Working,
-                    CreatedAt = DateTimeOffset.UtcNow,
-                    LastUpdatedAt = DateTimeOffset.UtcNow,
-                });
-        });
-    }
-
-    [Fact]
-    public async Task CallTool_ReturningCreateTaskResult_WithoutTasksGetHandler_ThrowsAtRequestTime()
-    {
-        await using var client = await CreateMcpClientForServer();
-
-        // Client surfaces a generic protocol error (the server intentionally redacts the message
-        // on the wire), so use the base McpException type and confirm via server-side logs that
-        // the originating exception was the misconfiguration guard.
-        await Assert.ThrowsAnyAsync<McpException>(async () =>
-            await client.CallToolAsync(
-                new CallToolRequestParams { Name = "anything" },
-                cancellationToken: TestContext.Current.CancellationToken));
-
-        Assert.Contains(MockLoggerProvider.LogMessages, log =>
-            log.Exception is InvalidOperationException ioe &&
-            ioe.Message.Contains("tasks/get", StringComparison.Ordinal) &&
-            ioe.Message.Contains("CreateTaskResult", StringComparison.Ordinal));
-    }
-}
diff --git a/tests/ModelContextProtocol.Tests/Server/TaskPollStuckDetectorTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskPollStuckDetectorTests.cs
index 1d17be223..0646edfd0 100644
--- a/tests/ModelContextProtocol.Tests/Server/TaskPollStuckDetectorTests.cs
+++ b/tests/ModelContextProtocol.Tests/Server/TaskPollStuckDetectorTests.cs
@@ -1,8 +1,10 @@
 using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol.Client;
+using ModelContextProtocol.Extensions.Tasks;
 using ModelContextProtocol.Protocol;
 using ModelContextProtocol.Server;
 using System.Runtime.InteropServices;
+using System.Text.Json;
 
 #pragma warning disable MCPEXP001
 
@@ -15,7 +17,7 @@ namespace ModelContextProtocol.Tests.Server;
 /// </summary>
 public class TaskPollStuckDetectorTests : ClientServerTestBase
 {
-    private int _pollCount = 0;
+    private readonly StuckInputRequiredStore _store = new();
 
     public TaskPollStuckDetectorTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
     {
@@ -30,101 +32,126 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer
         {
             options.Capabilities ??= new ServerCapabilities();
 
-            // CallTool always returns a CreateTaskResult with a tiny poll interval so the
-            // test exercises the threshold in well under a second.
-            options.Handlers.CallToolWithTaskHandler = (context, cancellationToken) =>
-            {
-                var taskId = Guid.NewGuid().ToString("N");
-                return new ValueTask<ResultOrCreatedTask<CallToolResult>>(new CreateTaskResult
-                {
-                    TaskId = taskId,
-                    Status = McpTaskStatus.InputRequired,
-                    CreatedAt = DateTimeOffset.UtcNow,
-                    LastUpdatedAt = DateTimeOffset.UtcNow,
-                    PollIntervalMs = 5,
-                    ResultType = "task",
-                });
-            };
-
-            // GetTask always reports InputRequired with NO outstanding input requests — the
-            // misbehaving-server condition the stuck-detector exists to break out of.
-            options.Handlers.GetTaskHandler = (context, cancellationToken) =>
-            {
-                Interlocked.Increment(ref _pollCount);
-
-                return new ValueTask<GetTaskResult>(new InputRequiredTaskResult
-                {
-                    TaskId = context.Params!.TaskId,
-                    CreatedAt = DateTimeOffset.UtcNow,
-                    LastUpdatedAt = DateTimeOffset.UtcNow,
-                    PollIntervalMs = 5,
-                    InputRequests = new Dictionary<string, InputRequest>(),
-                    ResultType = "complete",
-                });
-            };
-
-            // CancelTask must succeed since the client issues a best-effort cancel when it
-            // gives up; otherwise the cancel failure would mask the real exception.
-            options.Handlers.CancelTaskHandler = (context, cancellationToken) =>
-                new ValueTask<CancelTaskResult>(new CancelTaskResult { ResultType = "complete" });
-
-            // UpdateTask is never invoked in this scenario (there are no input requests to resolve)
-            // but must be present so the handler-configuration validation passes.
-            options.Handlers.UpdateTaskHandler = (context, cancellationToken) =>
-                new ValueTask<UpdateTaskResult>(new UpdateTaskResult { ResultType = "complete" });
+            // The store always reports the task as InputRequired with no outstanding input
+            // requests, which is the misbehaving-server condition the stuck-detector exists
+            // to break out of.
+            options.WithTasks(_store);
         });
+
+        mcpServerBuilder.WithTools([McpServerTool.Create(
+            (CancellationToken ct) => "ok",
+            new() { Name = "any-tool" })]);
     }
 
     [Fact]
-    public async Task CallToolAsync_TaskStuckInInputRequired_WithoutNewRequests_ThrowsAfterThreshold()
+    public async Task CallToolAsTaskAsync_TaskStuckInInputRequired_WithoutNewRequests_ThrowsAfterThreshold()
     {
         await using var client = await CreateMcpClientForServer();
         var ct = TestContext.Current.CancellationToken;
 
         var ex = await Assert.ThrowsAsync<McpException>(async () =>
-            await client.CallToolAsync(new CallToolRequestParams { Name = "any-tool" }, ct));
+            await client.CallToolAsTaskAsync(new CallToolRequestParams { Name = "any-tool" }, cancellationToken: ct));
 
         Assert.Contains(McpTaskStatus.InputRequired.ToString(), ex.Message);
         Assert.Contains("consecutive polls", ex.Message);
 
-        Assert.Equal(60, _pollCount);
+        Assert.Equal(McpClientTasksExtensions.DefaultMaxConsecutiveStuckPolls, _store.PollCount);
     }
 
     [Fact]
-    public async Task CallToolAsync_StuckDetector_HonorsConfiguredThreshold()
+    public async Task CallToolAsTaskAsync_StuckDetector_HonorsConfiguredThreshold()
     {
-        // Verifies McpClientOptions.MaxConsecutiveStuckPolls is plumbed into PollTaskToCompletionAsync:
+        // Verifies the maxConsecutiveStuckPolls argument is plumbed into PollTaskToCompletionAsync:
         // a smaller configured threshold is surfaced verbatim in the McpException message.
         const int CustomThreshold = 3;
 
-        await using var client = await CreateMcpClientForServer(new McpClientOptions
-        {
-            MaxConsecutiveStuckPolls = CustomThreshold,
-        });
+        await using var client = await CreateMcpClientForServer();
         var ct = TestContext.Current.CancellationToken;
 
         var ex = await Assert.ThrowsAsync<McpException>(async () =>
-            await client.CallToolAsync(new CallToolRequestParams { Name = "any-tool" }, ct));
+            await client.CallToolAsTaskAsync(
+                new CallToolRequestParams { Name = "any-tool" },
+                maxConsecutiveStuckPolls: CustomThreshold,
+                cancellationToken: ct));
 
         // The message embeds the configured threshold, which is the strongest signal that the
-        // option value (not the 60-default constant) is what governed the loop.
+        // argument value (not the default constant) is what governed the loop.
         Assert.Contains($"{CustomThreshold} consecutive polls", ex.Message);
-        Assert.Equal(CustomThreshold, _pollCount);
+        Assert.Equal(CustomThreshold, _store.PollCount);
     }
 
     [Theory]
     [InlineData(0)]
     [InlineData(-1)]
     [InlineData(int.MinValue)]
-    public void McpClientOptions_MaxConsecutiveStuckPolls_RejectsNonPositive(int value)
+    public async Task CallToolAsTaskAsync_MaxConsecutiveStuckPolls_RejectsNonPositive(int value)
     {
-        var options = new McpClientOptions();
-        Assert.Throws<ArgumentOutOfRangeException>(() => options.MaxConsecutiveStuckPolls = value);
+        await using var client = await CreateMcpClientForServer();
+        var ct = TestContext.Current.CancellationToken;
+
+        await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () =>
+            await client.CallToolAsTaskAsync(
+                new CallToolRequestParams { Name = "any-tool" },
+                maxConsecutiveStuckPolls: value,
+                cancellationToken: ct));
     }
 
     [Fact]
-    public void McpClientOptions_MaxConsecutiveStuckPolls_DefaultsTo60()
+    public void DefaultMaxConsecutiveStuckPolls_Is60()
+    {
+        Assert.Equal(60, McpClientTasksExtensions.DefaultMaxConsecutiveStuckPolls);
+    }
+
+    /// <summary>
+    /// A task store that always reports the task as <see cref="McpTaskStatus.InputRequired"/> with no
+    /// outstanding input requests, simulating a misbehaving server that never makes progress.
+    /// </summary>
+    private sealed class StuckInputRequiredStore : IMcpTaskStore
     {
-        Assert.Equal(60, new McpClientOptions().MaxConsecutiveStuckPolls);
+        private int _pollCount;
+
+        public int PollCount => Volatile.Read(ref _pollCount);
+
+        public event Action<InputResponseReceivedEventArgs>? InputResponseReceived
+        {
+            add { }
+            remove { }
+        }
+
+        public Task<McpTaskInfo> CreateTaskAsync(CancellationToken cancellationToken = default) =>
+            Task.FromResult(new McpTaskInfo(
+                Guid.NewGuid().ToString("N"),
+                McpTaskStatus.Working,
+                DateTimeOffset.UtcNow,
+                DateTimeOffset.UtcNow,
+                PollIntervalMs: 5));
+
+        public Task<McpTaskInfo?> GetTaskAsync(string taskId, CancellationToken cancellationToken = default)
+        {
+            Interlocked.Increment(ref _pollCount);
+
+            return Task.FromResult<McpTaskInfo?>(new McpTaskInfo(
+                taskId,
+                McpTaskStatus.InputRequired,
+                DateTimeOffset.UtcNow,
+                DateTimeOffset.UtcNow,
+                PollIntervalMs: 5,
+                InputRequests: new Dictionary<string, InputRequest>()));
+        }
+
+        public Task SetCompletedAsync(string taskId, JsonElement result, CancellationToken cancellationToken = default) =>
+            Task.CompletedTask;
+
+        public Task SetFailedAsync(string taskId, JsonElement error, CancellationToken cancellationToken = default) =>
+            Task.CompletedTask;
+
+        public Task<bool> SetCancelledAsync(string taskId, CancellationToken cancellationToken = default) =>
+            Task.FromResult(true);
+
+        public Task ResolveInputRequestsAsync(string taskId, IDictionary<string, InputResponse> inputResponses, CancellationToken cancellationToken = default) =>
+            Task.CompletedTask;
+
+        public Task SetInputRequestsAsync(string taskId, IDictionary<string, InputRequest> inputRequests, CancellationToken cancellationToken = default) =>
+            Task.CompletedTask;
     }
 }
diff --git a/tests/ModelContextProtocol.Tests/Server/TaskProtocolGatingTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskProtocolGatingTests.cs
index 7f9790526..2ef91cc43 100644
--- a/tests/ModelContextProtocol.Tests/Server/TaskProtocolGatingTests.cs
+++ b/tests/ModelContextProtocol.Tests/Server/TaskProtocolGatingTests.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;
@@ -34,10 +35,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(
@@ -157,10 +158,10 @@ public async Task LegacyClient_RawTasksGetRequest_ReturnsMethodNotFound()
         // gates tasks/* to the 2026-07-28 protocol and must reject this legacy request with MethodNotFound.
         var request = new JsonRpcRequest
         {
-            Method = RequestMethods.TasksGet,
+            Method = TaskMethods.Get,
             Params = JsonSerializer.SerializeToNode(
                 new GetTaskRequestParams { TaskId = "some-task-id" },
-                McpJsonUtilities.DefaultOptions),
+                McpTasksJsonUtilities.DefaultOptions),
         };
 
         var ex = await Assert.ThrowsAsync<McpProtocolException>(async () =>
diff --git a/tests/ModelContextProtocol.Tests/Server/TaskStoreOrphanedTaskTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskStoreOrphanedTaskTests.cs
deleted file mode 100644
index 303d16e17..000000000
--- a/tests/ModelContextProtocol.Tests/Server/TaskStoreOrphanedTaskTests.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using ModelContextProtocol.Client;
-using ModelContextProtocol.Protocol;
-using ModelContextProtocol.Server;
-using System.Runtime.InteropServices;
-using System.Text.Json;
-
-#pragma warning disable MCPEXP001
-
-namespace ModelContextProtocol.Tests.Server;
-
-/// <summary>
-/// Verifies that when both <see cref="McpServerOptions.TaskStore"/> and
-/// <see cref="McpServerHandlers.CallToolWithTaskHandler"/> are configured and the handler returns
-/// <see cref="CreateTaskResult"/> (IsTask = true), the store's pre-created task is failed with a
-/// clear error rather than being orphaned in <see cref="McpTaskStatus.Working"/> forever.
-/// </summary>
-public class TaskStoreOrphanedTaskTests : ClientServerTestBase
-{
-    public TaskStoreOrphanedTaskTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
-    {
-#if !NET
-        Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587");
-#endif
-    }
-
-    protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder)
-    {
-        mcpServerBuilder.Services.Configure<McpServerOptions>(options =>
-        {
-            options.Capabilities ??= new ServerCapabilities();
-            options.TaskStore = new InMemoryMcpTaskStore();
-
-            // Returning IsTask = true here while TaskStore is also configured is the
-            // misconfiguration the server must guard against.
-            options.Handlers.CallToolWithTaskHandler = (context, cancellationToken) =>
-                new ValueTask<ResultOrCreatedTask<CallToolResult>>(new CreateTaskResult
-                {
-                    TaskId = "user-task",
-                    Status = McpTaskStatus.Working,
-                    CreatedAt = DateTimeOffset.UtcNow,
-                    LastUpdatedAt = DateTimeOffset.UtcNow,
-                });
-        });
-    }
-
-    [Fact]
-    public async Task TaskStoreAndHandler_BothCreatingTasks_FailsStoreTaskWithClearError()
-    {
-        await using var client = await CreateMcpClientForServer();
-        var ct = TestContext.Current.CancellationToken;
-
-        // The store's task is created synchronously and its taskId returned to the client.
-        var augmented = await client.CallToolRawAsync(
-            new CallToolRequestParams { Name = "anything" }, ct);
-
-        Assert.True(augmented.IsTask);
-        var taskId = augmented.TaskCreated!.TaskId;
-
-        // Poll until the background runner observes the handler's IsTask=true and fails the
-        // store's task. Without the fix this would loop forever in Working.
-        GetTaskResult? taskResult = null;
-        for (int i = 0; i < 40; i++)
-        {
-            await Task.Delay(50, ct);
-            taskResult = await client.GetTaskAsync(taskId, ct);
-            if (taskResult is FailedTaskResult)
-            {
-                break;
-            }
-        }
-
-        var failed = Assert.IsType<FailedTaskResult>(taskResult);
-        Assert.Equal(JsonValueKind.Object, failed.Error.ValueKind);
-        Assert.Equal((int)McpErrorCode.InternalError, failed.Error.GetProperty("code").GetInt32());
-
-        var message = failed.Error.GetProperty("message").GetString();
-        Assert.NotNull(message);
-        Assert.Contains(nameof(McpServerOptions.TaskStore), message);
-        Assert.Contains(nameof(McpServerHandlers.CallToolWithTaskHandler), message);
-    }
-}