Address tarekgh PR review feedback

- McpSessionHandler.SendRequestAsync no longer double-wraps SendToRelatedTransportAsync in _outgoingMessageFilter and no longer duplicates the per-request logging that SendToRelatedTransportAsync already emits. Restores main's once-per-send semantics.
- McpClientImpl.ResolveInputRequestAsync gracefully handles roots/list InputRequests with no params (ListRootsRequestParams is optional per spec) by falling back to a default instance, matching the server-side resolver.
- Rename local var (McpClientImpl) and parameter (McpServerImpl.SerializeInputRequiredResult) from PascalCase 'InputRequiredResult' to camelCase 'inputRequiredResult'.
- StreamableHttpHandler.ValidateProtocolVersionHeader restored to private static (uses only a const and a static field; no instance state).
- Tighten InputRequiredResult XML doc to note that this SDK currently only wires the MRTR interceptor into tools/call, even though SEP-2322 defines the wire format for prompts/get and resources/read too.
- Tighten outgoing- and incoming-filter tests (AddOutgoingMessageFilter_Sees_Responses_Notifications_And_Requests, OutgoingFilter_SeesResponsesAndRequests, AddIncomingMessageFilter_Intercepts_Request_Messages, and AddIncomingMessageFilter_Multiple_Filters_Execute_In_Order) from substring/Contains/IndexOf checks to strict per-category counts. The substring assertions passed even when SendRequestAsync invoked the outgoing filter twice per request, so the regression went undetected; the new counts catch it (sampling/createMessage and tool-call response counts double when the bug is present). The symmetric incoming-side tightening guards against an analogous future regression on the receive pipeline.

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

Author: halter73

src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs

@@ -548,7 +548,7 @@ internal static Task RunSessionAsync(HttpContext httpContext, McpServer session,
     /// Validates the MCP-Protocol-Version header if present. A missing header is allowed for backwards compatibility,
     /// but an invalid or unsupported value must be rejected with 400 Bad Request per the MCP spec.
     /// </summary>
-    private bool ValidateProtocolVersionHeader(HttpContext context, out string? errorMessage)
+    private static bool ValidateProtocolVersionHeader(HttpContext context, out string? errorMessage)
     {
         var protocolVersionHeader = context.Request.Headers[McpProtocolVersionHeaderName].ToString();
         if (!string.IsNullOrEmpty(protocolVersionHeader) &&

src/ModelContextProtocol.Core/Client/McpClientImpl.cs

@@ -639,8 +639,8 @@ private async Task<InputResponse> ResolveInputRequestAsync(InputRequest inputReq
             case RequestMethods.RootsList:
                 if (_options.Handlers.RootsHandler is { } rootsHandler)
                 {
-                    var rootsParams = inputRequest.RootsParams
-                        ?? throw new McpException($"Failed to deserialize roots parameters from MRTR input request.");
+                    // ListRootsRequest params are optional per the spec, so fall back to an empty params instance.
+                    var rootsParams = inputRequest.RootsParams ?? new ListRootsRequestParams();
                     var result = await rootsHandler(rootsParams, cancellationToken).ConfigureAwait(false);
                     return InputResponse.FromRootsResult(result);
                 }
@@ -859,10 +859,10 @@ request.Params is System.Text.Json.Nodes.JsonObject paramsObjForHeaders &&
             {
                 WarnIfInputRequiredResultOnNonMrtrSession(request.Method);
 
-                var InputRequiredResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.JsonContext.Default.InputRequiredResult)
+                var inputRequiredResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.JsonContext.Default.InputRequiredResult)
                     ?? throw new JsonException("Failed to deserialize InputRequiredResult.");
 
-                if (InputRequiredResult.InputRequests is { Count: > 0 } inputRequests)
+                if (inputRequiredResult.InputRequests is { Count: > 0 } inputRequests)
                 {
                     IDictionary<string, InputResponse> inputResponses =
                         await ResolveInputRequestsAsync(inputRequests, cancellationToken).ConfigureAwait(false);
@@ -873,18 +873,18 @@ request.Params is System.Text.Json.Nodes.JsonObject paramsObjForHeaders &&
                     paramsObj["inputResponses"] = JsonSerializer.SerializeToNode(
                         inputResponses, McpJsonUtilities.JsonContext.Default.IDictionaryStringInputResponse);
 
-                    if (InputRequiredResult.RequestState is { } requestState)
+                    if (inputRequiredResult.RequestState is { } requestState)
                     {
                         paramsObj["requestState"] = requestState;
                     }
 
                     request = new JsonRpcRequest { Method = request.Method, Params = paramsObj, Context = request.Context };
                 }
-                else if (InputRequiredResult.RequestState is not null)
+                else if (inputRequiredResult.RequestState is not null)
                 {
                     // No input requests but has requestState (e.g., load shedding) — just retry with state.
                     var paramsObj = request.Params?.DeepClone() as JsonObject ?? new JsonObject();
-                    paramsObj["requestState"] = InputRequiredResult.RequestState;
+                    paramsObj["requestState"] = inputRequiredResult.RequestState;
                     paramsObj.Remove("inputResponses");
 
                     request = new JsonRpcRequest { Method = request.Method, Params = paramsObj, Context = request.Context };

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -591,16 +591,7 @@ public async Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest request, Canc
                 AddTags(ref tags, activity, request, method, target);
             }
 
-            if (_logger.IsEnabled(LogLevel.Trace))
-            {
-                LogSendingRequestSensitive(EndpointName, request.Method, JsonSerializer.Serialize(request, McpJsonUtilities.JsonContext.Default.JsonRpcMessage));
-            }
-            else
-            {
-                LogSendingRequest(EndpointName, request.Method);
-            }
-
-            await _outgoingMessageFilter(SendToRelatedTransportAsync)(request, cancellationToken).ConfigureAwait(false);
+            await SendToRelatedTransportAsync(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

src/ModelContextProtocol.Core/Protocol/InputRequiredResult.cs

@@ -9,9 +9,13 @@ namespace ModelContextProtocol.Protocol;
 /// </summary>
 /// <remarks>
 /// <para>
-/// An <see cref="InputRequiredResult"/> is returned in response to a client-initiated request (such as
-/// <see cref="RequestMethods.ToolsCall"/> or <see cref="RequestMethods.PromptsGet"/>) when the server
-/// needs the client to fulfill one or more server-initiated requests before it can produce a final result.
+/// An <see cref="InputRequiredResult"/> is returned in response to a client-initiated request when
+/// the server needs the client to fulfill one or more server-initiated requests before it can produce
+/// a final result. Per SEP-2322 the wire format is valid for <see cref="RequestMethods.ToolsCall"/>,
+/// <see cref="RequestMethods.PromptsGet"/>, and <c>resources/read</c>, but this SDK currently only wires
+/// the MRTR interceptor into <see cref="RequestMethods.ToolsCall"/>; throwing
+/// <see cref="InputRequiredException"/> from a prompts or resources handler will surface as an internal
+/// error until the other methods are opted in.
 /// </para>
 /// <para>
 /// At least one of <see cref="InputRequests"/> or <see cref="RequestState"/> must be present.

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -1318,8 +1318,8 @@ private static async Task<InputResponse> ResolveInputRequestAsync(McpServer dest
         }
     }
 
-    private static JsonNode? SerializeInputRequiredResult(InputRequiredResult InputRequiredResult) =>
-        JsonSerializer.SerializeToNode(InputRequiredResult, McpJsonUtilities.JsonContext.Default.InputRequiredResult);
+    private static JsonNode? SerializeInputRequiredResult(InputRequiredResult inputRequiredResult) =>
+        JsonSerializer.SerializeToNode(inputRequiredResult, McpJsonUtilities.JsonContext.Default.InputRequiredResult);
 
     [LoggerMessage(Level = LogLevel.Error, Message = "\"{ToolName}\" threw an unhandled exception.")]
     private partial void ToolCallError(string toolName, Exception exception);

tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs

@@ -385,10 +385,12 @@ await client.CallToolAsync("sampling-tool",
             new Dictionary<string, object?> { ["prompt"] = "Hello" },
             cancellationToken: TestContext.Current.CancellationToken);
 
-        Assert.Contains("initialize-response", observedMessageTypes);
-        Assert.Contains("tools-list-response", observedMessageTypes);
-        Assert.Contains("tool-call-response", observedMessageTypes);
-        Assert.Contains($"request:{RequestMethods.SamplingCreateMessage}", observedMessageTypes);
+        // Exact counts catch regressions where the outgoing filter pipeline gets applied more than once
+        // per outbound message (e.g., SendRequestAsync double-wrapping SendToRelatedTransportAsync).
+        Assert.Equal(1, observedMessageTypes.Count(m => m == "initialize-response"));
+        Assert.Equal(1, observedMessageTypes.Count(m => m == "tools-list-response"));
+        Assert.Equal(2, observedMessageTypes.Count(m => m == "tool-call-response")); // one per CallToolAsync
+        Assert.Equal(2, observedMessageTypes.Count(m => m == $"request:{RequestMethods.SamplingCreateMessage}")); // sampling-tool makes two SampleAsync calls
     }
 
     [Fact]

tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsMessageFilterTests.cs

@@ -87,8 +87,14 @@ public async Task AddIncomingMessageFilter_Intercepts_Request_Messages()
 
         await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken);
 
-        // The message filter should intercept JsonRpcRequest messages
-        Assert.Contains("JsonRpcRequest", messageTypes);
+        // The message filter should intercept JsonRpcRequest messages.
+        // Use strict counts so a regression that invokes the filter pipeline more than once per
+        // incoming message (analogous to the SendRequestAsync double-wrap regression on the outgoing
+        // side) would fail this test instead of slipping through Assert.Contains.
+        // A single ListToolsAsync drives three server-bound messages: initialize (request),
+        // notifications/initialized (notification), and tools/list (request).
+        Assert.Equal(2, messageTypes.Count(m => m == nameof(JsonRpcRequest)));
+        Assert.Equal(1, messageTypes.Count(m => m == nameof(JsonRpcNotification)));
     }
 
     [Fact]
@@ -142,6 +148,13 @@ public async Task AddIncomingMessageFilter_Multiple_Filters_Execute_In_Order()
         Assert.True(idx1Before < idx2Before);
         Assert.True(idx2Before < idx2After);
         Assert.True(idx2After < idx1After);
+
+        // Verify each filter ran exactly once per incoming message (initialize + notifications/initialized + tools/list).
+        // Strict counts catch regressions where the incoming filter pipeline gets invoked more than once per message.
+        Assert.Equal(3, logMessages.Count(m => m == "MessageFilter1 before"));
+        Assert.Equal(3, logMessages.Count(m => m == "MessageFilter2 before"));
+        Assert.Equal(3, logMessages.Count(m => m == "MessageFilter2 after"));
+        Assert.Equal(3, logMessages.Count(m => m == "MessageFilter1 after"));
     }
 
     [Fact]
@@ -372,15 +385,20 @@ public async Task AddOutgoingMessageFilter_Sees_Responses_Notifications_And_Requ
         await client.CallToolAsync("sampling-tool", new Dictionary<string, object?> { ["prompt"] = "Hello" },
             cancellationToken: TestContext.Current.CancellationToken);
 
+        // Exact counts catch regressions where the outgoing filter pipeline gets applied more than once
+        // per outbound message (e.g., SendRequestAsync double-wrapping SendToRelatedTransportAsync).
+        Assert.Equal(1, observedMessages.Count(m => m == "initialize"));
+        Assert.Equal(2, observedMessages.Count(m => m == "progress")); // ProgressTool sends two NotifyProgressAsync calls
+        Assert.Equal(2, observedMessages.Count(m => m == "response")); // one tool-call response per CallToolAsync
+        Assert.Equal(1, observedMessages.Count(m => m == $"request:{RequestMethods.SamplingCreateMessage}"));
+
+        // Preserve the original ordering intent: initialize first, then progress, then the final response.
         int initializeIndex = observedMessages.IndexOf("initialize");
         int progressIndex = observedMessages.IndexOf("progress");
         int responseIndex = observedMessages.LastIndexOf("response");
-        int requestIndex = observedMessages.IndexOf($"request:{RequestMethods.SamplingCreateMessage}");
 
-        Assert.True(initializeIndex >= 0);
         Assert.True(progressIndex > initializeIndex);
         Assert.True(responseIndex > progressIndex);
-        Assert.True(requestIndex >= 0);
     }
 
     [Fact]