Fix URI template derivation and lookup

samples/AspNetCoreSseServer/Program.cs

@@ -2,12 +2,14 @@
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
 using TestServerWithHosting.Tools;
+using TestServerWithHosting.Resources;
 
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddMcpServer()
     .WithHttpTransport()
     .WithTools<EchoTool>()
-    .WithTools<SampleLlmTool>();
+    .WithTools<SampleLlmTool>()
+    .WithResources<SimpleResourceType>();
 
 builder.Services.AddOpenTelemetry()
     .WithTracing(b => b.AddSource("*")

samples/AspNetCoreSseServer/Resources/SimpleResourceType.cs

@@ -0,0 +1,12 @@
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+using System.ComponentModel;
+
+namespace TestServerWithHosting.Resources;
+
+[McpServerResourceType]
+public class SimpleResourceType
+{
+    [McpServerResource, Description("A direct text resource")]
+    public static string DirectTextResource() => "This is a direct resource";
+}

src/ModelContextProtocol.Core/Server/AIFunctionMcpServerResource.cs

@@ -264,7 +264,7 @@ private static AIFunctionFactoryOptions CreateAIFunctionFactoryOptions(
             Name = name,
             Title = options?.Title,
             Description = options?.Description,
-            MimeType = options?.MimeType,
+            MimeType = options?.MimeType ?? "application/octet-stream",
         };
 
         return new AIFunctionMcpServerResource(function, resource);
@@ -295,7 +295,7 @@ private static string DeriveUriTemplate(string name, AIFunction function)
     {
         StringBuilder template = new();
 
-        template.Append("resource://").Append(Uri.EscapeDataString(name));
+        template.Append("resource://mcp/").Append(Uri.EscapeDataString(name));
 
         if (function.JsonSchema.TryGetProperty("properties", out JsonElement properties))
         {
@@ -359,7 +359,7 @@ private AIFunctionMcpServerResource(AIFunction function, ResourceTemplate resour
                 return null;
             }
         }
-        else if (request.Params.Uri != ProtocolResource!.Uri)
+        else if (new Uri(request.Params.Uri) != new Uri(ProtocolResource!.Uri))
         {
             return null;
         }

src/ModelContextProtocol.Core/Server/McpServerPrimitiveCollection.cs

@@ -10,13 +10,16 @@ public class McpServerPrimitiveCollection<T> : ICollection<T>, IReadOnlyCollecti
     where T : IMcpServerPrimitive
 {
     /// <summary>Concurrent dictionary of primitives, indexed by their names.</summary>
-    private readonly ConcurrentDictionary<string, T> _primitives = [];
+    private readonly ConcurrentDictionary<string, T> _primitives;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="McpServerPrimitiveCollection{T}"/> class.
     /// </summary>
     public McpServerPrimitiveCollection()
     {
+        _primitives = typeof(T) == typeof(McpServerResource)
+            ? new(UriTemplate.UriTemplateComparer.Instance)
+            : new();
     }
 
     /// <summary>Occurs when the collection is changed.</summary>

src/ModelContextProtocol.Core/UriTemplate.cs

@@ -2,6 +2,7 @@
 using System.Buffers;
 #endif
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -453,4 +454,52 @@ static void AppendHex(ref DefaultInterpolatedStringHandler builder, char c)
             }
         }
     }
+
+    /// <summary>
+    /// 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 using
+    /// linear traversal so there's no need for equality comparison to be fully accurate.
+    /// </summary>
+    public sealed class UriTemplateComparer : IEqualityComparer<string>
+    {
+        public static IEqualityComparer<string> Instance { get; } = new UriTemplateComparer();
+
+        public bool Equals(string? uriTemplate1, string? uriTemplate2)
+        {
+            if (TryParseAsNonTemplatedUri(uriTemplate1, out Uri? uri1) &&
+                TryParseAsNonTemplatedUri(uriTemplate2, out Uri? uri2))
+            {
+                return uri1 == uri2;
+            }
+
+            return string.Equals(uriTemplate1, uriTemplate2, StringComparison.Ordinal);
+        }
+
+        public int GetHashCode([DisallowNull] string uriTemplate)
+        {
+            if (TryParseAsNonTemplatedUri(uriTemplate, out Uri? uri))
+            {
+                return uri.GetHashCode();
+            }
+            else
+            {
+                return StringComparer.Ordinal.GetHashCode(uriTemplate);
+            }
+        }
+
+        private static bool TryParseAsNonTemplatedUri(string? uriTemplate, [NotNullWhen(true)] out Uri? uri)
+        {
+            if (uriTemplate is null || uriTemplate.Contains('{'))
+            {
+                uri = null;
+                return false;
+            }
+
+            return Uri.TryCreate(uriTemplate, UriKind.RelativeOrAbsolute, out uri);
+        }
+    }
 }

tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsResourcesTests.cs

@@ -220,7 +220,7 @@ public async Task Throws_When_Resource_Fails()
         await using IMcpClient client = await CreateMcpClientForServer();
 
         await Assert.ThrowsAsync<McpException>(async () => await client.ReadResourceAsync(
-            $"resource://{nameof(SimpleResources.ThrowsException)}",
+            $"resource://mcp/{nameof(SimpleResources.ThrowsException)}",
             cancellationToken: TestContext.Current.CancellationToken));
     }
 
@@ -230,7 +230,7 @@ public async Task Throws_Exception_On_Unknown_Resource()
         await using IMcpClient client = await CreateMcpClientForServer();
 
         var e = await Assert.ThrowsAsync<McpException>(async () => await client.ReadResourceAsync(
-            "test://NotRegisteredResource",
+            "test:///NotRegisteredResource",
             cancellationToken: TestContext.Current.CancellationToken));
 
         Assert.Contains("Resource not found", e.Message);
@@ -268,8 +268,8 @@ public void Register_Resources_From_Current_Assembly()
         sc.AddMcpServer().WithResourcesFromAssembly();
         IServiceProvider services = sc.BuildServiceProvider();
 
-        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResource?.Uri == $"resource://{nameof(SimpleResources.SomeNeatDirectResource)}");
-        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate?.UriTemplate == $"resource://{nameof(SimpleResources.SomeNeatTemplatedResource)}{{?name}}");
+        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResource?.Uri == $"resource://mcp/{nameof(SimpleResources.SomeNeatDirectResource)}");
+        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate?.UriTemplate == $"resource://mcp/{nameof(SimpleResources.SomeNeatTemplatedResource)}{{?name}}");
     }
 
     [Fact]
@@ -279,13 +279,13 @@ public void Register_Resources_From_Multiple_Sources()
         sc.AddMcpServer()
             .WithResources<SimpleResources>()
             .WithResources<MoreResources>()
-            .WithResources([McpServerResource.Create(() => "42", new() { UriTemplate = "myResources://Returns42/{something}" })]);
+            .WithResources([McpServerResource.Create(() => "42", new() { UriTemplate = "myResources:///returns42/{something}" })]);
         IServiceProvider services = sc.BuildServiceProvider();
 
-        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResource?.Uri == $"resource://{nameof(SimpleResources.SomeNeatDirectResource)}");
-        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate?.UriTemplate == $"resource://{nameof(SimpleResources.SomeNeatTemplatedResource)}{{?name}}");
-        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate?.UriTemplate == $"resource://{nameof(MoreResources.AnotherNeatDirectResource)}");
-        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate.UriTemplate == "myResources://Returns42/{something}");
+        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResource?.Uri == $"resource://mcp/{nameof(SimpleResources.SomeNeatDirectResource)}");
+        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate?.UriTemplate == $"resource://mcp/{nameof(SimpleResources.SomeNeatTemplatedResource)}{{?name}}");
+        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate?.UriTemplate == $"resource://mcp/{nameof(MoreResources.AnotherNeatDirectResource)}");
+        Assert.Contains(services.GetServices<McpServerResource>(), t => t.ProtocolResourceTemplate.UriTemplate == "myResources:///returns42/{something}");
     }
 
     [McpServerResourceType]