removed addnotificationhandler from client.

Author: Tyler-R-Kendrick

src/ModelContextProtocol/Client/IMcpClient.cs

@@ -1,6 +1,5 @@
 using ModelContextProtocol.Protocol.Types;
 using ModelContextProtocol.Shared;
-using ModelContextProtocol.Protocol.Messages;
 
 namespace ModelContextProtocol.Client;
 
@@ -25,21 +24,4 @@ public interface IMcpClient : IMcpSession
     /// It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
     /// </summary>
     string? ServerInstructions { get; }
-
-    
-    /// <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/Client/McpClient.cs

@@ -59,6 +59,8 @@ public McpClient(IClientTransport clientTransport, McpClientOptions options, Mcp
                 RequestMethods.RootsList,
                 (request, cancellationToken) => rootsHandler(request, cancellationToken));
         }
+
+        SetNotificationHandlers(options.NotificationHandlers);
     }
 
     /// <inheritdoc/>
@@ -141,6 +143,20 @@ await SendMessageAsync(
         }
     }
 
+    private void SetNotificationHandlers(
+        IReadOnlyDictionary<string, List<Func<JsonRpcNotification, Task>>> notificationHandlers)
+    {
+        foreach (var handlers in notificationHandlers)
+        {
+            var key = handlers.Key;
+            var list = handlers.Value;
+            foreach (var item in list)
+            {
+                AddNotificationHandler(key, item);
+            }
+        }
+    }
+
     /// <inheritdoc/>
     public override async ValueTask DisposeUnsynchronizedAsync()
     {

src/ModelContextProtocol/Client/McpClientOptions.cs

@@ -1,4 +1,7 @@
-using ModelContextProtocol.Protocol.Types;
+using System.Text.Json.Serialization;
+using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Protocol.Messages;
+using ModelContextProtocol.Shared;
 
 namespace ModelContextProtocol.Client;
 
@@ -28,4 +31,11 @@ public class McpClientOptions
     /// Timeout for initialization sequence.
     /// </summary>
     public TimeSpan InitializationTimeout { get; set; } = TimeSpan.FromSeconds(60);
+
+    /// <summary>
+    /// Gets or sets the handler for get notifications.
+    /// </summary>
+    [JsonIgnore]
+    public IReadOnlyDictionary<string, List<Func<JsonRpcNotification, Task>>> NotificationHandlers { get; init; } = new NotificationHandlers();
+
 }

src/ModelContextProtocol/Server/McpServer.cs

@@ -14,7 +14,7 @@ internal sealed class McpServer : McpJsonRpcEndpoint, IMcpServer
     private readonly EventHandler? _toolsChangedDelegate;
     private readonly EventHandler? _promptsChangedDelegate;
 
-    private ITransport _sessionTransport;
+    private readonly ITransport _sessionTransport;
     private string _endpointName;
 
     /// <summary>

src/ModelContextProtocol/Server/McpServerOptions.cs

@@ -44,7 +44,7 @@ public class McpServerOptions
     public Func<RequestContext<CompleteRequestParams>, CancellationToken, Task<CompleteResult>>? GetCompletionHandler { get; set; }
 
     /// <summary>
-    /// Gets or sets the handler for get completion requests.
+    /// Gets or sets the handler for get notifications.
     /// </summary>
     [JsonIgnore]
     public IReadOnlyDictionary<string, List<Func<JsonRpcNotification, Task>>> NotificationHandlers { get; init; } = new NotificationHandlers();

tests/ModelContextProtocol.Tests/ClientIntegrationTests.cs

@@ -253,15 +253,26 @@ public async Task SubscribeResource_Stdio()
     {
         // arrange
         var clientId = "test_server";
-
-        // act
         TaskCompletionSource<bool> tcs = new();
-        await using var client = await _fixture.CreateClientAsync(clientId);
-        client.AddNotificationHandler(NotificationMethods.ResourceUpdatedNotification, (notification) =>
+        Task HandleResourceUpdatedNotification(JsonRpcNotification notification)
         {
             var notificationParams = JsonSerializer.Deserialize<ResourceUpdatedNotificationParams>(notification.Params!.ToString() ?? string.Empty);
             tcs.TrySetResult(true);
             return Task.CompletedTask;
+        }
+
+        // act
+        await using var client = await _fixture.CreateClientAsync(clientId, new()
+        {
+            ClientInfo = new()
+            {
+                Name = "IntegrationTestClient",
+                Version = "1.0.0"
+            },
+            NotificationHandlers = new Dictionary<string, List<Func<JsonRpcNotification, Task>>>()
+            {
+                [NotificationMethods.ResourceUpdatedNotification] = [HandleResourceUpdatedNotification],
+            },
         });
         await client.SubscribeToResourceAsync("test://static/resource/1", TestContext.Current.CancellationToken);
 
@@ -274,15 +285,26 @@ public async Task UnsubscribeResource_Stdio()
     {
         // arrange
         var clientId = "test_server";
-
-        // act
         TaskCompletionSource<bool> receivedNotification = new();
-        await using var client = await _fixture.CreateClientAsync(clientId);
-        client.AddNotificationHandler(NotificationMethods.ResourceUpdatedNotification, (notification) =>
+        Task HandleResourceUpdatedNotification(JsonRpcNotification notification)
         {
             var notificationParams = JsonSerializer.Deserialize<ResourceUpdatedNotificationParams>(notification.Params!.ToString() ?? string.Empty);
             receivedNotification.TrySetResult(true);
             return Task.CompletedTask;
+        }
+
+        // act
+        await using var client = await _fixture.CreateClientAsync(clientId, new()
+        {
+            ClientInfo = new()
+            {
+                Name = "IntegrationTestClient",
+                Version = "1.0.0"
+            },
+            NotificationHandlers = new Dictionary<string, List<Func<JsonRpcNotification, Task>>>()
+            {
+                [NotificationMethods.ResourceUpdatedNotification] = [HandleResourceUpdatedNotification],
+            },
         });
         await client.SubscribeToResourceAsync("test://static/resource/1", TestContext.Current.CancellationToken);
 
@@ -543,6 +565,16 @@ public async Task SamplingViaChatClient_RequestResponseProperlyPropagated()
     public async Task SetLoggingLevel_ReceivesLoggingMessages(string clientId)
     {
         // arrange
+        TaskCompletionSource<bool> receivedNotification = new();
+        Task HandleLoggingNotification(JsonRpcNotification notification)
+        {
+            var loggingMessageNotificationParameters = JsonSerializer.Deserialize<LoggingMessageNotificationParams>(notification.Params!.ToString() ?? string.Empty);
+            if (loggingMessageNotificationParameters is not null)
+            {
+                receivedNotification.TrySetResult(true);
+            }
+            return Task.CompletedTask;
+        }
         JsonSerializerOptions jsonSerializerOptions = new(JsonSerializerDefaults.Web)
         {
             TypeInfoResolver = new DefaultJsonTypeInfoResolver(),
@@ -552,17 +584,17 @@ public async Task SetLoggingLevel_ReceivesLoggingMessages(string clientId)
             Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
         };
 
-        TaskCompletionSource<bool> receivedNotification = new();
-        await using var client = await _fixture.CreateClientAsync(clientId);
-        client.AddNotificationHandler(NotificationMethods.LoggingMessageNotification, (notification) =>
+        await using var client = await _fixture.CreateClientAsync(clientId, new()
         {
-            var loggingMessageNotificationParameters = JsonSerializer.Deserialize<LoggingMessageNotificationParams>(notification.Params!.ToString() ?? string.Empty,
-                jsonSerializerOptions);
-            if (loggingMessageNotificationParameters is not null)
+            ClientInfo = new()
             {
-                receivedNotification.TrySetResult(true);
-            }
-            return Task.CompletedTask;
+                Name = "IntegrationTestClient",
+                Version = "1.0.0"
+            },
+            NotificationHandlers = new Dictionary<string, List<Func<JsonRpcNotification, Task>>>()
+            {
+                [NotificationMethods.LoggingMessageNotification] = [HandleLoggingNotification],
+            },
         });
 
         // act

tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsPromptsTests.cs

@@ -117,7 +117,8 @@ public async ValueTask DisposeAsync()
         Dispose();
     }
 
-    private async Task<IMcpClient> CreateMcpClientForServer()
+    private async Task<IMcpClient> CreateMcpClientForServer(
+        Dictionary<string, List<Func<JsonRpcNotification, Task>>>? notificationHandlers = null)
     {
         return await McpClientFactory.CreateAsync(
             new McpServerConfig()
@@ -126,6 +127,15 @@ private async Task<IMcpClient> CreateMcpClientForServer()
                 Name = "TestServer",
                 TransportType = "ignored",
             },
+            clientOptions: new()
+            {
+                ClientInfo = new()
+                {
+                    Name = "TestClient",
+                    Version = "1.0.0",
+                },
+                NotificationHandlers = notificationHandlers ?? [],
+            },
             createTransportFunc: (_, _) => new StreamClientTransport(
                 serverInput: _clientToServerPipe.Writer.AsStream(),
                 serverOutput: _serverToClientPipe.Reader.AsStream(),
@@ -175,19 +185,24 @@ public async Task Can_List_And_Call_Registered_Prompts()
     [Fact]
     public async Task Can_Be_Notified_Of_Prompt_Changes()
     {
-        IMcpClient client = await CreateMcpClientForServer();
-
-        var prompts = await client.ListPromptsAsync(TestContext.Current.CancellationToken);
-        Assert.Equal(6, prompts.Count);
-
+        var token = TestContext.Current.CancellationToken;
         Channel<JsonRpcNotification> listChanged = Channel.CreateUnbounded<JsonRpcNotification>();
-        client.AddNotificationHandler("notifications/prompts/list_changed", notification =>
+        Task HandleListChangedNotification(JsonRpcNotification notification)
         {
             listChanged.Writer.TryWrite(notification);
             return Task.CompletedTask;
-        });
+        }
+        IMcpClient client = await CreateMcpClientForServer(
+            notificationHandlers: new()
+            {
+                [NotificationMethods.PromptListChangedNotification] = [HandleListChangedNotification],
+            }
+        );
+
+        var prompts = await client.ListPromptsAsync(token);
+        Assert.Equal(6, prompts.Count);
 
-        var notificationRead = listChanged.Reader.ReadAsync(TestContext.Current.CancellationToken);
+        var notificationRead = listChanged.Reader.ReadAsync(token);
         Assert.False(notificationRead.IsCompleted);
 
         var serverOptions = _serviceProvider.GetRequiredService<IOptions<McpServerOptions>>().Value;
@@ -198,16 +213,16 @@ public async Task Can_Be_Notified_Of_Prompt_Changes()
         serverPrompts.Add(newPrompt);
         await notificationRead;
 
-        prompts = await client.ListPromptsAsync(TestContext.Current.CancellationToken);
+        prompts = await client.ListPromptsAsync(token);
         Assert.Equal(7, prompts.Count);
         Assert.Contains(prompts, t => t.Name == "NewPrompt");
 
-        notificationRead = listChanged.Reader.ReadAsync(TestContext.Current.CancellationToken);
+        notificationRead = listChanged.Reader.ReadAsync(token);
         Assert.False(notificationRead.IsCompleted);
         serverPrompts.Remove(newPrompt);
         await notificationRead;
 
-        prompts = await client.ListPromptsAsync(TestContext.Current.CancellationToken);
+        prompts = await client.ListPromptsAsync(token);
         Assert.Equal(6, prompts.Count);
         Assert.DoesNotContain(prompts, t => t.Name == "NewPrompt");
     }

tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsToolsTests.cs

@@ -141,15 +141,25 @@ public async ValueTask DisposeAsync()
         Dispose();
     }
 
-    private async Task<IMcpClient> CreateMcpClientForServer()
+    private async Task<IMcpClient> CreateMcpClientForServer(
+        IReadOnlyDictionary<string, List<Func<JsonRpcNotification, Task>>>? notificationHandlers = null)
     {
         return await McpClientFactory.CreateAsync(
-             new McpServerConfig()
-             {
-                 Id = "TestServer",
-                 Name = "TestServer",
-                 TransportType = "ignored",
-             },
+            new McpServerConfig()
+            {
+                Id = "TestServer",
+                Name = "TestServer",
+                TransportType = "ignored",
+            },
+            clientOptions: new()
+            {
+                ClientInfo = new()
+                {
+                    Name = "TestClient",
+                    Version = "1.0.0",
+                },
+                NotificationHandlers = notificationHandlers ?? new Dictionary<string, List<Func<JsonRpcNotification, Task>>>(),
+            },
             createTransportFunc: (_, _) => new StreamClientTransport(
                 serverInput: _clientToServerPipe.Writer.AsStream(),
                 _serverToClientPipe.Reader.AsStream(),
@@ -242,17 +252,21 @@ public async Task Can_Create_Multiple_Servers_From_Options_And_List_Registered_T
     [Fact]
     public async Task Can_Be_Notified_Of_Tool_Changes()
     {
-        IMcpClient client = await CreateMcpClientForServer();
-
-        var tools = await client.ListToolsAsync(TestContext.Current.CancellationToken);
-        Assert.Equal(16, tools.Count);
-
         Channel<JsonRpcNotification> listChanged = Channel.CreateUnbounded<JsonRpcNotification>();
-        client.AddNotificationHandler(NotificationMethods.ToolListChangedNotification, notification =>
+        Task HandleListChangeNotification(JsonRpcNotification notification)
         {
             listChanged.Writer.TryWrite(notification);
             return Task.CompletedTask;
-        });
+        }
+        IMcpClient client = await CreateMcpClientForServer(
+            notificationHandlers: new Dictionary<string, List<Func<JsonRpcNotification, Task>>>()
+            {
+                [NotificationMethods.ToolListChangedNotification] = [HandleListChangeNotification],
+            }
+        );
+
+        var tools = await client.ListToolsAsync(TestContext.Current.CancellationToken);
+        Assert.Equal(16, tools.Count);
 
         var notificationRead = listChanged.Reader.ReadAsync(TestContext.Current.CancellationToken);
         Assert.False(notificationRead.IsCompleted);
@@ -607,17 +621,21 @@ public void Create_ExtractsToolAnnotations_SomeSet()
     [Fact]
     public async Task HandlesIProgressParameter()
     {
+        var token = TestContext.Current.CancellationToken;
         ConcurrentQueue<ProgressNotification> notifications = new();
-
-        IMcpClient client = await CreateMcpClientForServer();
-        client.AddNotificationHandler(NotificationMethods.ProgressNotification, notification =>
+        Task HandleProgressNotification(JsonRpcNotification notification)
         {
             ProgressNotification pn = JsonSerializer.Deserialize<ProgressNotification>((JsonElement)notification.Params!)!;
             notifications.Enqueue(pn);
             return Task.CompletedTask;
-        });
+        }
+        IMcpClient client = await CreateMcpClientForServer(
+            notificationHandlers: new Dictionary<string, List<Func<JsonRpcNotification, Task>>>()
+            {
+                [NotificationMethods.ProgressNotification] = [HandleProgressNotification],
+            });
 
-        var tools = await client.ListToolsAsync(TestContext.Current.CancellationToken);
+        var tools = await client.ListToolsAsync(token);
         Assert.NotNull(tools);
         Assert.NotEmpty(tools);
 
@@ -631,7 +649,7 @@ public async Task HandlesIProgressParameter()
                 Name = progressTool.ProtocolTool.Name,
                 Meta = new() { ProgressToken = new("abc123") },
             },
-        }, TestContext.Current.CancellationToken);
+        }, token);
 
         Assert.Contains("done", JsonSerializer.Serialize(result));
         SpinWait.SpinUntil(() => notifications.Count == 10, TimeSpan.FromSeconds(10));