Make the interceptor's delivery capability explicit

An outgoing-request interceptor replaces the session's server-to-client
channel, so it can deliver sampling, roots, and elicitation requests even
when the underlying transport cannot. That is what lets background task
execution park a request in an IMcpTaskStore and have the client answer it
on a later, unrelated request, which does not depend on session affinity.

OutgoingRequestInterceptingMcpServer relied on inheriting the base
SupportsServerToClientRequests default to get this, while forwarding every
other member to the wrapped server. Make the override explicit so the
behavior is stated rather than implied, and add stateless coverage for
AsSamplingChatClient() and the generic ElicitAsync<T>(), which are the two
APIs that check the capability guard eagerly instead of routing through the
interceptor short-circuit.

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

Author: halter73

src/ModelContextProtocol.Core/Server/OutgoingRequestInterceptingMcpServer.cs

@@ -17,6 +17,11 @@ internal sealed class OutgoingRequestInterceptingMcpServer(
 
     public override ClientCapabilities? ClientCapabilities => server.ClientCapabilities;
 
+    // The interceptor replaces the session's server-to-client channel, so it can deliver requests even
+    // when the underlying transport cannot (for example a stateless HTTP request, where a background task
+    // parks the request in an IMcpTaskStore and the client answers it on a later, unrelated request).
+    internal override bool SupportsServerToClientRequests => true;
+
     public override Implementation? ClientInfo => server.ClientInfo;
 
     public override McpServerOptions ServerOptions => server.ServerOptions;

tests/ModelContextProtocol.AspNetCore.Tests/StatelessServerTests.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.AI;
 using Microsoft.Extensions.DependencyInjection;
 using ModelContextProtocol.AspNetCore.Tests.Utils;
 using ModelContextProtocol.Client;
@@ -9,6 +10,7 @@
 using System.Net;
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
 using System.Threading.Channels;
 
 namespace ModelContextProtocol.AspNetCore.Tests;
@@ -173,6 +175,24 @@ public async Task ClientCapabilities_AreAvailableFromInjectedServer()
             Assert.IsType<TextContentBlock>(Assert.Single(toolResponse.Content)).Text);
     }
 
+    [Fact]
+    public async Task InterceptedServerToClientRequests_Succeed_InStatelessMode()
+    {
+        await StartAsync();
+        var clientOptions = new McpClientOptions();
+        clientOptions.Handlers.SamplingHandler = (_, _, _) => throw new UnreachableException();
+        clientOptions.Handlers.ElicitationHandler = (_, _) => throw new UnreachableException();
+        await using var client = await ConnectMcpClientAsync(clientOptions);
+
+        var toolResponse = await client.CallToolAsync(
+            "testInterceptedRequests",
+            cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.Equal(
+            "intercepted-sample|Seattle",
+            Assert.IsType<TextContentBlock>(Assert.Single(toolResponse.Content)).Text);
+    }
+
     [Fact]
     public async Task UnsolicitedNotification_Fails_WithInvalidOperationException()
     {
@@ -654,6 +674,31 @@ public static string GetClientCapabilities(McpServer server) =>
             server.ClientCapabilities?.Roots is null ? "no-roots" : "roots",
             server.ClientCapabilities?.Elicitation is null ? "no-elicitation" : "elicitation");
 
+    [McpServerTool(Name = "testInterceptedRequests")]
+    public static async Task<string> TestInterceptedRequests(McpServer server)
+    {
+        // Background task execution replaces the server-to-client channel with an interceptor that parks the
+        // request in an IMcpTaskStore, so the client can answer it on a later, unrelated request. That does not
+        // depend on session affinity, which is why these requests are allowed through in stateless mode.
+#pragma warning disable MCPEXP002
+        var intercepted = server.WithOutgoingRequestInterceptor((method, _, _) => new(JsonNode.Parse(method switch
+        {
+            RequestMethods.SamplingCreateMessage =>
+                """{"role":"assistant","content":{"type":"text","text":"intercepted-sample"},"model":"test-model"}""",
+            RequestMethods.ElicitationCreate =>
+                """{"action":"accept","content":{"city":"Seattle"}}""",
+            _ => throw new UnreachableException(),
+        })));
+#pragma warning restore MCPEXP002
+
+        var samplingResponse = await intercepted.AsSamplingChatClient().GetResponseAsync("Where am I?");
+        var elicitResult = await intercepted.ElicitAsync<CityForm>(
+            "Which city?",
+            options: new() { JsonSerializerOptions = StatelessInterceptorJsonContext.Default.Options });
+
+        return $"{samplingResponse.Text}|{elicitResult.Content?.City}";
+    }
+
     [McpServerTool(Name = "testScope")]
     public static string? TestScope(ScopedService scopedService) => scopedService.State;
 
@@ -667,3 +712,12 @@ private class SynchronousProgress<T>(Action<T> handler) : IProgress<T>
         public void Report(T value) => handler(value);
     }
 }
+
+public class CityForm
+{
+    public string? City { get; set; }
+}
+
+[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
+[JsonSerializable(typeof(CityForm))]
+internal partial class StatelessInterceptorJsonContext : JsonSerializerContext;