Gate built-in ping handler to legacy protocol versions

The ping RPC was removed in the draft 2026-07-28 revision (SEP-2575).
TypeScript and Go SDKs both reject ping under draft; C# was responding
to ping unconditionally with the comment 'must always be handled',
which was a holdover from the older spec.

The built-in handler now throws McpProtocolException(MethodNotFound)
for any per-request protocol version >= DraftProtocolVersion, falling
back to the session-level NegotiatedProtocolVersion when the per-request
_meta is absent (legacy sessions).

Liveness on draft sessions belongs to transport- and request-level
timeouts, not a removed MCP RPC.

Adds PingProtocolGatingTests covering:
* Ping under draft returns MethodNotFound
* Ping under legacy still succeeds

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

Author: halter73

src/ModelContextProtocol.Core/McpSessionHandler.cs

@@ -141,10 +141,25 @@ public McpSessionHandler(
         _outgoingMessageFilter = outgoingMessageFilter ?? (next => next);
         _logger = logger;
 
-        // Per the MCP spec, ping may be initiated by either party and must always be handled.
+        // ping was removed in the draft protocol revision (SEP-2575). Under draft, return
+        // MethodNotFound; under legacy, the per-spec behavior is to always answer with PingResult.
+        // Liveness on draft sessions belongs to transport- and request-level timeouts, not a
+        // dedicated MCP RPC.
         _requestHandlers.Set(
             RequestMethods.Ping,
-            (request, _, cancellationToken) => new ValueTask<PingResult>(new PingResult()),
+            (request, jsonRpcRequest, cancellationToken) =>
+            {
+                string? perRequestVersion = jsonRpcRequest?.Context?.ProtocolVersion ?? NegotiatedProtocolVersion;
+                if (perRequestVersion is not null &&
+                    StringComparer.Ordinal.Compare(perRequestVersion, DraftProtocolVersion) >= 0)
+                {
+                    throw new McpProtocolException(
+                        $"Method '{RequestMethods.Ping}' is not available on protocol version '{perRequestVersion}'.",
+                        McpErrorCode.MethodNotFound);
+                }
+
+                return new ValueTask<PingResult>(new PingResult());
+            },
             McpJsonUtilities.JsonContext.Default.JsonNode,
             McpJsonUtilities.JsonContext.Default.PingResult);
 

tests/ModelContextProtocol.Tests/Server/PingProtocolGatingTests.cs

@@ -0,0 +1,53 @@
+using Microsoft.Extensions.DependencyInjection;
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+
+namespace ModelContextProtocol.Tests.Server;
+
+/// <summary>
+/// Verifies that the built-in <c>ping</c> handler is gated by protocol version.
+/// SEP-2575 (the draft 2026-07-28 revision) removes <c>ping</c>; servers must
+/// respond with <c>-32601 MethodNotFound</c>. Legacy protocol versions still
+/// support <c>ping</c> per the spec.
+/// </summary>
+public sealed class PingProtocolGatingTests : ClientServerTestBase
+{
+    public PingProtocolGatingTests(ITestOutputHelper testOutputHelper)
+        : base(testOutputHelper, startServer: false)
+    {
+    }
+
+    protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder)
+    {
+    }
+
+    [Fact]
+    public async Task Ping_OnDraftSession_ReturnsMethodNotFound()
+    {
+        StartServer();
+        await using var client = await CreateMcpClientForServer(new McpClientOptions
+        {
+            ProtocolVersion = McpSession.DraftProtocolVersion,
+        });
+
+        var ex = await Assert.ThrowsAsync<McpProtocolException>(async () =>
+            await client.PingAsync(cancellationToken: TestContext.Current.CancellationToken));
+
+        Assert.Equal(McpErrorCode.MethodNotFound, ex.ErrorCode);
+    }
+
+    [Fact]
+    public async Task Ping_OnLegacySession_StillSucceeds()
+    {
+        // Default server config; client pinned to 2025-11-25.
+        StartServer();
+        await using var client = await CreateMcpClientForServer(new McpClientOptions
+        {
+            ProtocolVersion = "2025-11-25",
+        });
+
+        var result = await client.PingAsync(cancellationToken: TestContext.Current.CancellationToken);
+        Assert.NotNull(result);
+    }
+}