Add draft-mode tests and update XML docs

Adds round-trip tests for the new draft protocol revision and updates the XML
documentation on ExperimentalProtocolVersion (client + server) to describe the
full SEP-2575 + SEP-2567 behavior (sessionless, handshake-less, server/discover,
MRTR-only server-to-client interactions, fallback to legacy initialize on
unsupported-version responses).

Tests added:
- DiscoverProtocolTests / SubscriptionsListenProtocolTests / DraftErrorDataTests:
  JSON-serialization round-trip coverage for the new protocol types and error
  data payloads.
- DraftConnectionTests: end-to-end client/server connection flow for draft
  client vs. draft server, draft client vs. legacy server (fallback), legacy
  client vs. draft server, and explicit server/discover invocation.
- DraftHttpHandlerTests (AspNetCore): HTTP-level checks that draft requests
  don't emit Mcp-Session-Id, unsupported protocol versions return -32004 with
  the structured supportedVersions payload, draft requests carrying an
  Mcp-Session-Id route through the legacy lookup, and draft GET/DELETE are
  rejected.

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

Author: halter73

src/ModelContextProtocol.Core/Client/McpClientOptions.cs

@@ -113,20 +113,35 @@ public McpClientHandlers Handlers
     public bool SendTaskStatusNotifications { get; set; } = true;
 
     /// <summary>
-    /// Gets or sets an experimental protocol version that enables draft protocol features such as
-    /// Multi Round-Trip Requests (MRTR).
+    /// Gets or sets an experimental protocol version that enables draft protocol features.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// When set, this version is used as the requested protocol version during initialization instead of
-    /// the latest stable version. The server must also have a matching <c>ExperimentalProtocolVersion</c>
-    /// configured for the experimental features to activate. If the server does not recognize the
-    /// experimental version, it will negotiate to the latest stable version and the client will work
-    /// normally without experimental features.
+    /// When set, this version is used as the requested protocol version during connection establishment
+    /// instead of the latest stable version. Under the draft revision (SEP-2575 + SEP-2567 + SEP-2322),
+    /// the client:
+    /// </para>
+    /// <list type="bullet">
+    /// <item><description>Skips the legacy <c>initialize</c> handshake. The server's capabilities, info,
+    /// and instructions are learned via the <c>server/discover</c> RPC instead.</description></item>
+    /// <item><description>Carries <c>protocolVersion</c>, <c>clientInfo</c>, and <c>clientCapabilities</c>
+    /// in the per-request <c>_meta</c> field on every request, replacing what the handshake previously
+    /// negotiated once.</description></item>
+    /// <item><description>Does not include the <c>Mcp-Session-Id</c> header on HTTP requests, and does
+    /// not expect one in responses. The protocol is sessionless at every layer.</description></item>
+    /// <item><description>Uses MRTR (<see cref="IncompleteResult"/>) for server-initiated sampling,
+    /// elicitation, and roots requests instead of standalone server-to-client JSON-RPC requests.</description></item>
+    /// </list>
+    /// <para>
+    /// If the server does not support the requested experimental version (either it returns a
+    /// <see cref="McpErrorCode.UnsupportedProtocolVersion"/> error or its <c>server/discover</c> reply
+    /// omits the version), the client falls back to the legacy <c>initialize</c> handshake with the
+    /// highest mutually-supported stable version.
     /// </para>
     /// <para>
     /// This property is intended for proof-of-concept and testing of draft MCP specification features
-    /// that have not yet been ratified.
+    /// that have not yet been ratified. The legacy stateful interaction model continues to work for
+    /// clients and servers that do not opt in.
     /// </para>
     /// </remarks>
     [Experimental(Experimentals.Mrtr_DiagnosticId, UrlFormat = Experimentals.Mrtr_Url)]

src/ModelContextProtocol.Core/Server/McpServerOptions.cs

@@ -240,15 +240,33 @@ public McpServerFilters Filters
     public bool SendTaskStatusNotifications { get; set; }
 
     /// <summary>
-    /// Gets or sets an experimental protocol version that enables draft protocol features such as
-    /// Multi Round-Trip Requests (MRTR).
+    /// Gets or sets an experimental protocol version that enables draft protocol features.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// When set, this version is accepted from clients during protocol version negotiation, and MRTR
-    /// is activated when the negotiated version matches. If a client does not request this version,
-    /// the server negotiates to the latest stable version and uses standard server-to-client JSON-RPC
-    /// requests for sampling and elicitation.
+    /// When set, this version is accepted from clients in addition to
+    /// <see cref="McpSessionHandler.SupportedProtocolVersions"/>. The server advertises it in
+    /// <c>server/discover</c> replies and reports it through the <c>MCP-Protocol-Version</c> header
+    /// during version negotiation.
+    /// </para>
+    /// <para>
+    /// Under the draft revision (SEP-2575 + SEP-2567 + SEP-2322), client requests that declare this
+    /// version are processed sessionlessly:
+    /// </para>
+    /// <list type="bullet">
+    /// <item><description>The server does not issue an <c>Mcp-Session-Id</c> response header, regardless
+    /// of the <c>HttpServerTransportOptions.Stateless</c> setting (which governs only legacy
+    /// clients).</description></item>
+    /// <item><description>The legacy <c>initialize</c> handshake is bypassed. Client info, client
+    /// capabilities, and the negotiated protocol version are read from each request's <c>_meta</c>
+    /// fields instead.</description></item>
+    /// <item><description>Server-initiated sampling, elicitation, and roots requests are embedded inline
+    /// as <see cref="IncompleteResult"/> values (MRTR) instead of standalone JSON-RPC requests.</description></item>
+    /// </list>
+    /// <para>
+    /// The legacy <c>initialize</c> handler, <c>Mcp-Session-Id</c> session management, and standalone
+    /// GET endpoint continue to function for clients that do not declare the experimental version, so a
+    /// single server can serve both legacy and draft clients concurrently.
     /// </para>
     /// <para>
     /// This property is intended for proof-of-concept and testing of draft MCP specification features

tests/ModelContextProtocol.AspNetCore.Tests/DraftHttpHandlerTests.cs

@@ -0,0 +1,139 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using ModelContextProtocol.AspNetCore.Tests.Utils;
+using ModelContextProtocol.Protocol;
+using System.Net;
+using System.Text;
+using System.Text.Json;
+
+namespace ModelContextProtocol.AspNetCore.Tests;
+
+/// <summary>
+/// HTTP-level tests for the draft protocol revision (SEP-2575 + SEP-2567): verify that the server
+/// suppresses the <c>Mcp-Session-Id</c> header for draft requests and returns structured
+/// <see cref="McpErrorCode.UnsupportedProtocolVersion"/> errors instead of plain 400s.
+/// </summary>
+public class DraftHttpHandlerTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable
+{
+    private const string DraftVersion = "2026-06-XX";
+
+    private WebApplication? _app;
+
+    private async Task StartAsync(bool experimentalServer)
+    {
+#pragma warning disable MCPEXP001 // ExperimentalProtocolVersion is experimental
+        Builder.Services.AddMcpServer(options =>
+        {
+            options.ServerInfo = new Implementation { Name = nameof(DraftHttpHandlerTests), Version = "1" };
+            if (experimentalServer)
+            {
+                options.ExperimentalProtocolVersion = DraftVersion;
+            }
+        }).WithHttpTransport();
+#pragma warning restore MCPEXP001
+
+        _app = Builder.Build();
+        _app.MapMcp();
+        await _app.StartAsync(TestContext.Current.CancellationToken);
+
+        HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json"));
+        HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream"));
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (_app is not null)
+        {
+            await _app.DisposeAsync();
+        }
+        base.Dispose();
+    }
+
+    [Fact]
+    public async Task DraftRequest_DoesNotEmitMcpSessionIdHeader()
+    {
+        await StartAsync(experimentalServer: true);
+
+        HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", DraftVersion);
+
+        // server/discover should succeed without creating a session.
+        var content = new StringContent(
+            """{"jsonrpc":"2.0","id":1,"method":"server/discover","params":{}}""",
+            Encoding.UTF8, "application/json");
+        using var response = await HttpClient.PostAsync("", content, TestContext.Current.CancellationToken);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.False(response.Headers.Contains("Mcp-Session-Id"), "Draft responses must not include Mcp-Session-Id");
+    }
+
+    [Fact]
+    public async Task RequestWithUnsupportedProtocolVersion_Returns_UnsupportedProtocolVersionError()
+    {
+        await StartAsync(experimentalServer: false);
+
+        HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", "2099-12-31");
+
+        var content = new StringContent(
+            """{"jsonrpc":"2.0","id":1,"method":"server/discover","params":{}}""",
+            Encoding.UTF8, "application/json");
+        using var response = await HttpClient.PostAsync("", content, TestContext.Current.CancellationToken);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+
+        var body = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken);
+        var rpcMessage = JsonSerializer.Deserialize<JsonRpcMessage>(body, McpJsonUtilities.DefaultOptions);
+        var rpcError = Assert.IsType<JsonRpcError>(rpcMessage);
+        Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, rpcError.Error.Code);
+
+        // Validate the structured data payload (SEP-2575 §"Unsupported Protocol Versions").
+        var dataElement = (JsonElement)rpcError.Error.Data!;
+        var errorData = dataElement.Deserialize<UnsupportedProtocolVersionErrorData>(McpJsonUtilities.DefaultOptions);
+        Assert.NotNull(errorData);
+        Assert.Equal("2099-12-31", errorData.Requested);
+        Assert.NotEmpty(errorData.Supported);
+    }
+
+    [Fact]
+    public async Task DraftRequest_WithMcpSessionIdHeader_RoutesThroughLegacyPath()
+    {
+        // For back-compat with clients that opted into the experimental version on top of the legacy
+        // stateful session model (MRTR-as-extension-on-initialize), draft-version requests that DO
+        // include an Mcp-Session-Id are still accepted via the legacy session lookup path.
+        await StartAsync(experimentalServer: true);
+
+        HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", DraftVersion);
+        HttpClient.DefaultRequestHeaders.Add("Mcp-Session-Id", "non-existent-session-id");
+
+        var content = new StringContent(
+            """{"jsonrpc":"2.0","id":1,"method":"server/discover","params":{}}""",
+            Encoding.UTF8, "application/json");
+        using var response = await HttpClient.PostAsync("", content, TestContext.Current.CancellationToken);
+
+        // Legacy path returns 404 for unknown sessions.
+        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task DraftGet_WithoutSessionId_IsRejected()
+    {
+        await StartAsync(experimentalServer: true);
+
+        HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", DraftVersion);
+
+        using var response = await HttpClient.GetAsync("", TestContext.Current.CancellationToken);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task DraftDelete_WithoutSessionId_IsRejected()
+    {
+        await StartAsync(experimentalServer: true);
+
+        HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", DraftVersion);
+
+        using var response = await HttpClient.DeleteAsync("", TestContext.Current.CancellationToken);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+}

tests/ModelContextProtocol.Tests/Client/DraftConnectionTests.cs

@@ -0,0 +1,116 @@
+using Microsoft.Extensions.DependencyInjection;
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+using System.Text.Json;
+
+namespace ModelContextProtocol.Tests.Client;
+
+/// <summary>
+/// Tests for the draft protocol revision (SEP-2575 + SEP-2567) connection flow on
+/// <see cref="McpClient"/> — the client should call <c>server/discover</c> instead of
+/// <c>initialize</c> when <see cref="McpClientOptions.ExperimentalProtocolVersion"/> is set and
+/// the server supports the requested version, and it should fall back to the legacy
+/// <c>initialize</c> handshake otherwise.
+/// </summary>
+#pragma warning disable MCPEXP002 // ExperimentalProtocolVersion
+public class DraftConnectionTests : ClientServerTestBase
+{
+    private const string DraftVersion = "2026-06-XX";
+    private const string LatestStableVersion = "2025-11-25";
+
+    private bool _serverHasExperimental;
+
+    public DraftConnectionTests(ITestOutputHelper testOutputHelper)
+        : base(testOutputHelper, startServer: false)
+    {
+    }
+
+    protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder)
+    {
+        services.Configure<McpServerOptions>(options =>
+        {
+            options.ServerInfo = new Implementation { Name = nameof(DraftConnectionTests), Version = "1.0" };
+            if (_serverHasExperimental)
+            {
+                options.ExperimentalProtocolVersion = DraftVersion;
+            }
+        });
+    }
+
+    [Fact]
+    public async Task DraftClient_ConnectingToDraftServer_NegotiatesExperimentalVersion()
+    {
+        _serverHasExperimental = true;
+        StartServer();
+
+        var options = new McpClientOptions { ExperimentalProtocolVersion = DraftVersion };
+        await using var client = await CreateMcpClientForServer(options);
+
+        Assert.Equal(DraftVersion, client.NegotiatedProtocolVersion);
+        Assert.NotNull(client.ServerCapabilities);
+        Assert.Equal(nameof(DraftConnectionTests), client.ServerInfo.Name);
+    }
+
+    [Fact]
+    public async Task DraftClient_ConnectingToLegacyServer_FallsBackToLegacyInitialize()
+    {
+        _serverHasExperimental = false;
+        StartServer();
+
+        var options = new McpClientOptions { ExperimentalProtocolVersion = DraftVersion };
+        await using var client = await CreateMcpClientForServer(options);
+
+        Assert.NotEqual(DraftVersion, client.NegotiatedProtocolVersion);
+        Assert.Equal(LatestStableVersion, client.NegotiatedProtocolVersion);
+    }
+
+    [Fact]
+    public async Task LegacyClient_ConnectingToDraftServer_NegotiatesLegacyVersion()
+    {
+        _serverHasExperimental = true;
+        StartServer();
+
+        await using var client = await CreateMcpClientForServer();
+
+        Assert.NotEqual(DraftVersion, client.NegotiatedProtocolVersion);
+    }
+
+    [Fact]
+    public async Task LegacyClient_CanCallServerDiscover_EvenWithoutDraftConfigured()
+    {
+        // server/discover is registered unconditionally, so a legacy client can probe it
+        // (e.g., to learn capabilities without doing a second initialize).
+        _serverHasExperimental = false;
+        StartServer();
+
+        await using var client = await CreateMcpClientForServer();
+
+        var response = await client.SendRequestAsync(
+            new JsonRpcRequest { Method = RequestMethods.ServerDiscover },
+            TestContext.Current.CancellationToken);
+
+        var discoverResult = JsonSerializer.Deserialize<DiscoverResult>(response.Result, McpJsonUtilities.DefaultOptions);
+        Assert.NotNull(discoverResult);
+        Assert.NotEmpty(discoverResult.SupportedVersions);
+        Assert.Contains(LatestStableVersion, discoverResult.SupportedVersions);
+        Assert.Equal(nameof(DraftConnectionTests), discoverResult.ServerInfo.Name);
+    }
+
+    [Fact]
+    public async Task DraftServer_DiscoverIncludesExperimentalVersion()
+    {
+        _serverHasExperimental = true;
+        StartServer();
+
+        await using var client = await CreateMcpClientForServer();
+
+        var response = await client.SendRequestAsync(
+            new JsonRpcRequest { Method = RequestMethods.ServerDiscover },
+            TestContext.Current.CancellationToken);
+
+        var discoverResult = JsonSerializer.Deserialize<DiscoverResult>(response.Result, McpJsonUtilities.DefaultOptions);
+        Assert.NotNull(discoverResult);
+        Assert.Contains(DraftVersion, discoverResult.SupportedVersions);
+    }
+}