Address feedback

Author: stephentoub

src/ModelContextProtocol/Server/McpServer.cs

@@ -489,10 +489,10 @@ internal static LoggingLevel ToLoggingLevel(LogLevel level) =>
         {
             LogLevel.Trace => Protocol.Types.LoggingLevel.Debug,
             LogLevel.Debug => Protocol.Types.LoggingLevel.Debug,
+            LogLevel.Information => Protocol.Types.LoggingLevel.Info,
             LogLevel.Warning => Protocol.Types.LoggingLevel.Warning,
             LogLevel.Error => Protocol.Types.LoggingLevel.Error,
             LogLevel.Critical => Protocol.Types.LoggingLevel.Critical,
-            LogLevel.Information => Protocol.Types.LoggingLevel.Info,
-            _ => Protocol.Types.LoggingLevel.Debug,
+            _ => Protocol.Types.LoggingLevel.Emergency,
         };
 }

src/ModelContextProtocol/Server/McpServerExtensions.cs

@@ -158,11 +158,11 @@ public static IChatClient AsSamplingChatClient(this IMcpServer server)
     /// <summary>Gets an <see cref="ILogger"/> on which logged messages will be sent as notifications to the client.</summary>
     /// <param name="server">The server to wrap as an <see cref="ILogger"/>.</param>
     /// <returns>An <see cref="ILogger"/> that can be used to log to the client..</returns>
-    public static ILogger AsClientLogger(this IMcpServer server)
+    public static ILoggerProvider AsClientLoggerProvider(this IMcpServer server)
     {
         Throw.IfNull(server);
 
-        return new ClientLogger(server);
+        return new ClientLoggerProvider(server);
     }
 
     /// <summary>
@@ -224,40 +224,54 @@ void IDisposable.Dispose() { } // nop
     }
 
     /// <summary>
-    /// Provides an <see cref="ILogger"/> implementation for sending logging message notifications
-    /// to the client for logged messages.
+    /// Provides an <see cref="ILoggerProvider"/> implementation for creating loggers
+    /// that send logging message notifications to the client for logged messages.
     /// </summary>
-    private sealed class ClientLogger(IMcpServer server) : ILogger
+    private sealed class ClientLoggerProvider(IMcpServer server) : ILoggerProvider
     {
         /// <inheritdoc />
-        public IDisposable? BeginScope<TState>(TState state) where TState : notnull =>
-            null;
+        public ILogger CreateLogger(string categoryName)
+        {
+            Throw.IfNull(categoryName);
 
-        /// <inheritdoc />
-        public bool IsEnabled(LogLevel logLevel) =>
-            server?.LoggingLevel is { } loggingLevel &&
-            McpServer.ToLoggingLevel(logLevel) >= loggingLevel;
+            return new ClientLogger(server, categoryName);
+        }
 
         /// <inheritdoc />
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        void IDisposable.Dispose() { }
+
+        private sealed class ClientLogger(IMcpServer server, string categoryName) : ILogger
         {
-            if (!IsEnabled(logLevel))
+            /// <inheritdoc />
+            public IDisposable? BeginScope<TState>(TState state) where TState : notnull =>
+                null;
+
+            /// <inheritdoc />
+            public bool IsEnabled(LogLevel logLevel) =>
+                server?.LoggingLevel is { } loggingLevel &&
+                McpServer.ToLoggingLevel(logLevel) >= loggingLevel;
+
+            /// <inheritdoc />
+            public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
             {
-                return;
-            }
+                if (!IsEnabled(logLevel))
+                {
+                    return;
+                }
 
-            Throw.IfNull(formatter);
+                Throw.IfNull(formatter);
 
-            Log(logLevel, formatter(state, exception));
+                Log(logLevel, formatter(state, exception));
 
-            void Log(LogLevel logLevel, string message)
-            {
-                _ = server.SendNotificationAsync(NotificationMethods.LoggingMessageNotification, new LoggingMessageNotificationParams()
+                void Log(LogLevel logLevel, string message)
                 {
-                    Level = McpServer.ToLoggingLevel(logLevel),
-                    Data = JsonSerializer.SerializeToElement(message, McpJsonUtilities.JsonContext.Default.String),
-                    Logger = eventId.Name,
-                });
+                    _ = server.SendNotificationAsync(NotificationMethods.LoggingMessageNotification, new LoggingMessageNotificationParams()
+                    {
+                        Level = McpServer.ToLoggingLevel(logLevel),
+                        Data = JsonSerializer.SerializeToElement(message, McpJsonUtilities.JsonContext.Default.String),
+                        Logger = categoryName,
+                    });
+                }
             }
         }
     }

tests/ModelContextProtocol.Tests/Client/McpClientExtensionsTests.cs

@@ -379,11 +379,16 @@ public async Task WithDescription_ChangesToolDescription()
     }
 
     [Fact]
-    public async Task AsClientLogger_MessagesSentToClient()
+    public async Task AsClientLoggerProvider_MessagesSentToClient()
     {
         IMcpClient client = await CreateMcpClientForServer();
 
-        ILogger logger = _server.AsClientLogger();
+        ILoggerProvider loggerProvider = _server.AsClientLoggerProvider();
+        Assert.Throws<ArgumentNullException>("categoryName", () => loggerProvider.CreateLogger(null!));
+
+        ILogger logger = loggerProvider.CreateLogger("TestLogger");
+        Assert.NotNull(logger);
+
         Assert.Null(logger.BeginScope(""));
 
         Assert.Null(_server.LoggingLevel);
@@ -433,9 +438,29 @@ public async Task AsClientLogger_MessagesSentToClient()
                 var m = await channel.Reader.ReadAsync(TestContext.Current.CancellationToken);
                 Assert.NotNull(m);
                 Assert.NotNull(m.Data);
-                
-                string? s = JsonSerializer.Deserialize<string>(m.Data.Value);
+
+                Assert.Equal("TestLogger", m.Logger);
+
+                string ? s = JsonSerializer.Deserialize<string>(m.Data.Value);
                 Assert.NotNull(s);
+
+                if (s.Contains("Information"))
+                {
+                    Assert.Equal(LoggingLevel.Info, m.Level);
+                }
+                else if (s.Contains("Warning"))
+                {
+                    Assert.Equal(LoggingLevel.Warning, m.Level);
+                }
+                else if (s.Contains("Error"))
+                {
+                    Assert.Equal(LoggingLevel.Error, m.Level);
+                }
+                else if (s.Contains("Critical"))
+                {
+                    Assert.Equal(LoggingLevel.Critical, m.Level);
+                }
+
                 data.Add(s);
             }