Fix: Allow handlers for empty tool/prompt/resource collections

Changed condition from `IsEmpty: false` to `not null` check in McpServerImpl.cs
for resources (line 298), prompts (line 459), and tools (line 547). This allows
handlers to be synthesized even when collections are empty, enabling dynamic
addition of items after initialization.

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

Author: Copilot

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -295,7 +295,7 @@ subscribeHandler is null && unsubscribeHandler is null && resources is null &&
         var subscribe = resourcesCapability?.Subscribe;
 
         // Handle resources provided via DI.
-        if (resources is { IsEmpty: false })
+        if (resources is not null)
         {
             var originalListResourcesHandler = listResourcesHandler;
             listResourcesHandler = async (request, cancellationToken) =>
@@ -456,7 +456,7 @@ private void ConfigurePrompts(McpServerOptions options)
         var listChanged = promptsCapability?.ListChanged;
 
         // Handle tools provided via DI by augmenting the handlers to incorporate them.
-        if (prompts is { IsEmpty: false })
+        if (prompts is not null)
         {
             var originalListPromptsHandler = listPromptsHandler;
             listPromptsHandler = async (request, cancellationToken) =>
@@ -544,7 +544,7 @@ private void ConfigureTools(McpServerOptions options)
         var listChanged = toolsCapability?.ListChanged;
 
         // Handle tools provided via DI by augmenting the handlers to incorporate them.
-        if (tools is { IsEmpty: false })
+        if (tools is not null)
         {
             var originalListToolsHandler = listToolsHandler;
             listToolsHandler = async (request, cancellationToken) =>

tests/ModelContextProtocol.Tests/Server/EmptyCollectionTests.cs

@@ -0,0 +1,160 @@
+using Microsoft.Extensions.DependencyInjection;
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+
+namespace ModelContextProtocol.Tests.Server;
+
+/// <summary>
+/// Tests to verify that handlers are synthesized for empty collections that can be populated dynamically.
+/// This addresses the issue where handlers were only created when collections had items.
+/// </summary>
+public class EmptyCollectionTests : ClientServerTestBase
+{
+    public EmptyCollectionTests(ITestOutputHelper testOutputHelper)
+        : base(testOutputHelper)
+    {
+    }
+
+    private McpServerResourceCollection? _resourceCollection;
+    private McpServerPrimitiveCollection<McpServerTool>? _toolCollection;
+    private McpServerPrimitiveCollection<McpServerPrompt>? _promptCollection;
+
+    protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder)
+    {
+        // Initialize empty collections
+        _resourceCollection = [];
+        _toolCollection = [];
+        _promptCollection = [];
+
+        mcpServerBuilder.Services.Configure<McpServerOptions>(options =>
+        {
+            options.ServerInfo = new Implementation
+            {
+                Name = "empty-collection-test",
+                Version = "1.0.0"
+            };
+
+            // Set empty collections - handlers should still be synthesized
+            options.ResourceCollection = _resourceCollection;
+            options.ToolCollection = _toolCollection;
+            options.PromptCollection = _promptCollection;
+        });
+    }
+
+    [Fact]
+    public async Task EmptyResourceCollection_CanAddResourcesDynamically()
+    {
+        using var client = await CreateMcpClientForServer();
+
+        // Initially, the resource collection is empty
+        var initialResources = await client.ListResourcesAsync();
+        Assert.Empty(initialResources);
+
+        // Add a resource dynamically
+        _resourceCollection!.Add(McpServerResource.Create(
+            () => "test content",
+            new() { UriTemplate = "test://resource/1" }));
+
+        // The resource should now be listed
+        var updatedResources = await client.ListResourcesAsync();
+        Assert.Single(updatedResources);
+        Assert.Equal("test://resource/1", updatedResources[0].Uri);
+    }
+
+    [Fact]
+    public async Task EmptyToolCollection_CanAddToolsDynamically()
+    {
+        using var client = await CreateMcpClientForServer();
+
+        // Initially, the tool collection is empty
+        var initialTools = await client.ListToolsAsync();
+        Assert.Empty(initialTools);
+
+        // Add a tool dynamically
+        _toolCollection!.Add(McpServerTool.Create(
+            () => "test result",
+            new() { Name = "test_tool", Description = "A test tool" }));
+
+        // The tool should now be listed
+        var updatedTools = await client.ListToolsAsync();
+        Assert.Single(updatedTools);
+        Assert.Equal("test_tool", updatedTools[0].Name);
+    }
+
+    [Fact]
+    public async Task EmptyPromptCollection_CanAddPromptsDynamically()
+    {
+        using var client = await CreateMcpClientForServer();
+
+        // Initially, the prompt collection is empty
+        var initialPrompts = await client.ListPromptsAsync();
+        Assert.Empty(initialPrompts);
+
+        // Add a prompt dynamically
+        _promptCollection!.Add(McpServerPrompt.Create(
+            () => new ChatMessage(ChatRole.User, "test prompt"),
+            new() { Name = "test_prompt", Description = "A test prompt" }));
+
+        // The prompt should now be listed
+        var updatedPrompts = await client.ListPromptsAsync();
+        Assert.Single(updatedPrompts);
+        Assert.Equal("test_prompt", updatedPrompts[0].Name);
+    }
+
+    [Fact]
+    public async Task EmptyResourceCollection_CanCallReadResourceAfterAddingDynamically()
+    {
+        using var client = await CreateMcpClientForServer();
+
+        // Add a resource dynamically
+        _resourceCollection!.Add(McpServerResource.Create(
+            () => "dynamic content",
+            new() { UriTemplate = "test://resource/dynamic" }));
+
+        // Read the resource
+        var result = await client.ReadResourceAsync("test://resource/dynamic");
+        Assert.NotNull(result);
+        Assert.Single(result.Contents);
+        Assert.IsType<TextContent>(result.Contents[0]);
+        Assert.Equal("dynamic content", ((TextContent)result.Contents[0]).Text);
+    }
+
+    [Fact]
+    public async Task EmptyToolCollection_CanCallToolAfterAddingDynamically()
+    {
+        using var client = await CreateMcpClientForServer();
+
+        // Add a tool dynamically
+        _toolCollection!.Add(McpServerTool.Create(
+            () => "dynamic result",
+            new() { Name = "dynamic_tool", Description = "A dynamic tool" }));
+
+        // Call the tool
+        var result = await client.CallToolAsync("dynamic_tool");
+        Assert.NotNull(result);
+        Assert.Single(result.Content);
+        Assert.IsType<TextContent>(result.Content[0]);
+        Assert.Equal("dynamic result", ((TextContent)result.Content[0]).Text);
+    }
+
+    [Fact]
+    public async Task EmptyPromptCollection_CanGetPromptAfterAddingDynamically()
+    {
+        using var client = await CreateMcpClientForServer();
+
+        // Add a prompt dynamically
+        _promptCollection!.Add(McpServerPrompt.Create(
+            () => new ChatMessage(ChatRole.User, "dynamic prompt content"),
+            new() { Name = "dynamic_prompt", Description = "A dynamic prompt" }));
+
+        // Get the prompt
+        var result = await client.GetPromptAsync("dynamic_prompt");
+        Assert.NotNull(result);
+        Assert.Single(result.Messages);
+        Assert.Equal(ChatRole.User, result.Messages[0].Role);
+        Assert.Single(result.Messages[0].Content);
+        Assert.IsType<TextContent>(result.Messages[0].Content[0]);
+        Assert.Equal("dynamic prompt content", ((TextContent)result.Messages[0].Content[0]).Text);
+    }
+}