Recognize JSON-RPC errors in AutoDetect HTTP transport (no SSE fallback)

AutoDetectingClientSessionTransport's job is to pick between StreamableHttp
(post-SEP-2243) and legacy SSE based on the server's response to the first
POST. The detection logic only checked the HTTP status code, so a draft server
returning `400 Bad Request` with a JSON-RPC error body (e.g. `-32004`
UnsupportedProtocolVersion or `-32600` from a legacy server that didn't
understand the draft `_meta` envelope) was being treated as ""this isn't
StreamableHttp"" — and the transport silently fell back to SSE, breaking
fallback negotiation against any HTTP/1.1 peer that follows the spec.

Detect a JSON-RPC error envelope in the 400 body, adopt StreamableHttp, then
re-throw the structured exception so McpClientImpl can dispatch on the error
code (retry with advertised version, surface capability gap, or fall back to
`initialize`). Use a deferred throw guarded by `catch when (ActiveTransport
is null)` to preserve transport ownership across the deferred error path.

Cross-SDK validation: against vanilla Go SDK `origin/main` HTTP everything
server, default `--http-mode autodetect` now successfully adopts
StreamableHttp, recognizes `-32004` with `data.supported`, retries with
`2025-11-25`, and lists 10 tools. Against Python `main`'s
`simple-streamablehttp-stateless`, the same flow recognizes the `-32600`
returned from the draft probe, adopts StreamableHttp, and falls back to
`initialize` with `2025-06-18` to complete the handshake.

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

Author: halter73

src/ModelContextProtocol.Core/Client/AutoDetectingClientSessionTransport.cs

@@ -2,6 +2,8 @@
 using Microsoft.Extensions.Logging.Abstractions;
 using ModelContextProtocol.Protocol;
 using System.Net;
+using System.Net.Http;
+using System.Text.Json;
 using System.Threading.Channels;
 
 namespace ModelContextProtocol.Client;
@@ -62,6 +64,7 @@ private async Task InitializeAsync(JsonRpcMessage message, CancellationToken can
     {
         // Try StreamableHttp first
         var streamableHttpTransport = new StreamableHttpClientSessionTransport(_name, _options, _httpClient, _messageChannel, _loggerFactory);
+        McpProtocolException? structuredError = null;
 
         try
         {
@@ -73,22 +76,76 @@ private async Task InitializeAsync(JsonRpcMessage message, CancellationToken can
                 LogUsingStreamableHttp(_name);
                 ActiveTransport = streamableHttpTransport;
             }
+            else if (await TryGetJsonRpcErrorFromResponseAsync(response, cancellationToken).ConfigureAwait(false) is { } parsedError)
+            {
+                // A JSON-RPC error envelope in the body means the peer IS a Streamable HTTP server
+                // — it just rejected our specific request (e.g., -32004 UnsupportedProtocolVersion,
+                // -32003 MissingRequiredClientCapability, -32001 HeaderMismatch, or any other
+                // application-level error). Don't fall back to SSE — that would mask the real signal
+                // and surface a misleading "session id required" error from the SSE GET path.
+                // Adopt the Streamable HTTP transport and surface the structured exception to the
+                // caller so the connect-time fallback logic can react per spec PR #2844.
+                LogUsingStreamableHttp(_name);
+                ActiveTransport = streamableHttpTransport;
+                structuredError = McpSessionHandler.CreateRemoteProtocolExceptionFromError(parsedError);
+            }
             else
             {
-                // If the status code is not success, fall back to SSE
+                // Non-JSON-RPC error response: either the server doesn't speak MCP at all, or this
+                // is an older deployment that expects the SSE transport (which establishes its
+                // protocol via GET /sse rather than POST). Fall back to SSE per the original
+                // behavior.
                 LogStreamableHttpFailed(_name, response.StatusCode);
 
                 await streamableHttpTransport.DisposeAsync().ConfigureAwait(false);
                 await InitializeSseTransportAsync(message, cancellationToken).ConfigureAwait(false);
             }
         }
-        catch
+        catch when (ActiveTransport is null)
         {
-            // If nothing threw inside the try block, we've either set streamableHttpTransport as the
-            // ActiveTransport, or else we will have disposed it in the !IsSuccessStatusCode else block.
+            // Only dispose the Streamable HTTP transport when we didn't adopt it. If we set
+            // ActiveTransport above (success path OR structured-error path), the transport's
+            // lifetime is owned by the outer transport from this point on.
             await streamableHttpTransport.DisposeAsync().ConfigureAwait(false);
             throw;
         }
+
+        if (structuredError is not null)
+        {
+            throw structuredError;
+        }
+    }
+
+    private static async Task<JsonRpcError?> TryGetJsonRpcErrorFromResponseAsync(HttpResponseMessage response, CancellationToken cancellationToken)
+    {
+        if (response.Content.Headers.ContentType?.MediaType != "application/json")
+        {
+            return null;
+        }
+
+        string body;
+        try
+        {
+            body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+        }
+        catch
+        {
+            return null;
+        }
+
+        if (string.IsNullOrEmpty(body))
+        {
+            return null;
+        }
+
+        try
+        {
+            return JsonSerializer.Deserialize(body, McpJsonUtilities.JsonContext.Default.JsonRpcMessage) as JsonRpcError;
+        }
+        catch
+        {
+            return null;
+        }
     }
 
     private async Task InitializeSseTransportAsync(JsonRpcMessage message, CancellationToken cancellationToken)