Add SEP-2322 MRTR conformance scenarios (ephemeral)

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

Author: halter73

tests/Common/Utils/NodeHelpers.cs

@@ -205,6 +205,44 @@ public static bool HasSep2243Scenarios()
         }
     }
 
+    /// <summary>
+    /// Checks whether the SEP-2322 (Multi Round-Trip Requests / IncompleteResult)
+    /// conformance scenarios are available by reading the conformance package version
+    /// from the repo's package.json. MRTR scenarios require a conformance package version
+    /// that includes SEP-2322 support (see
+    /// https://github.com/modelcontextprotocol/conformance/pull/188).
+    /// </summary>
+    public static bool HasMrtrScenarios()
+    {
+        try
+        {
+            var repoRoot = FindRepoRoot();
+            var packageJsonPath = Path.Combine(repoRoot, "package.json");
+            if (!File.Exists(packageJsonPath))
+            {
+                return false;
+            }
+
+            var json = System.Text.Json.JsonDocument.Parse(File.ReadAllText(packageJsonPath));
+            if (json.RootElement.TryGetProperty("dependencies", out var deps) &&
+                deps.TryGetProperty("@modelcontextprotocol/conformance", out var versionElement))
+            {
+                var versionStr = versionElement.GetString();
+                if (versionStr is not null && Version.TryParse(versionStr, out var version))
+                {
+                    // SEP-2322 scenarios are expected in conformance package >= 0.2.0
+                    return version >= new Version(0, 2, 0);
+                }
+            }
+
+            return false;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     private static ProcessStartInfo NpmStartInfo(string arguments, string workingDirectory)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

tests/ModelContextProtocol.AspNetCore.Tests/ServerConformanceTests.cs

@@ -159,6 +159,34 @@ public async Task RunConformanceTest_HttpCustomHeaderServerValidation()
             $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}");
     }
 
+    // SEP-2322 (Multi Round-Trip Requests / IncompleteResult) conformance scenarios.
+    // The csharp-sdk ConformanceServer surfaces the matching tools/prompts via
+    // ConformanceServer.Tools.IncompleteResultTools and ConformanceServer.Prompts.IncompleteResultPrompts.
+    // Each scenario uses the conformance harness's RawMcpSession, which negotiates DRAFT-2026-v1
+    // so the csharp-sdk emits InputRequiredResult on the wire. These tests skip until the
+    // upstream conformance package ships with SEP-2322 scenarios
+    // (https://github.com/modelcontextprotocol/conformance/pull/188).
+    [Theory]
+    [InlineData("incomplete-result-basic-elicitation")]
+    [InlineData("incomplete-result-basic-sampling")]
+    [InlineData("incomplete-result-basic-list-roots")]
+    [InlineData("incomplete-result-request-state")]
+    [InlineData("incomplete-result-multiple-input-requests")]
+    [InlineData("incomplete-result-multi-round")]
+    [InlineData("incomplete-result-missing-input-response")]
+    [InlineData("incomplete-result-non-tool-request")]
+    public async Task RunMrtrConformanceTest(string scenario)
+    {
+        Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests.");
+        Assert.SkipWhen(!NodeHelpers.HasMrtrScenarios(), "SEP-2322 MRTR conformance scenarios not yet available in the published @modelcontextprotocol/conformance package.");
+
+        var result = await RunConformanceTestsAsync(
+            $"server --url {fixture.ServerUrl} --scenario {scenario}");
+
+        Assert.True(result.Success,
+            $"MRTR conformance test '{scenario}' failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}");
+    }
+
     private async Task<(bool Success, string Output, string Error)> RunConformanceTestsAsync(string arguments)
     {
         var startInfo = NodeHelpers.ConformanceTestStartInfo(arguments);

tests/ModelContextProtocol.ConformanceServer/Program.cs

@@ -31,6 +31,7 @@ public static async Task MainAsync(string[] args, ILoggerProvider? loggerProvide
             .WithHttpTransport()
             .WithDistributedCacheEventStreamStore()
             .WithTools<ConformanceTools>()
+            .WithTools<IncompleteResultTools>()
             .WithTools([ConformanceTools.CreateJsonSchema202012Tool()])
             .WithRequestFilters(filters => filters.AddCallToolFilter(next => async (request, cancellationToken) =>
             {
@@ -47,6 +48,7 @@ public static async Task MainAsync(string[] args, ILoggerProvider? loggerProvide
                 return result;
             }))
             .WithPrompts<ConformancePrompts>()
+            .WithPrompts<IncompleteResultPrompts>()
             .WithResources<ConformanceResources>()
             .WithSubscribeToResourcesHandler(async (ctx, ct) =>
             {

tests/ModelContextProtocol.ConformanceServer/Prompts/IncompleteResultPrompts.cs

@@ -0,0 +1,68 @@
+#pragma warning disable MCPEXP001 // MRTR (SEP-2322) is experimental.
+
+using ModelContextProtocol;
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+using System.ComponentModel;
+using System.Text.Json;
+
+namespace ConformanceServer.Prompts;
+
+/// <summary>
+/// Prompt implementing the SEP-2322 D1 conformance scenario (<c>incomplete-result-non-tool-request</c>),
+/// proving that <c>prompts/get</c> can return an <see cref="InputRequiredResult"/> just like
+/// <c>tools/call</c>.
+/// </summary>
+[McpServerPromptType]
+public sealed class IncompleteResultPrompts
+{
+    [McpServerPrompt(Name = "test_incomplete_result_prompt")]
+    [Description("SEP-2322 D1: prompts/get returns IncompleteResult until user_context is supplied.")]
+    public static GetPromptResult IncompleteResultPrompt(RequestContext<GetPromptRequestParams> context)
+    {
+        if (context.Params!.InputResponses is { } responses &&
+            responses.TryGetValue("user_context", out var response))
+        {
+            var elicit = response.ElicitationResult;
+            var contextValue = TryReadString(elicit?.Content, "context") ?? "(unknown)";
+            return new GetPromptResult
+            {
+                Description = "Prompt customized with elicited user context.",
+                Messages =
+                [
+                    new PromptMessage
+                    {
+                        Role = Role.User,
+                        Content = new TextContentBlock { Text = $"Please continue using context: {contextValue}" },
+                    },
+                ],
+            };
+        }
+
+        throw new InputRequiredException(
+            new Dictionary<string, InputRequest>
+            {
+                ["user_context"] = InputRequest.ForElicitation(new ElicitRequestParams
+                {
+                    Message = "What context should the prompt use?",
+                    RequestedSchema = new ElicitRequestParams.RequestSchema
+                    {
+                        Properties = new Dictionary<string, ElicitRequestParams.PrimitiveSchemaDefinition>
+                        {
+                            ["context"] = new ElicitRequestParams.StringSchema(),
+                        },
+                        Required = ["context"],
+                    },
+                }),
+            });
+    }
+
+    private static string? TryReadString(IDictionary<string, JsonElement>? content, string key)
+    {
+        if (content is null || !content.TryGetValue(key, out var element))
+        {
+            return null;
+        }
+        return element.ValueKind == JsonValueKind.String ? element.GetString() : element.ToString();
+    }
+}