Merge branch 'main' into dependabot/nuget/opentelemetry-testing-41c03e88af

Author: stephentoub

.github/workflows/ci-build-test.yml

@@ -67,8 +67,9 @@ jobs:
     - name: 📦 Install dependencies for tests
       run: npm install @modelcontextprotocol/server-memory
 
-    - name: 📦 Install dependencies for tests
-      run: npm install @modelcontextprotocol/conformance
+    # Keep version in sync with McpConformanceVersion in Directory.Packages.props
+    - name: 📦 Install conformance test runner
+      run: npm install @modelcontextprotocol/conformance@0.1.10
 
     - name: 🏗️ Build
       run: make build CONFIGURATION=${{ matrix.configuration }}

Directory.Packages.props

@@ -5,6 +5,9 @@
     <System9Version>9.0.11</System9Version>
     <System10Version>10.0.2</System10Version>
     <MicrosoftExtensionsVersion>10.2.0</MicrosoftExtensionsVersion>
+    <!-- Pin the conformance tester Node package version for CI stability.
+         Keep in sync npm install step at ci-build-test.yml -->
+    <McpConformanceVersion>0.1.10</McpConformanceVersion>
   </PropertyGroup>
 
   <!-- Product dependencies shared -->

README.md

@@ -88,6 +88,9 @@ var response = await chatClient.GetResponseAsync(
 
 ## Getting Started (Server)
 
+> [!TIP]
+> You can use the [MCP Server project template](https://learn.microsoft.com/dotnet/ai/quickstarts/build-mcp-server?pivots=visualstudio) to quickly get started with creating your own MCP server.
+
 Here is an example of how to create an MCP server and register all tools from the current application.
 It includes a simple echo tool as an example (this is included in the same file here for easy of copy and paste, but it needn't be in the same file...
 the employed overload of `WithTools` examines the current assembly for classes with the `McpServerToolType` attribute, and registers all methods with the

src/ModelContextProtocol.Core/UriTemplate.cs

@@ -67,7 +67,7 @@ internal static partial class UriTemplate
     public static Regex CreateParser(string uriTemplate)
     {
         DefaultInterpolatedStringHandler pattern = new(0, 0, CultureInfo.InvariantCulture, stackalloc char[256]);
-        pattern.AppendFormatted('^');
+        pattern.AppendLiteral("^");
 
         int lastIndex = 0;
         for (Match m = UriTemplateExpression().Match(uriTemplate); m.Success; m = m.NextMatch())
@@ -84,17 +84,20 @@ public static Regex CreateParser(string uriTemplate)
 
             switch (m.Groups["operator"].Value)
             {
-                case "#": AppendExpression(ref pattern, paramNames, '#', "[^,]+"); break;
-                case "/": AppendExpression(ref pattern, paramNames, '/', "[^/?]+"); break;
-                default:  AppendExpression(ref pattern, paramNames, null, "[^/?&]+"); break;
-                
+                case "+": AppendExpression(ref pattern, paramNames, null, "[^?&#]*"); break;
+                case "#": AppendExpression(ref pattern, paramNames, '#', ".*"); break;
+                case ".": AppendExpression(ref pattern, paramNames, '.', "[^/?#]*"); break;
+                case "/": AppendExpression(ref pattern, paramNames, '/', "[^/?#]*"); break;
+                default:  AppendExpression(ref pattern, paramNames, null, "[^/?&#]*"); break;
+
                 case "?": AppendQueryExpression(ref pattern, paramNames, '?'); break;
                 case "&": AppendQueryExpression(ref pattern, paramNames, '&'); break;
+                case ";": AppendPathParameterExpression(ref pattern, paramNames); break;
             }
         }
 
         pattern.AppendFormatted(Regex.Escape(uriTemplate.Substring(lastIndex)));
-        pattern.AppendFormatted('$');
+        pattern.AppendLiteral("$");
 
         return new Regex(
             pattern.ToStringAndClear(),
@@ -113,63 +116,101 @@ static void AppendQueryExpression(ref DefaultInterpolatedStringHandler pattern,
         {
             Debug.Assert(prefix is '?' or '&');
 
-            pattern.AppendFormatted("(?:\\");
+            pattern.AppendLiteral("(?:\\");
             pattern.AppendFormatted(prefix);
 
             if (paramNames.Count > 0)
             {
                 AppendParameter(ref pattern, paramNames[0]);
                 for (int i = 1; i < paramNames.Count; i++)
                 {
-                    pattern.AppendFormatted("\\&?");
+                    pattern.AppendLiteral("\\&?");
                     AppendParameter(ref pattern, paramNames[i]);
                 }
 
                 static void AppendParameter(ref DefaultInterpolatedStringHandler pattern, string paramName)
                 {
                     paramName = Regex.Escape(paramName);
-                    pattern.AppendFormatted("(?:");
+                    pattern.AppendLiteral("(?:");
                     pattern.AppendFormatted(paramName);
-                    pattern.AppendFormatted("=(?<");
+                    pattern.AppendLiteral("=(?<");
                     pattern.AppendFormatted(paramName);
-                    pattern.AppendFormatted(">[^/?&]+))?");
+                    pattern.AppendLiteral(">[^/?&]*))?");
                 }
             }
 
-            pattern.AppendFormatted(")?");
+            pattern.AppendLiteral(")?");
         }
 
         // Chooses a regex character‐class (`valueChars`) based on the initial `prefix` to define which
         // characters make up a parameter value. Then, for each name in `paramNames`, it optionally
         // appends the escaped `prefix` (only on the first parameter, then switches to ','), and
         // adds an optional named capture group `(?<paramName>valueChars)` to match and capture that value.
+        // Note: For "+" (reserved expansion) operator, prefix is null but valueChars allows "/" characters.
+        // Note: For "." (label expansion) operator, the separator is "." instead of ",".
         static void AppendExpression(ref DefaultInterpolatedStringHandler pattern, List<string> paramNames, char? prefix, string valueChars)
         {
-            Debug.Assert(prefix is '#' or '/' or null);
+            Debug.Assert(prefix is '#' or '/' or '.' or null);
 
             if (paramNames.Count > 0)
             {
                 if (prefix is not null)
                 {
-                    pattern.AppendFormatted('\\');
+                    pattern.AppendLiteral("\\");
                     pattern.AppendFormatted(prefix);
-                    pattern.AppendFormatted('?');
+                    pattern.AppendLiteral("?");
                 }
 
                 AppendParameter(ref pattern, paramNames[0], valueChars);
+
+                // For label expansion (.), the separator between values is also a dot
+                // For path segment expansion (/), the separator between values is also a slash
+                string separator = prefix switch
+                {
+                    '.' => "\\.",
+                    '/' => "\\/",
+                    _ => "\\,"
+                };
                 for (int i = 1; i < paramNames.Count; i++)
                 {
-                    pattern.AppendFormatted("\\,?");
+                    pattern.AppendFormatted(separator);
+                    pattern.AppendLiteral("?");
                     AppendParameter(ref pattern, paramNames[i], valueChars);
                 }
 
                 static void AppendParameter(ref DefaultInterpolatedStringHandler pattern, string paramName, string valueChars)
                 {
-                    pattern.AppendFormatted("(?<");
+                    pattern.AppendLiteral("(?<");
                     pattern.AppendFormatted(Regex.Escape(paramName));
-                    pattern.AppendFormatted('>');
+                    pattern.AppendLiteral(">");
                     pattern.AppendFormatted(valueChars);
-                    pattern.AppendFormatted(")?");
+                    pattern.AppendLiteral(")?");
+                }
+            }
+        }
+
+        // Appends a regex fragment for path-style parameter expansion (;).
+        // Format: ;name=value or ;name (if value is empty), separated by semicolons.
+        // Each parameter is made optional and captured by a named group.
+        static void AppendPathParameterExpression(ref DefaultInterpolatedStringHandler pattern, List<string> paramNames)
+        {
+            if (paramNames.Count > 0)
+            {
+                AppendParameter(ref pattern, paramNames[0]);
+                for (int i = 1; i < paramNames.Count; i++)
+                {
+                    AppendParameter(ref pattern, paramNames[i]);
+                }
+
+                static void AppendParameter(ref DefaultInterpolatedStringHandler pattern, string paramName)
+                {
+                    // Match ;name or ;name=value
+                    paramName = Regex.Escape(paramName);
+                    pattern.AppendLiteral("(?:;");
+                    pattern.AppendFormatted(paramName);
+                    pattern.AppendLiteral("(?:=(?<");
+                    pattern.AppendFormatted(paramName);
+                    pattern.AppendLiteral(">[^;/?&]*))?)?");
                 }
             }
         }
@@ -363,7 +404,7 @@ value as string ??
                 }
             }
 
-            if (expansions.Count > 0 && 
+            if (expansions.Count > 0 &&
                 (modifierBehavior.PrefixEmptyExpansions || !expansions.All(string.IsNullOrEmpty)))
             {
                 builder.AppendLiteral(modifierBehavior.Prefix);
@@ -435,7 +476,7 @@ static void AppendHex(ref DefaultInterpolatedStringHandler builder, char c)
 
             if (c <= 0x7F)
             {
-                builder.AppendFormatted('%');
+                builder.AppendLiteral("%");
                 builder.AppendFormatted(hexDigits[c >> 4]);
                 builder.AppendFormatted(hexDigits[c & 0xF]);
             }
@@ -448,7 +489,7 @@ static void AppendHex(ref DefaultInterpolatedStringHandler builder, char c)
                 foreach (byte b in Encoding.UTF8.GetBytes([c]))
 #endif
                 {
-                    builder.AppendFormatted('%');
+                    builder.AppendLiteral("%");
                     builder.AppendFormatted(hexDigits[b >> 4]);
                     builder.AppendFormatted(hexDigits[b & 0xF]);
                 }
@@ -460,13 +501,13 @@ static void AppendHex(ref DefaultInterpolatedStringHandler builder, char c)
     /// Defines an equality comparer for Uri templates as follows:
     /// 1. Non-templated Uris use regular System.Uri equality comparison (host name is case insensitive).
     /// 2. Templated Uris use regular string equality.
-    /// 
+    ///
     /// We do this because non-templated resources are looked up directly from the resource dictionary
     /// and we need to make sure equality is implemented correctly. Templated Uris are resolved in a
     /// fallback step using linear traversal of the resource dictionary, so their equality is only
     /// there to distinguish between different templates.
     /// </summary>
-    public sealed class UriTemplateComparer : IEqualityComparer<string>
+    internal sealed class UriTemplateComparer : IEqualityComparer<string>
     {
         public static IEqualityComparer<string> Instance { get; } = new UriTemplateComparer();
 

tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj

@@ -51,6 +51,13 @@
     <PackageReference Include="System.Linq.AsyncEnumerable" />
   </ItemGroup>
 
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+      <_Parameter1>McpConformanceVersion</_Parameter1>
+      <_Parameter2>$(McpConformanceVersion)</_Parameter2>
+    </AssemblyAttribute>
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\samples\TestServerWithHosting\TestServerWithHosting.csproj" />
     <ProjectReference Include="..\..\src\ModelContextProtocol.Core\ModelContextProtocol.Core.csproj" />

tests/ModelContextProtocol.AspNetCore.Tests/ResumabilityIntegrationTests.cs

@@ -279,6 +279,7 @@ public async Task Client_CanResumePostResponseStream_AfterDisconnection()
     [Fact]
     public async Task Client_CanResumeUnsolicitedMessageStream_AfterDisconnection()
     {
+        var timeout = TimeSpan.FromSeconds(10);
         using var faultingStreamHandler = new FaultingStreamHandler()
         {
             InnerHandler = SocketsHttpHandler,
@@ -304,12 +305,12 @@ public async Task Client_CanResumeUnsolicitedMessageStream_AfterDisconnection()
         await using var client = await ConnectClientAsync();
 
         // Get the server instance
-        var server = await serverTcs.Task.WaitAsync(TestContext.Current.CancellationToken);
+        var server = await serverTcs.Task.WaitAsync(timeout, TestContext.Current.CancellationToken);
 
         // Set up notification tracking with unique messages
-        var clientReceivedInitialNotificationTcs = new TaskCompletionSource();
-        var clientReceivedReplayedNotificationTcs = new TaskCompletionSource();
-        var clientReceivedReconnectNotificationTcs = new TaskCompletionSource();
+        var clientReceivedInitialNotificationTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var clientReceivedReplayedNotificationTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var clientReceivedReconnectNotificationTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
 
         const string CustomNotificationMethod = "test/custom_notification";
         const string InitialMessage = "Initial notification";
@@ -343,11 +344,14 @@ public async Task Client_CanResumeUnsolicitedMessageStream_AfterDisconnection()
             return default;
         });
 
+        // Wait for the client's unsolicited message stream to be established before sending notifications
+        await faultingStreamHandler.WaitForUnsolicitedMessageStreamAsync(TestContext.Current.CancellationToken);
+
         // Send a custom notification to the client on the unsolicited message stream
         await server.SendNotificationAsync(CustomNotificationMethod, new JsonObject { ["message"] = InitialMessage }, cancellationToken: TestContext.Current.CancellationToken);
 
         // Wait for client to receive the first notification
-        await clientReceivedInitialNotificationTcs.Task.WaitAsync(TestContext.Current.CancellationToken);
+        await clientReceivedInitialNotificationTcs.Task.WaitAsync(timeout, TestContext.Current.CancellationToken);
 
         // Fault the unsolicited message stream (GET SSE)
         var reconnectAttempt = await faultingStreamHandler.TriggerFaultAsync(TestContext.Current.CancellationToken);
@@ -359,13 +363,13 @@ public async Task Client_CanResumeUnsolicitedMessageStream_AfterDisconnection()
         reconnectAttempt.Continue();
 
         // Wait for client to receive the notification via replay
-        await clientReceivedReplayedNotificationTcs.Task.WaitAsync(TestContext.Current.CancellationToken);
+        await clientReceivedReplayedNotificationTcs.Task.WaitAsync(timeout, TestContext.Current.CancellationToken);
 
         // Send a final notification while the client has reconnected - this should be handled by the transport
         await server.SendNotificationAsync(CustomNotificationMethod, new JsonObject { ["message"] = ReconnectMessage }, cancellationToken: TestContext.Current.CancellationToken);
 
         // Wait for the client to receive the final notification
-        await clientReceivedReconnectNotificationTcs.Task.WaitAsync(TestContext.Current.CancellationToken);
+        await clientReceivedReconnectNotificationTcs.Task.WaitAsync(timeout, TestContext.Current.CancellationToken);
 
         // Assert each notification was received exactly once
         Assert.Equal(1, initialNotificationReceivedCount);
@@ -531,7 +535,7 @@ public async Task PostResponse_EndsAndSseEventStreamWriterIsDisposed_WhenWriteEv
         timeoutCts.CancelAfter(TimeSpan.FromSeconds(10));
 
         // The call task should throw an OCE due to cancellation
-        await Assert.ThrowsAsync<OperationCanceledException>(() => callTask).WaitAsync(timeoutCts.Token);
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => callTask).WaitAsync(timeoutCts.Token);
 
         // Wait for the writer to be disposed
         await blockingStore.DisposedTask.WaitAsync(timeoutCts.Token);

tests/ModelContextProtocol.AspNetCore.Tests/ServerConformanceTests.cs

@@ -115,9 +115,21 @@ private void StartConformanceServer()
         _serverTask = Task.Run(() => ConformanceServer.Program.MainAsync(["--urls", _serverUrl], new XunitLoggerProvider(_output), cancellationToken: _serverCts.Token));
     }
 
+    private static string GetConformanceVersion()
+    {
+        var assembly = typeof(ServerConformanceTests).Assembly;
+        var attribute = assembly.GetCustomAttributes(typeof(System.Reflection.AssemblyMetadataAttribute), false)
+            .Cast<System.Reflection.AssemblyMetadataAttribute>()
+            .FirstOrDefault(a => a.Key == "McpConformanceVersion");
+        return attribute?.Value ?? throw new InvalidOperationException("McpConformanceVersion not found in assembly metadata");
+    }
+
     private async Task<(bool Success, string Output, string Error)> RunNpxConformanceTests()
     {
-        var startInfo = NodeHelpers.NpxStartInfo($"-y @modelcontextprotocol/conformance server --url {_serverUrl}");
+        // Version is configured in Directory.Packages.props for central management
+        var version = GetConformanceVersion();
+
+        var startInfo = NodeHelpers.NpxStartInfo($"-y @modelcontextprotocol/conformance@{version} server --url {_serverUrl}");
 
         var outputBuilder = new StringBuilder();
         var errorBuilder = new StringBuilder();