removed AddNotificationHandler from server.

Author: Tyler-R-Kendrick

src/ModelContextProtocol/Server/IMcpServer.cs

@@ -31,20 +31,4 @@ public interface IMcpServer : IMcpSession
     /// Runs the server, listening for and handling client requests.
     /// </summary>
     Task RunAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Adds a handler for server notifications of a specific method.
-    /// </summary>
-    /// <param name="method">The notification method to handle.</param>
-    /// <param name="handler">The async handler function to process notifications.</param>
-    /// <remarks>
-    /// <para>
-    /// Each method may have multiple handlers. Adding a handler for a method that already has one
-    /// will not replace the existing handler.
-    /// </para>
-    /// <para>
-    /// <see cref="NotificationMethods"> provides constants for common notification methods.</see>
-    /// </para>
-    /// </remarks>
-    void AddNotificationHandler(string method, Func<JsonRpcNotification, Task> handler);
 }

src/ModelContextProtocol/Server/McpServer.cs

@@ -26,7 +26,11 @@ internal sealed class McpServer : McpJsonRpcEndpoint, IMcpServer
     /// <param name="loggerFactory">Logger factory to use for logging</param>
     /// <param name="serviceProvider">Optional service provider to use for dependency injection</param>
     /// <exception cref="McpServerException"></exception>
-    public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory? loggerFactory, IServiceProvider? serviceProvider)
+    public McpServer(
+        ITransport transport,
+        McpServerOptions options,
+        ILoggerFactory? loggerFactory,
+        IServiceProvider? serviceProvider)
         : base(loggerFactory)
     {
         Throw.IfNull(transport);
@@ -74,6 +78,7 @@ public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory?
         SetPromptsHandler(options);
         SetResourcesHandler(options);
         SetSetLoggingLevelHandler(options);
+        SetNotificationHandlers(options);
     }
 
     public ServerCapabilities? ServerCapabilities { get; set; }
@@ -382,4 +387,27 @@ private void SetSetLoggingLevelHandler(McpServerOptions options)
 
         SetRequestHandler<SetLevelRequestParams, EmptyResult>(RequestMethods.LoggingSetLevel, (request, ct) => setLoggingLevelHandler(new(this, request), ct));
     }
+
+    private void SetNotificationHandlers(McpServerOptions options)
+    {
+        if (options.NotificationHandlers is not { } handlers)
+        {
+            throw new McpServerException("Experimental capability was enabled, but NotificationHandlers were not specified.");
+        }
+
+        foreach (var handler in handlers)
+        {
+            var key = handler.Key;
+            var list = handler.Value;
+            foreach (var item in list)
+            {
+                SetNotificationHandler(key, item);
+            }
+        }
+    }
+
+    private void SetNotificationHandler(string method, Func<JsonRpcNotification, Task> handler)
+    {
+        AddNotificationHandler(method, handler);
+    }
 }

src/ModelContextProtocol/Server/McpServerOptions.cs

@@ -1,6 +1,7 @@
-
-using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Protocol.Messages;
 using System.Text.Json.Serialization;
+using ModelContextProtocol.Shared;
 
 namespace ModelContextProtocol.Server;
 
@@ -41,4 +42,10 @@ public class McpServerOptions
     /// </summary>
     [JsonIgnore]
     public Func<RequestContext<CompleteRequestParams>, CancellationToken, Task<CompleteResult>>? GetCompletionHandler { get; set; }
+
+    /// <summary>
+    /// Gets or sets the handler for get completion requests.
+    /// </summary>
+    [JsonIgnore]
+    public IReadOnlyDictionary<string, List<Func<JsonRpcNotification, Task>>> NotificationHandlers { get; init; } = new NotificationHandlers();
 }

tests/ModelContextProtocol.Tests/Server/McpServerTests.cs

@@ -24,14 +24,18 @@ public McpServerTests(ITestOutputHelper testOutputHelper)
         _serviceProvider = new ServiceCollection().BuildServiceProvider();
     }
 
-    private static McpServerOptions CreateOptions(ServerCapabilities? capabilities = null)
+    private static McpServerOptions CreateOptions(
+        ServerCapabilities? capabilities = null,
+        IReadOnlyDictionary<string, List<Func<JsonRpcNotification, Task>>>? notificationHandlers = null)
     {
+        notificationHandlers ??= new Dictionary<string, List<Func<JsonRpcNotification, Task>>>();
         return new McpServerOptions
         {
             ServerInfo = new Implementation { Name = "TestServer", Version = "1.0" },
             ProtocolVersion = "2024",
             InitializationTimeout = TimeSpan.FromSeconds(30),
             Capabilities = capabilities,
+            NotificationHandlers = notificationHandlers,
         };
     }
 
@@ -640,18 +644,20 @@ public Task RunAsync(CancellationToken cancellationToken = default) =>
     public async Task NotifyProgress_Should_Be_Handled()
     {
         await using TestServerTransport transport = new();
-        var options = CreateOptions();
-
-        var notificationReceived = new TaskCompletionSource<JsonRpcNotification>();
-
-        var server = McpServerFactory.Create(transport, options, LoggerFactory, _serviceProvider);
-        server.AddNotificationHandler(NotificationMethods.ProgressNotification, notification =>
+        TaskCompletionSource<JsonRpcNotification> notificationReceived = new();
+        var token = TestContext.Current.CancellationToken;
+        
+        Task SetNotificationHandler(JsonRpcNotification notification)
         {
             notificationReceived.SetResult(notification);
             return Task.CompletedTask;
+        }
+        var options = CreateOptions(notificationHandlers: new Dictionary<string, List<Func<JsonRpcNotification, Task>>>()
+        {
+            { NotificationMethods.ProgressNotification, [SetNotificationHandler] },
         });
-
-        Task serverTask = server.RunAsync(TestContext.Current.CancellationToken);
+        var server = McpServerFactory.Create(transport, options, LoggerFactory, _serviceProvider);
+        Task serverTask = server.RunAsync(token);
 
         await transport.SendMessageAsync(new JsonRpcNotification
         {
@@ -666,14 +672,16 @@ await transport.SendMessageAsync(new JsonRpcNotification
                     Message = "Progress message",
                 },
             },
-        }, TestContext.Current.CancellationToken);
+        }, token);
 
         var notification = await notificationReceived.Task;
         var progress = (ProgressNotification)notification.Params!;
         Assert.Equal("\"abc\"", progress.ProgressToken.ToString());
-        Assert.Equal(50, progress.Progress.Progress);
-        Assert.Equal(100, progress.Progress.Total);
-        Assert.Equal("Progress message", progress.Progress.Message);
+
+        var progressValue = progress.Progress;
+        Assert.Equal(50, progressValue.Progress);
+        Assert.Equal(100, progressValue.Total);
+        Assert.Equal("Progress message", progressValue.Message);
 
         await server.DisposeAsync();
         await serverTask;