Route SendRequestAsync through outgoing filters and add message filter tests

Fix McpSessionHandler.SendRequestAsync to route through the outgoing message
filter pipeline instead of calling SendToRelatedTransportAsync directly. This
makes server-originated JSON-RPC requests (elicitation/create,
sampling/createMessage, roots/list) visible to outgoing filters, matching the
documented behavior that filters see all outgoing messages.

Add AddOutgoingMessageFilter_Sees_ServerOriginatedRequests test to verify the
fix catches the regression via stream transport.

Add 5 message filter tests to MapMcpTests covering incoming filters, outgoing
filters, server-originated requests, filter ordering, and additional message
injection. These run across all HTTP transport variants (SSE, Streamable HTTP,
and Stateless) via the existing MapMcpSseTests, MapMcpStreamableHttpTests, and
MapMcpStatelessTests subclasses.

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

Author: halter73

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -585,7 +585,10 @@ public async Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest request, Canc
                 LogSendingRequest(EndpointName, request.Method);
             }
 
-            await SendToRelatedTransportAsync(request, cancellationToken).ConfigureAwait(false);
+            await _outgoingMessageFilter(async (msg, ct) =>
+            {
+                await SendToRelatedTransportAsync(msg, ct).ConfigureAwait(false);
+            })(request, cancellationToken).ConfigureAwait(false);
 
             // Now that the request has been sent, register for cancellation. If we registered before,
             // a cancellation request could arrive before the server knew about that request ID, in which

tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs

@@ -9,6 +9,7 @@
 using System.Diagnostics;
 using System.Net;
 using System.Security.Claims;
+using System.Text.Json.Nodes;
 
 namespace ModelContextProtocol.AspNetCore.Tests;
 
@@ -290,6 +291,225 @@ public async Task LongRunningToolCall_DoesNotTimeout_WhenNoEventStreamStore()
 
     }
 
+    [Fact]
+    public async Task IncomingFilter_SeesClientRequests()
+    {
+        var observedMethods = new List<string>();
+
+        Builder.Services.AddMcpServer()
+            .WithHttpTransport(ConfigureStateless)
+            .WithMessageFilters(filters => filters.AddIncomingFilter((next) => async (context, cancellationToken) =>
+            {
+                if (context.JsonRpcMessage is JsonRpcRequest request)
+                {
+                    observedMethods.Add(request.Method);
+                }
+
+                await next(context, cancellationToken);
+            }))
+            .WithTools<EchoHttpContextUserTools>();
+
+        Builder.Services.AddHttpContextAccessor();
+
+        await using var app = Builder.Build();
+        app.MapMcp();
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        await using var client = await ConnectAsync();
+
+        await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken);
+        await client.CallToolAsync("echo_with_user_name",
+            new Dictionary<string, object?> { ["message"] = "hi" },
+            cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.Contains(RequestMethods.Initialize, observedMethods);
+        Assert.Contains(RequestMethods.ToolsList, observedMethods);
+        Assert.Contains(RequestMethods.ToolsCall, observedMethods);
+    }
+
+    [Fact]
+    public async Task OutgoingFilter_SeesResponses()
+    {
+        var observedMessageTypes = new List<string>();
+
+        Builder.Services.AddMcpServer()
+            .WithHttpTransport(ConfigureStateless)
+            .WithMessageFilters(filters => filters.AddOutgoingFilter((next) => async (context, cancellationToken) =>
+            {
+                var typeName = context.JsonRpcMessage switch
+                {
+                    JsonRpcResponse r when r.Result is JsonObject obj && obj.ContainsKey("protocolVersion") => "initialize-response",
+                    JsonRpcResponse r when r.Result is JsonObject obj && obj.ContainsKey("tools") => "tools-list-response",
+                    JsonRpcResponse r when r.Result is JsonObject obj && obj.ContainsKey("content") => "tool-call-response",
+                    _ => null,
+                };
+
+                if (typeName is not null)
+                {
+                    observedMessageTypes.Add(typeName);
+                }
+
+                await next(context, cancellationToken);
+            }))
+            .WithTools<ClaimsPrincipalTools>();
+
+        await using var app = Builder.Build();
+        app.MapMcp();
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        await using var client = await ConnectAsync();
+
+        await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken);
+        await client.CallToolAsync("echo_claims_principal",
+            new Dictionary<string, object?> { ["message"] = "hi" },
+            cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.Contains("initialize-response", observedMessageTypes);
+        Assert.Contains("tools-list-response", observedMessageTypes);
+        Assert.Contains("tool-call-response", observedMessageTypes);
+    }
+
+    [Fact]
+    public async Task OutgoingFilter_SeesServerOriginatedRequests()
+    {
+        Assert.SkipWhen(Stateless, "Server-originated requests are not supported in stateless mode.");
+
+        var observedMethods = new List<string>();
+
+        Builder.Services.AddMcpServer()
+            .WithHttpTransport(ConfigureStateless)
+            .WithMessageFilters(filters => filters.AddOutgoingFilter((next) => async (context, cancellationToken) =>
+            {
+                if (context.JsonRpcMessage is JsonRpcRequest request)
+                {
+                    observedMethods.Add(request.Method);
+                }
+
+                await next(context, cancellationToken);
+            }))
+            .WithTools<SamplingRegressionTools>();
+
+        await using var app = Builder.Build();
+        app.MapMcp();
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        var clientOptions = new McpClientOptions
+        {
+            Capabilities = new() { Sampling = new() },
+            Handlers = new()
+            {
+                SamplingHandler = (_, _, _) => new(new CreateMessageResult
+                {
+                    Content = [new TextContentBlock { Text = "sampled response" }],
+                    Model = "test-model",
+                }),
+            },
+        };
+
+        await using var client = await ConnectAsync(clientOptions: clientOptions);
+
+        await client.CallToolAsync("sampling-tool",
+            new Dictionary<string, object?> { ["prompt"] = "Hello" },
+            cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.Contains(RequestMethods.SamplingCreateMessage, observedMethods);
+    }
+
+    [Fact]
+    public async Task OutgoingFilter_MultipleFilters_ExecuteInOrder()
+    {
+        var executionOrder = new List<string>();
+
+        Builder.Services.AddMcpServer()
+            .WithHttpTransport(ConfigureStateless)
+            .WithMessageFilters(filters =>
+            {
+                filters.AddOutgoingFilter((next) => async (context, cancellationToken) =>
+                {
+                    if (context.JsonRpcMessage is JsonRpcResponse r && r.Result is JsonObject obj && obj.ContainsKey("tools"))
+                    {
+                        executionOrder.Add("filter1-before");
+                    }
+
+                    await next(context, cancellationToken);
+
+                    if (context.JsonRpcMessage is JsonRpcResponse r2 && r2.Result is JsonObject obj2 && obj2.ContainsKey("tools"))
+                    {
+                        executionOrder.Add("filter1-after");
+                    }
+                });
+
+                filters.AddOutgoingFilter((next) => async (context, cancellationToken) =>
+                {
+                    if (context.JsonRpcMessage is JsonRpcResponse r && r.Result is JsonObject obj && obj.ContainsKey("tools"))
+                    {
+                        executionOrder.Add("filter2-before");
+                    }
+
+                    await next(context, cancellationToken);
+
+                    if (context.JsonRpcMessage is JsonRpcResponse r2 && r2.Result is JsonObject obj2 && obj2.ContainsKey("tools"))
+                    {
+                        executionOrder.Add("filter2-after");
+                    }
+                });
+            })
+            .WithTools<ClaimsPrincipalTools>();
+
+        await using var app = Builder.Build();
+        app.MapMcp();
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        await using var client = await ConnectAsync();
+
+        await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.Equal(["filter1-before", "filter2-before", "filter2-after", "filter1-after"], executionOrder);
+    }
+
+    [Fact]
+    public async Task OutgoingFilter_CanSendAdditionalMessages()
+    {
+        Builder.Services.AddMcpServer()
+            .WithHttpTransport(ConfigureStateless)
+            .WithMessageFilters(filters => filters.AddOutgoingFilter((next) => async (context, cancellationToken) =>
+            {
+                if (context.JsonRpcMessage is JsonRpcResponse response &&
+                    response.Result is JsonObject result && result.ContainsKey("tools"))
+                {
+                    var extraNotification = new JsonRpcNotification
+                    {
+                        Method = "test/extra",
+                        Params = new JsonObject { ["message"] = "injected" },
+                        Context = new JsonRpcMessageContext { RelatedTransport = context.JsonRpcMessage.Context?.RelatedTransport },
+                    };
+
+                    await next(new MessageContext(context.Server, extraNotification), cancellationToken);
+                }
+
+                await next(context, cancellationToken);
+            }))
+            .WithTools<ClaimsPrincipalTools>();
+
+        await using var app = Builder.Build();
+        app.MapMcp();
+        await app.StartAsync(TestContext.Current.CancellationToken);
+
+        await using var client = await ConnectAsync();
+
+        var extraReceived = new TaskCompletionSource<string?>(TaskCreationOptions.RunContinuationsAsynchronously);
+        await using var registration = client.RegisterNotificationHandler("test/extra", (notification, _) =>
+        {
+            extraReceived.TrySetResult(notification.Params?["message"]?.GetValue<string>());
+            return default;
+        });
+
+        await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken);
+
+        var extraMessage = await extraReceived.Task.WaitAsync(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+        Assert.Equal("injected", extraMessage);
+    }
+
     private ClaimsPrincipal CreateUser(string name)
         => new(new ClaimsIdentity(
             [new Claim("name", name), new Claim(ClaimTypes.NameIdentifier, name)],

tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsMessageFilterTests.cs

@@ -428,6 +428,46 @@ public async Task AddOutgoingMessageFilter_Can_Send_Additional_Messages()
         Assert.Equal("extra", extraMessage);
     }
 
+    [Fact]
+    public async Task AddOutgoingMessageFilter_Sees_ServerOriginatedRequests()
+    {
+        var observedMethods = new List<string>();
+
+        McpServerBuilder
+            .WithMessageFilters(filters => filters.AddOutgoingFilter((next) => async (context, cancellationToken) =>
+            {
+                if (context.JsonRpcMessage is JsonRpcRequest request)
+                {
+                    observedMethods.Add(request.Method);
+                }
+
+                await next(context, cancellationToken);
+            }))
+            .WithTools<SamplingTool>();
+
+        StartServer();
+
+        var clientOptions = new McpClientOptions
+        {
+            Capabilities = new() { Sampling = new() },
+            Handlers = new()
+            {
+                SamplingHandler = (_, _, _) => new(new CreateMessageResult
+                {
+                    Content = [new TextContentBlock { Text = "sampled" }],
+                    Model = "test-model",
+                }),
+            },
+        };
+
+        await using McpClient client = await CreateMcpClientForServer(clientOptions);
+
+        await client.CallToolAsync("sampling-tool", new Dictionary<string, object?> { ["prompt"] = "Hello" },
+            cancellationToken: TestContext.Current.CancellationToken);
+
+        Assert.Contains(RequestMethods.SamplingCreateMessage, observedMethods);
+    }
+
     [Fact]
     public async Task AddIncomingMessageFilter_Items_Flow_To_Request_Filters()
     {
@@ -644,7 +684,6 @@ public async Task AddIncomingMessageFilter_Items_Flow_Through_Multiple_Request_F
         Assert.Equal("modifiedByFilter1", observedValues[1]);
     }
 
-    [McpServerToolType]
     public sealed class TestTool
     {
         [McpServerTool]
@@ -654,7 +693,6 @@ public static string TestToolMethod()
         }
     }
 
-    [McpServerPromptType]
     public sealed class TestPrompt
     {
         [McpServerPrompt]
@@ -668,7 +706,6 @@ public static Task<GetPromptResult> TestPromptMethod()
         }
     }
 
-    [McpServerResourceType]
     public sealed class TestResource
     {
         [McpServerResource(UriTemplate = "test://resource/{id}")]
@@ -678,7 +715,6 @@ public static string TestResourceMethod(string id)
         }
     }
 
-    [McpServerToolType]
     public sealed class ProgressTool
     {
         [McpServerTool(Name = "progress-tool")]
@@ -708,7 +744,6 @@ public static async Task<string> ReportProgress(
         }
     }
 
-    [McpServerToolType]
     public sealed class SimpleTool
     {
         [McpServerTool(Name = "simple-tool")]
@@ -717,4 +752,19 @@ public static string Execute()
             return "success";
         }
     }
+
+    public sealed class SamplingTool
+    {
+        [McpServerTool(Name = "sampling-tool")]
+        public static async Task<string> SampleAsync(McpServer server, string prompt, CancellationToken cancellationToken)
+        {
+            var result = await server.SampleAsync(new CreateMessageRequestParams
+            {
+                Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = prompt }] }],
+                MaxTokens = 100,
+            }, cancellationToken);
+
+            return $"Sampled: {Assert.IsType<TextContentBlock>(Assert.Single(result.Content)).Text}";
+        }
+    }
 }