305 lines
13 KiB
C#
305 lines
13 KiB
C#
using Microsoft.AspNetCore.Builder;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Http.Json;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using ModelContextProtocol.AspNetCore.Tests.Utils;
|
|
using ModelContextProtocol.Client;
|
|
using ModelContextProtocol.Protocol;
|
|
using ModelContextProtocol.Tests.Utils;
|
|
using System.Net;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
using System.Text.Json.Serialization.Metadata;
|
|
|
|
namespace ModelContextProtocol.AspNetCore.Tests;
|
|
|
|
/// <summary>
|
|
/// Regression tests for the draft-protocol-to-legacy fallback path over Streamable HTTP. These
|
|
/// hand-craft minimal HTTP servers that mimic real-world peer behavior (e.g. Python's
|
|
/// <c>simple-streamablehttp-stateless</c> returns a JSON-RPC error envelope in a <c>400</c> body
|
|
/// on a draft probe; vanilla Go does the same on <c>POST /</c>) so the client's HTTP-fallback
|
|
/// logic can be exercised in isolation without the cross-SDK harness.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Two latent bugs were discovered during cross-SDK testing and fixed by the SEP-2575 / SEP-2567
|
|
/// branch:
|
|
/// </para>
|
|
/// <list type="number">
|
|
/// <item>
|
|
/// <see cref="StreamableHttpClientSessionTransport"/> only surfaced the three modern draft
|
|
/// error codes (<c>-32004</c>, <c>-32003</c>, <c>-32001</c>) as <see cref="McpProtocolException"/>;
|
|
/// any other JSON-RPC error code in a <c>400</c> body (e.g. <c>-32600</c> from a legacy server
|
|
/// that doesn't understand the draft <c>_meta</c> envelope) threw <see cref="HttpRequestException"/>
|
|
/// and bypassed the connect-time fallback logic. Per spec PR #2844, the fallback must trigger
|
|
/// on ANY non-modern JSON-RPC error in a <c>400</c> body.
|
|
/// </item>
|
|
/// <item>
|
|
/// <see cref="AutoDetectingClientSessionTransport"/> treated any non-2xx HTTP response as a
|
|
/// signal to abandon the Streamable HTTP transport and fall back to SSE. That masked
|
|
/// application-level errors (including the three modern codes) because the SSE GET would
|
|
/// either fail with "session id required" or succeed against a different endpoint and lose
|
|
/// the actual signal.
|
|
/// </item>
|
|
/// </list>
|
|
/// </remarks>
|
|
public class DraftHttpFallbackTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable
|
|
{
|
|
private WebApplication? _app;
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
if (_app is not null)
|
|
{
|
|
await _app.DisposeAsync();
|
|
}
|
|
base.Dispose();
|
|
}
|
|
|
|
private async Task StartServerAsync(RequestDelegate handler)
|
|
{
|
|
Builder.Services.Configure<JsonOptions>(options =>
|
|
{
|
|
options.SerializerOptions.TypeInfoResolverChain.Add(McpJsonUtilities.DefaultOptions.TypeInfoResolver!);
|
|
});
|
|
|
|
_app = Builder.Build();
|
|
_app.MapPost("/mcp", handler);
|
|
await _app.StartAsync(TestContext.Current.CancellationToken);
|
|
}
|
|
|
|
private static JsonTypeInfo<T> GetJsonTypeInfo<T>() => (JsonTypeInfo<T>)McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(T));
|
|
|
|
private static async Task WriteJsonRpcErrorAsync(HttpContext context, HttpStatusCode statusCode, int code, string message)
|
|
{
|
|
var rpcError = new JsonRpcError
|
|
{
|
|
Id = default,
|
|
Error = new JsonRpcErrorDetail { Code = code, Message = message },
|
|
};
|
|
|
|
context.Response.StatusCode = (int)statusCode;
|
|
context.Response.ContentType = "application/json";
|
|
await context.Response.WriteAsync(JsonSerializer.Serialize(rpcError, GetJsonTypeInfo<JsonRpcMessage>()), context.RequestAborted);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mimics Python's <c>simple-streamablehttp-stateless</c> on a draft probe: returns
|
|
/// <c>400</c> + JSON-RPC <c>-32600</c> ("Bad Request: Unsupported protocol version") for the
|
|
/// initial <c>server/discover</c>, then performs a normal legacy <c>initialize</c> handshake
|
|
/// when the client falls back.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task DraftClient_AgainstLegacyHttpServer_FallsBack_To_Initialize_When_400_Contains_JsonRpcError()
|
|
{
|
|
var ct = TestContext.Current.CancellationToken;
|
|
|
|
await StartServerAsync(async context =>
|
|
{
|
|
var message = await JsonSerializer.DeserializeAsync(
|
|
context.Request.Body,
|
|
GetJsonTypeInfo<JsonRpcMessage>(),
|
|
ct);
|
|
|
|
if (message is not JsonRpcRequest request)
|
|
{
|
|
context.Response.StatusCode = StatusCodes.Status202Accepted;
|
|
return;
|
|
}
|
|
|
|
// Draft probe: simulate a legacy server that rejects the unknown protocol version with
|
|
// a -32600 envelope (matches Python's wire shape verified in cross-SDK testing).
|
|
if (request.Method == RequestMethods.ServerDiscover)
|
|
{
|
|
await WriteJsonRpcErrorAsync(context, HttpStatusCode.BadRequest, code: -32600, message: "Bad Request: Unsupported protocol version: draft");
|
|
return;
|
|
}
|
|
|
|
// Legacy initialize: respond with the highest version the legacy server speaks.
|
|
if (request.Method == RequestMethods.Initialize)
|
|
{
|
|
var response = new JsonRpcResponse
|
|
{
|
|
Id = request.Id,
|
|
Result = JsonSerializer.SerializeToNode(new InitializeResult
|
|
{
|
|
ProtocolVersion = "2025-06-18",
|
|
Capabilities = new() { Tools = new() },
|
|
ServerInfo = new Implementation { Name = "legacy", Version = "1.0" },
|
|
}, McpJsonUtilities.DefaultOptions),
|
|
};
|
|
|
|
context.Response.ContentType = "application/json";
|
|
await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo<JsonRpcMessage>(), ct);
|
|
return;
|
|
}
|
|
|
|
if (request.Method == RequestMethods.ToolsList)
|
|
{
|
|
var response = new JsonRpcResponse
|
|
{
|
|
Id = request.Id,
|
|
Result = JsonSerializer.SerializeToNode(new ListToolsResult { Tools = [] }, McpJsonUtilities.DefaultOptions),
|
|
};
|
|
|
|
context.Response.ContentType = "application/json";
|
|
await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo<JsonRpcMessage>(), ct);
|
|
return;
|
|
}
|
|
|
|
context.Response.StatusCode = StatusCodes.Status202Accepted;
|
|
});
|
|
|
|
// Default AutoDetect transport — exercises BOTH fixes (AutoDetect adopting StreamableHttp
|
|
// on JSON-RPC-error 400, and SendMessageAsync surfacing -32600 as McpProtocolException).
|
|
await using var transport = new HttpClientTransport(new()
|
|
{
|
|
Endpoint = new("http://localhost:5000/mcp"),
|
|
}, HttpClient, LoggerFactory);
|
|
|
|
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
|
|
{
|
|
ProtocolVersion = McpSession.DraftProtocolVersion,
|
|
}, loggerFactory: LoggerFactory, cancellationToken: ct);
|
|
|
|
Assert.Equal("2025-06-18", client.NegotiatedProtocolVersion);
|
|
|
|
// Sanity: subsequent traffic still works post-fallback.
|
|
var tools = await client.ListToolsAsync(cancellationToken: ct);
|
|
Assert.Empty(tools);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mimics vanilla Go: returns <c>400</c> + JSON-RPC <c>-32004</c> with
|
|
/// <c>data.supported[]</c> on a draft probe so the client retries legacy
|
|
/// <c>initialize</c> with one of the advertised versions.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task DraftClient_OnUnsupportedProtocolVersion_AdoptsStreamableHttp_NoSseFallback()
|
|
{
|
|
var ct = TestContext.Current.CancellationToken;
|
|
|
|
await StartServerAsync(async context =>
|
|
{
|
|
var message = await JsonSerializer.DeserializeAsync(
|
|
context.Request.Body,
|
|
GetJsonTypeInfo<JsonRpcMessage>(),
|
|
ct);
|
|
|
|
if (message is not JsonRpcRequest request)
|
|
{
|
|
context.Response.StatusCode = StatusCodes.Status202Accepted;
|
|
return;
|
|
}
|
|
|
|
if (request.Method == RequestMethods.ServerDiscover)
|
|
{
|
|
// -32004 with the spec-shaped data: client should retry with one of supported[].
|
|
// Use the typed payload type so the source-generated serializer can handle it.
|
|
var data = JsonSerializer.SerializeToNode(new UnsupportedProtocolVersionErrorData
|
|
{
|
|
Supported = new List<string> { "2025-11-25" },
|
|
Requested = "draft",
|
|
}, GetJsonTypeInfo<UnsupportedProtocolVersionErrorData>());
|
|
|
|
var rpcError = new JsonRpcError
|
|
{
|
|
Id = request.Id,
|
|
Error = new JsonRpcErrorDetail
|
|
{
|
|
Code = (int)McpErrorCode.UnsupportedProtocolVersion,
|
|
Message = "Unsupported protocol version",
|
|
Data = data,
|
|
},
|
|
};
|
|
|
|
context.Response.StatusCode = StatusCodes.Status400BadRequest;
|
|
context.Response.ContentType = "application/json";
|
|
await context.Response.WriteAsync(JsonSerializer.Serialize(rpcError, GetJsonTypeInfo<JsonRpcMessage>()), ct);
|
|
return;
|
|
}
|
|
|
|
if (request.Method == RequestMethods.Initialize)
|
|
{
|
|
var response = new JsonRpcResponse
|
|
{
|
|
Id = request.Id,
|
|
Result = JsonSerializer.SerializeToNode(new InitializeResult
|
|
{
|
|
ProtocolVersion = "2025-11-25",
|
|
Capabilities = new() { Tools = new() },
|
|
ServerInfo = new Implementation { Name = "go-shaped", Version = "1.0" },
|
|
}, McpJsonUtilities.DefaultOptions),
|
|
};
|
|
|
|
context.Response.ContentType = "application/json";
|
|
await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo<JsonRpcMessage>(), ct);
|
|
return;
|
|
}
|
|
|
|
context.Response.StatusCode = StatusCodes.Status202Accepted;
|
|
});
|
|
|
|
await using var transport = new HttpClientTransport(new()
|
|
{
|
|
Endpoint = new("http://localhost:5000/mcp"),
|
|
}, HttpClient, LoggerFactory);
|
|
|
|
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
|
|
{
|
|
ProtocolVersion = McpSession.DraftProtocolVersion,
|
|
}, loggerFactory: LoggerFactory, cancellationToken: ct);
|
|
|
|
Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A 400 with a JSON-RPC <c>-32001 HeaderMismatch</c> envelope must be surfaced to the
|
|
/// caller (no legacy fallback) — falling back wouldn't fix a malformed envelope.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task DraftClient_OnHeaderMismatch_400_Surfaces_McpProtocolException_NoFallback()
|
|
{
|
|
var ct = TestContext.Current.CancellationToken;
|
|
bool initializeReceived = false;
|
|
|
|
await StartServerAsync(async context =>
|
|
{
|
|
var message = await JsonSerializer.DeserializeAsync(
|
|
context.Request.Body,
|
|
GetJsonTypeInfo<JsonRpcMessage>(),
|
|
ct);
|
|
|
|
if (message is JsonRpcRequest { Method: RequestMethods.Initialize })
|
|
{
|
|
initializeReceived = true;
|
|
}
|
|
|
|
if (message is JsonRpcRequest { Method: RequestMethods.ServerDiscover })
|
|
{
|
|
await WriteJsonRpcErrorAsync(context, HttpStatusCode.BadRequest,
|
|
code: (int)McpErrorCode.HeaderMismatch,
|
|
message: "Header mismatch: MCP-Protocol-Version did not match body _meta");
|
|
return;
|
|
}
|
|
|
|
context.Response.StatusCode = StatusCodes.Status202Accepted;
|
|
});
|
|
|
|
await using var transport = new HttpClientTransport(new()
|
|
{
|
|
Endpoint = new("http://localhost:5000/mcp"),
|
|
}, HttpClient, LoggerFactory);
|
|
|
|
var exception = await Assert.ThrowsAsync<McpProtocolException>(async () =>
|
|
{
|
|
await using var client = await McpClient.CreateAsync(transport, new McpClientOptions
|
|
{
|
|
ProtocolVersion = McpSession.DraftProtocolVersion,
|
|
}, loggerFactory: LoggerFactory, cancellationToken: ct);
|
|
});
|
|
|
|
Assert.Equal(McpErrorCode.HeaderMismatch, exception.ErrorCode);
|
|
Assert.False(initializeReceived);
|
|
}
|
|
}
|