Add generic public seams to Core for Tasks extension extraction

- Add ResultOrAlternate<TResult> replacing task-specific types in server pipeline
- Add McpServerRequestHandler for custom request handler registration (seam #1)
- Add McpServerOptions.RequestHandlers property with wiring in McpServerImpl
- Rename CallToolWithTaskHandler/Filters to CallToolWithAlternateHandler/Filters
- Rename SetTaskAugmented to SetWithAlternate (remove tasks/get guard)
- Rename InvokeToolAsTask to InvokeToolWithAlternate
- Rename BuildInitialTaskToolFilter to BuildInitialAlternateToolFilter
- Make McpClient.ResolveInputRequestsAsync public (seam #4)
- Update test references to use new names
- Adapt TaskHandlerConfigurationValidationTests for removed guard

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

Author: jeffhandley

src/ModelContextProtocol.Core/Client/McpClient.cs

@@ -82,7 +82,8 @@ 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(
+    [Experimental(Experimentals.Extensions_DiagnosticId, UrlFormat = Experimentals.Extensions_Url)]
+    public abstract ValueTask<IDictionary<string, InputResponse>> ResolveInputRequestsAsync(
         IDictionary<string, InputRequest> inputRequests, CancellationToken cancellationToken);
 
     /// <summary>

src/ModelContextProtocol.Core/Client/McpClientImpl.cs

@@ -182,7 +182,7 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not
     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)
     {

src/ModelContextProtocol.Core/Protocol/ResultOrAlternate.cs

@@ -0,0 +1,86 @@
+using System.Text.Json.Serialization.Metadata;
+
+namespace ModelContextProtocol.Protocol;
+
+/// <summary>
+/// Represents the result of a request that may return either the standard result or an alternate
+/// <see cref="Result"/> subtype for scenarios like asynchronous task execution.
+/// </summary>
+/// <typeparam name="TResult">The standard result type for the request (e.g., <see cref="CallToolResult"/>).</typeparam>
+/// <remarks>
+/// <para>
+/// Extensions that augment request handling (such as the Tasks extension) use this type to indicate
+/// that the server returned an alternate result instead of the normal one. The alternate carries its
+/// own <see cref="JsonTypeInfo"/> so the transport layer can serialize it without compile-time knowledge
+/// of the concrete type.
+/// </para>
+/// <para>
+/// Use <see cref="IsAlternate"/> to determine which variant was returned, then access either
+/// <see cref="Result"/> for the immediate result or <see cref="Alternate"/> for the alternate.
+/// </para>
+/// </remarks>
+public class ResultOrAlternate<TResult> where TResult : Result
+{
+    private readonly TResult? _result;
+    private readonly Result? _alternate;
+    private readonly JsonTypeInfo? _alternateTypeInfo;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ResultOrAlternate{TResult}"/> with an immediate result.
+    /// </summary>
+    /// <param name="result">The standard result returned by the server.</param>
+    public ResultOrAlternate(TResult result)
+    {
+        Throw.IfNull(result);
+        _result = result;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ResultOrAlternate{TResult}"/> with an alternate result.
+    /// </summary>
+    /// <param name="alternate">The alternate result.</param>
+    /// <param name="alternateTypeInfo">The <see cref="JsonTypeInfo"/> used to serialize the alternate result.</param>
+    public ResultOrAlternate(Result alternate, JsonTypeInfo alternateTypeInfo)
+    {
+        Throw.IfNull(alternate);
+        Throw.IfNull(alternateTypeInfo);
+        _alternate = alternate;
+        _alternateTypeInfo = alternateTypeInfo;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether the server returned an alternate result instead of the standard result.
+    /// </summary>
+    public bool IsAlternate => _alternate is not null;
+
+    /// <summary>
+    /// Gets the immediate result, or <see langword="null"/> if the server returned an alternate.
+    /// </summary>
+    public TResult? Result => _result;
+
+    /// <summary>
+    /// Gets the alternate result, or <see langword="null"/> if the server returned the standard result.
+    /// </summary>
+    public Result? Alternate => _alternate;
+
+    /// <summary>
+    /// Gets the <see cref="JsonTypeInfo"/> for serializing the alternate result, or <see langword="null"/>
+    /// if the server returned the standard result.
+    /// </summary>
+    public JsonTypeInfo? AlternateTypeInfo => _alternateTypeInfo;
+
+    /// <summary>
+    /// Implicitly converts a <typeparamref name="TResult"/> to a <see cref="ResultOrAlternate{TResult}"/>
+    /// wrapping the immediate result.
+    /// </summary>
+    /// <param name="result">The result to wrap.</param>
+    public static implicit operator ResultOrAlternate<TResult>(TResult result) => new(result);
+
+    /// <summary>
+    /// Implicitly converts a <see cref="CreateTaskResult"/> to a <see cref="ResultOrAlternate{TResult}"/>
+    /// wrapping the task handle as an alternate result using the default serialization context.
+    /// </summary>
+    /// <param name="taskCreated">The task creation result to wrap.</param>
+    public static implicit operator ResultOrAlternate<TResult>(CreateTaskResult taskCreated) =>
+        new(taskCreated, McpJsonUtilities.JsonContext.Default.CreateTaskResult);
+}

src/ModelContextProtocol.Core/RequestHandlers.cs

@@ -47,44 +47,29 @@ public void Set<TParams, TResult>(
     }
 
     /// <summary>
-    /// Registers a handler that may return either a standard result or a <see cref="CreateTaskResult"/>
-    /// for task-augmented execution.
+    /// Registers a handler that may return either a standard result or an alternate <see cref="Result"/>
+    /// subtype for scenarios like task-augmented execution.
     /// </summary>
-    public void SetTaskAugmented<TParams, TResult>(
+    public void SetWithAlternate<TParams, TResult>(
         string method,
-        Func<TParams, JsonRpcRequest, CancellationToken, ValueTask<ResultOrCreatedTask<TResult>>> handler,
+        Func<TParams, JsonRpcRequest, CancellationToken, ValueTask<ResultOrAlternate<TResult>>> handler,
         JsonTypeInfo<TParams> requestTypeInfo,
-        JsonTypeInfo<TResult> responseTypeInfo,
-        JsonTypeInfo<CreateTaskResult> taskResultTypeInfo)
+        JsonTypeInfo<TResult> responseTypeInfo)
         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)
+            if (augmented.IsAlternate)
             {
-                // 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.Alternate!, augmented.AlternateTypeInfo!);
             }
 
             return JsonSerializer.SerializeToNode(augmented.Result!, responseTypeInfo);

src/ModelContextProtocol.Core/Server/McpRequestFilters.cs

@@ -42,7 +42,7 @@ public IList<McpRequestFilter<ListToolsRequestParams, ListToolsResult>> ListTool
     /// <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,
+    /// Cannot be used together with <see cref="CallToolWithAlternateFilters"/>. If both are non-empty at configuration time,
     /// an <see cref="InvalidOperationException"/> will be thrown.
     /// </para>
     /// </remarks>
@@ -57,21 +57,21 @@ public IList<McpRequestFilter<CallToolRequestParams, CallToolResult>> CallToolFi
     }
 
     /// <summary>
-    /// Gets or sets the filters for the call-tool handler pipeline with task support.
+    /// Gets or sets the filters for the call-tool handler pipeline with alternate result 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.
+    /// These filters wrap the alternate-result call-tool handler whose return type is
+    /// <see cref="ResultOrAlternate{TResult}"/>. Use these filters when the server's tool pipeline
+    /// supports returning either an immediate <see cref="CallToolResult"/> or an alternate <see cref="Result"/>
+    /// subtype 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
+    public IList<McpRequestFilter<CallToolRequestParams, ResultOrAlternate<CallToolResult>>> CallToolWithAlternateFilters
     {
         get => field ??= [];
         set