@@ -24,7 +24,7 @@ When sessions are enabled (`Stateless = false`), the server creates and tracks a
 
 <!-- mlc-disable-next-line -->
 > [!NOTE]
-> **Why is stateless now the default?** Earlier versions of the SDK defaulted to stateful for back-compat with the `2025-11-25` (and older) protocol revisions, which require the `Mcp-Session-Id` header. The `2026-07-28` protocol revision removes that header (SEP-2567) and the `initialize` handshake (SEP-2575) entirely, so the SDK now defaults <xref:ModelContextProtocol.AspNetCore.HttpServerTransportOptions.Stateless> to `true` to match the new wire format. You can still opt back into sessions with `Stateless = false` for [unsolicited notifications](#how-streamable-http-delivers-messages), resource subscriptions, per-client isolation, or server-to-client requests against clients that don't support [MRTR](xref:mrtr) — see [Stateful mode (sessions)](#stateful-mode-sessions).
+> **Why is stateless now the default?** Earlier versions of the SDK defaulted to stateful, but not because the `2025-11-25` (and older) protocol revisions ever required a server to use the `Mcp-Session-Id` header. They didn't. The original SSE transport could only operate statefully, and keeping Streamable HTTP stateful by default let server-to-client requests (elicitation, sampling, roots) keep working on `2025-11-25` the way they always had. A client was required to echo a server-assigned `Mcp-Session-Id` on later requests, but whether to assign one was always the server's choice. The `2026-07-28` protocol revision removes the header (SEP-2567) and the `initialize` handshake (SEP-2575) from the wire format entirely, and server-to-client requests now run through [MRTR](xref:mrtr), so the SDK now defaults <xref:ModelContextProtocol.AspNetCore.HttpServerTransportOptions.Stateless> to `true` to match the new wire format. You can still opt back into sessions with `Stateless = false` for [unsolicited notifications](#how-streamable-http-delivers-messages), resource subscriptions, per-client isolation, or server-to-client requests against clients that don't support [MRTR](xref:mrtr) — see [Stateful mode (sessions)](#stateful-mode-sessions).
 
 ## Forward and backward compatibility
 
@@ -53,13 +53,12 @@ The `2026-07-28` protocol revision goes further than `Stateless = true`: it remo
 
 The era is cached per <xref:ModelContextProtocol.Client.IClientTransport> instance, so the probe cost is paid only on the first connect.
 
-**Opting out of fallback.** Set <xref:ModelContextProtocol.Client.McpClientOptions.MinProtocolVersion> to <xref:ModelContextProtocol.McpSession.DraftProtocolVersion> when you want the client to refuse to fall back. The connect call throws an <xref:ModelContextProtocol.McpException> instead of silently degrading. This is useful for strict-modern production code and for tests that need to assert `2026-07-28`-only behavior.
+**Opting out of fallback.** Pin <xref:ModelContextProtocol.Client.McpClientOptions.ProtocolVersion> to `2026-07-28` when you want the client to refuse to fall back. A non-null `ProtocolVersion` is also treated as the minimum, so the connect call throws an <xref:ModelContextProtocol.McpException> instead of silently degrading to a legacy revision. This is useful for strict-modern production code and for tests that need to assert `2026-07-28`-only behavior. To try several versions yourself, leave `ProtocolVersion` unset (the default) or retry the connection with a different value.
 
 ```csharp
 var clientOptions = new McpClientOptions
 {
-    ProtocolVersion = McpSession.DraftProtocolVersion,
-    MinProtocolVersion = McpSession.DraftProtocolVersion,
+    ProtocolVersion = "2026-07-28",
 };
 ```
 
 
@@ -392,13 +392,15 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
                             .FirstOrDefault()
                             ?? McpHttpHeaders.November2025ProtocolVersion;
 
-                        // Honor MinProtocolVersion: refuse to fall back below the configured minimum.
-                        // String.Compare is the spec's prescribed ordering for ISO-8601 date-based versions.
-                        if (_options.MinProtocolVersion is { } minVersion &&
-                            StringComparer.Ordinal.Compare(fallbackVersion, minVersion) < 0)
+                        // A non-null ProtocolVersion is also the minimum: refuse to fall back below the
+                        // explicitly requested version. String.Compare is the spec's prescribed ordering
+                        // for ISO-8601 date-based versions.
+                        if (_options.ProtocolVersion is { } pinnedVersion &&
+                            StringComparer.Ordinal.Compare(fallbackVersion, pinnedVersion) < 0)
                         {
                             throw new McpException(
-                                $"Server does not support the configured minimum protocol version '{minVersion}'. " +
+                                $"The server does not support the requested protocol version '{pinnedVersion}'. " +
+                                "Leave McpClientOptions.ProtocolVersion unset to allow automatic fallback to an older version. " +
                                 (serverSupportedVersions is null
                                     ? "The server appears to be a legacy server that requires the deprecated initialize handshake."
                                     : $"Server-supported versions: {string.Join(", ", serverSupportedVersions)}."));
@@ -495,15 +497,6 @@ private async Task PerformLegacyInitializeAsync(string requestProtocol, Cancella
             throw new McpException($"Server protocol version mismatch. Expected {requestProtocol}, got {initializeResponse.ProtocolVersion}");
         }
 
-        // If the user set a MinProtocolVersion, also enforce it against the negotiated response
-        // (the server could have downgraded further than the version we asked for).
-        if (_options.MinProtocolVersion is { } minVersion &&
-            StringComparer.Ordinal.Compare(initializeResponse.ProtocolVersion, minVersion) < 0)
-        {
-            throw new McpException(
-                $"Server negotiated protocol version '{initializeResponse.ProtocolVersion}' is below the configured minimum '{minVersion}'.");
-        }
-
         _negotiatedProtocolVersion = initializeResponse.ProtocolVersion;
         _sessionHandler.NegotiatedProtocolVersion = _negotiatedProtocolVersion;
 
 
@@ -52,51 +52,22 @@ public sealed class McpClientOptions
     /// </summary>
     /// <remarks>
     /// <para>
-    /// When non-<see langword="null"/>, this version is requested from the server. Setting it to a
-    /// version that still supports Streamable HTTP sessions, such as <c>2025-11-25</c>, opts out of the
-    /// <c>2026-07-28</c> revision and forces the <c>initialize</c> handshake; the handshake then fails if
-    /// the server's negotiated version does not match.
-    /// </para>
-    /// <para>
     /// When <see langword="null"/> (the default), the client prefers the latest revision (<c>2026-07-28</c>),
-    /// which removed the <c>initialize</c> handshake and Streamable HTTP sessions: it probes with
-    /// <c>server/discover</c> and automatically falls back to a legacy <c>initialize</c> handshake,
+    /// which removed the <c>initialize</c> handshake and Streamable HTTP sessions. It probes with
+    /// <c>server/discover</c> and automatically falls back to the legacy <c>initialize</c> handshake,
     /// downgrading to any version the server advertises, when the server does not support that revision.
     /// </para>
-    /// </remarks>
-    public string? ProtocolVersion { get; set; }
-
-    /// <summary>
-    /// Gets or sets the minimum protocol version the client will accept during version negotiation.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// When negotiating with a server that advertises multiple supported versions, or when falling back
-    /// to a legacy server, the client will refuse any version older than this minimum and surface an
-    /// <see cref="McpException"/> instead.
-    /// </para>
     /// <para>
-    /// This is useful when the client requires features that older protocol revisions lack, such as the
-    /// <c>2026-07-28</c> revision's removal of the <c>initialize</c> handshake and <c>Mcp-Session-Id</c>.
-    /// Because the client already prefers <c>2026-07-28</c> by default, setting this to
-    /// <c>2026-07-28</c> disables the automatic legacy-server fallback that otherwise switches to the
-    /// <c>initialize</c> handshake.
+    /// When non-<see langword="null"/>, this value is both the requested version and the minimum the client
+    /// will accept: the client requests exactly this version and refuses to downgrade below it, throwing an
+    /// <see cref="McpException"/> instead of falling back. Setting it to <c>2026-07-28</c> therefore disables
+    /// the automatic legacy-server fallback, and setting it to a version that still supports Streamable HTTP
+    /// sessions, such as <c>2025-11-25</c>, forces the <c>initialize</c> handshake and fails if the server
+    /// negotiates a different version. To try more than one version, leave this unset for automatic fallback
+    /// or retry the connection with a different value.
     /// </para>
-    /// <para>
-    /// If <see langword="null"/> (the default), the client falls back to any version the server
-    /// advertises, including legacy versions such as 2025-11-25.
-    /// </para>
-    /// <example>
-    /// <code>
-    /// // 2026-07-28 is already the default; pin the minimum to refuse the legacy fallback.
-    /// var clientOptions = new McpClientOptions
-    /// {
-    ///     MinProtocolVersion = "2026-07-28",
-    /// };
-    /// </code>
-    /// </example>
     /// </remarks>
-    public string? MinProtocolVersion { get; set; }
+    public string? ProtocolVersion { get; set; }
 
     /// <summary>
     /// Gets or sets a timeout for the client-server initialization handshake sequence.
 
@@ -157,10 +157,9 @@ await StartServerAsync(async context =>
             Endpoint = new("http://localhost:5000/mcp"),
         }, HttpClient, LoggerFactory);
 
-        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
-        {
-            ProtocolVersion = McpHttpHeaders.July2026ProtocolVersion,
-        }, loggerFactory: LoggerFactory, cancellationToken: ct);
+        // Default options prefer 2026-07-28 but allow automatic fallback to a legacy server.
+        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(),
+            loggerFactory: LoggerFactory, cancellationToken: ct);
 
         Assert.Equal("2025-06-18", client.NegotiatedProtocolVersion);
 
@@ -245,10 +244,9 @@ await StartServerAsync(async context =>
             Endpoint = new("http://localhost:5000/mcp"),
         }, HttpClient, LoggerFactory);
 
-        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
-        {
-            ProtocolVersion = McpHttpHeaders.July2026ProtocolVersion,
-        }, loggerFactory: LoggerFactory, cancellationToken: ct);
+        // Default options prefer 2026-07-28 but allow automatic fallback to a legacy server.
+        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(),
+            loggerFactory: LoggerFactory, cancellationToken: ct);
 
         Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion);
     }
 
@@ -9,20 +9,16 @@ namespace ModelContextProtocol.Tests.Client;
 
 /// <summary>
 /// Regression tests for the fallback from the 2026-07-28 protocol revision to a legacy protocol in
-/// <see cref="McpClient"/>. These verify that a client configured with
-/// <c>McpClientOptions.ProtocolVersion = McpHttpHeaders.July2026ProtocolVersion</c>
-/// correctly probes a server with <c>server/discover</c>, falls
-/// back to the legacy <c>initialize</c> handshake when the server is legacy,
-/// and accepts whatever supported protocol version the legacy server
-/// negotiates, including a version different from the one the client
-/// originally requested.
+/// <see cref="McpClient"/>. With default options (<c>ProtocolVersion = null</c>) the client prefers
+/// 2026-07-28 but probes with <c>server/discover</c>, falls back to the legacy <c>initialize</c>
+/// handshake when the server is legacy, and accepts whatever supported protocol version the legacy
+/// server negotiates. Pinning <c>ProtocolVersion</c> to <c>2026-07-28</c> instead makes it the
+/// minimum too, so the client refuses to fall back.
 /// </summary>
 /// <remarks>
-/// The originally shipped logic in <c>PerformLegacyInitializeAsync</c> compared
-/// the server's response against <c>_options.ProtocolVersion</c>, which for a
-/// 2026-07-28 client is <c>"2026-07-28"</c>. When the legacy server downgraded to (say)
-/// <c>"2025-06-18"</c>, the comparison threw, even though the legacy
-/// negotiation succeeded. These tests guard against that regression.
+/// The originally shipped logic in <c>PerformLegacyInitializeAsync</c> compared the server's response
+/// against the requested version and threw when a legacy server downgraded to (say) <c>"2025-06-18"</c>,
+/// even though the legacy negotiation succeeded. These tests guard against that regression.
 /// </remarks>
 public class July2026ProtocolFallbackTests(ITestOutputHelper testOutputHelper) : LoggedTest(testOutputHelper)
 {
@@ -32,10 +28,9 @@ public async Task Client_OnMethodNotFound_FallsBackTo_Initialize_AcceptsDowngrad
         var ct = TestContext.Current.CancellationToken;
         await using var transport = new LegacyServerTestTransport(serverNegotiatedVersion: "2025-06-18");
 
-        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
-        {
-            ProtocolVersion = McpHttpHeaders.July2026ProtocolVersion,
-        }, loggerFactory: LoggerFactory, cancellationToken: ct);
+        // Default options (ProtocolVersion = null) prefer 2026-07-28 but allow automatic fallback.
+        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(),
+            loggerFactory: LoggerFactory, cancellationToken: ct);
 
         Assert.True(transport.ServerDiscoverProbed);
         Assert.True(transport.LegacyInitializeReceived);
@@ -50,17 +45,16 @@ public async Task Client_OnInvalidParams_FallsBackTo_Initialize()
             serverNegotiatedVersion: "2025-11-25",
             probeErrorCode: (int)McpErrorCode.InvalidParams);
 
-        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
-        {
-            ProtocolVersion = McpHttpHeaders.July2026ProtocolVersion,
-        }, loggerFactory: LoggerFactory, cancellationToken: ct);
+        // Default options (ProtocolVersion = null) prefer 2026-07-28 but allow automatic fallback.
+        await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(),
+            loggerFactory: LoggerFactory, cancellationToken: ct);
 
         Assert.True(transport.LegacyInitializeReceived);
         Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion);
     }
 
     [Fact]
-    public async Task Client_WithMinProtocolVersion_RefusesFallback_BelowMinimum()
+    public async Task Client_WithPinnedJuly2026Version_RefusesFallback_ToLegacyServer()
     {
         var ct = TestContext.Current.CancellationToken;
         await using var transport = new LegacyServerTestTransport(serverNegotiatedVersion: "2025-06-18");
@@ -69,13 +63,13 @@ public async Task Client_WithMinProtocolVersion_RefusesFallback_BelowMinimum()
         {
             await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
             {
+                // Pinning the version makes it the minimum too, so the client refuses to fall back.
                 ProtocolVersion = McpHttpHeaders.July2026ProtocolVersion,
-                MinProtocolVersion = McpHttpHeaders.July2026ProtocolVersion,
             }, loggerFactory: LoggerFactory, cancellationToken: ct);
         });
 
         Assert.IsType<McpException>(exception);
-        Assert.Contains("minimum", exception.Message, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("2026-07-28", exception.Message, StringComparison.OrdinalIgnoreCase);
     }
 
     [Fact]
@@ -133,9 +127,9 @@ public async Task Client_OnSilentProbe_FallsBackTo_Initialize_AfterConfiguredPro
             silentDiscoverProbe: true);
 
         var stopwatch = Stopwatch.StartNew();
+        // Default options (ProtocolVersion = null) prefer 2026-07-28 but allow automatic fallback.
         await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
         {
-            ProtocolVersion = McpHttpHeaders.July2026ProtocolVersion,
             DiscoverProbeTimeout = TimeSpan.FromMilliseconds(250),
             InitializationTimeout = TestConstants.DefaultTimeout,
         }, loggerFactory: LoggerFactory, cancellationToken: ct);