Fix: Handle logging/setLevel request for server

Author: devcrocod

kotlin-sdk-client/src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/client/Client.kt

@@ -315,7 +315,7 @@ public open class Client(private val clientInfo: Implementation, options: Client
      * @throws IllegalStateException If the server does not support logging.
      */
     public suspend fun setLoggingLevel(level: LoggingLevel, options: RequestOptions? = null): EmptyRequestResult =
-        request<EmptyRequestResult>(SetLevelRequest(level), options)
+        request(SetLevelRequest(level), options)
 
     /**
      * Retrieves a prompt by name from the server.

kotlin-sdk-server/src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/server/ServerSession.kt

@@ -16,6 +16,7 @@ import io.modelcontextprotocol.kotlin.sdk.InitializedNotification
 import io.modelcontextprotocol.kotlin.sdk.LATEST_PROTOCOL_VERSION
 import io.modelcontextprotocol.kotlin.sdk.ListRootsRequest
 import io.modelcontextprotocol.kotlin.sdk.ListRootsResult
+import io.modelcontextprotocol.kotlin.sdk.LoggingLevel
 import io.modelcontextprotocol.kotlin.sdk.LoggingMessageNotification
 import io.modelcontextprotocol.kotlin.sdk.Method
 import io.modelcontextprotocol.kotlin.sdk.Method.Defined
@@ -43,22 +44,6 @@ public open class ServerSession(
     @Suppress("ktlint:standard:backing-property-naming")
     private var _onClose: () -> Unit = {}
 
-    init {
-        // Core protocol handlers
-        setRequestHandler<InitializeRequest>(Method.Defined.Initialize) { request, _ ->
-            handleInitialize(request)
-        }
-        setNotificationHandler<InitializedNotification>(Method.Defined.NotificationsInitialized) {
-            _onInitialized()
-            CompletableDeferred(Unit)
-        }
-    }
-
-    /**
-     * The capabilities supported by the server, related to the session.
-     */
-    private val serverCapabilities = options.capabilities
-
     /**
      * The client's reported capabilities after initialization.
      */
@@ -71,6 +56,44 @@ public open class ServerSession(
     public var clientVersion: Implementation? = null
         private set
 
+    /**
+     * The capabilities supported by the server, related to the session.
+     */
+    private val serverCapabilities = options.capabilities
+
+    /**
+     * The current logging level set by the client.
+     * When null, all messages are sent (no filtering).
+     */
+    private var currentLoggingLevel: LoggingLevel? = null
+
+    /**
+     * Map of LoggingLevel to severity index for comparison.
+     * Higher index means higher severity.
+     */
+    private val loggingLevelSeverity: Map<LoggingLevel, Int> = LoggingLevel.entries.withIndex()
+        .associate { (index, level) -> level to index }
+
+    init {
+        // Core protocol handlers
+        setRequestHandler<InitializeRequest>(Defined.Initialize) { request, _ ->
+            handleInitialize(request)
+        }
+        setNotificationHandler<InitializedNotification>(Defined.NotificationsInitialized) {
+            _onInitialized()
+            CompletableDeferred(Unit)
+        }
+
+        // Logging level handler
+        if (options.capabilities.logging != null) {
+            setRequestHandler<LoggingMessageNotification.SetLevelRequest>(Defined.LoggingSetLevel) { request, _ ->
+                currentLoggingLevel = request.level
+                logger.debug { "Logging level set to: ${request.level}" }
+                EmptyRequestResult()
+            }
+        }
+    }
+
     /**
      * Registers a callback to be invoked when the server has completed initialization.
      */
@@ -152,12 +175,20 @@ public open class ServerSession(
 
     /**
      * Sends a logging message notification to the client.
+     * Messages are filtered based on the current logging level set by the client.
+     * If no logging level is set, all messages are sent.
      *
      * @param notification The logging message notification.
      */
     public suspend fun sendLoggingMessage(notification: LoggingMessageNotification) {
-        logger.trace { "Sending logging message: ${notification.params.data}" }
-        notification(notification)
+        if (serverCapabilities.logging != null) {
+            if (!isMessageIgnored(notification.params.level)) {
+                logger.trace { "Sending logging message: ${notification.params.data}" }
+                notification(notification)
+            } else {
+                logger.trace { "Filtering out logging message with level ${notification.params.level}" }
+            }
+        }
     }
 
     /**
@@ -310,6 +341,7 @@ public open class ServerSession(
 
             Defined.LoggingSetLevel -> {
                 if (serverCapabilities.logging == null) {
+                    logger.error { "Server does not support logging (required for $method)" }
                     throw IllegalStateException("Server does not support logging (required for $method)")
                 }
             }
@@ -373,4 +405,19 @@ public open class ServerSession(
             instructions = instructions,
         )
     }
+
+    /**
+     * Checks if a message with the given level should be ignored based on the current logging level.
+     *
+     * @param level The level of the message to check.
+     * @return true if the message should be ignored (filtered out), false otherwise.
+     */
+    private fun isMessageIgnored(level: LoggingLevel): Boolean {
+        val current = currentLoggingLevel ?: return false // If no level is set, don't filter
+
+        val messageSeverity = loggingLevelSeverity[level] ?: return false
+        val currentSeverity = loggingLevelSeverity[current] ?: return false
+
+        return messageSeverity < currentSeverity
+    }
 }

kotlin-sdk-test/src/commonTest/kotlin/io/modelcontextprotocol/kotlin/sdk/client/ClientTest.kt

@@ -886,6 +886,96 @@ class ClientTest {
         )
     }
 
+    @Test
+    fun `should handle logging setLevel request`() = runTest {
+        val server = Server(
+            Implementation(name = "test server", version = "1.0"),
+            ServerOptions(
+                capabilities = ServerCapabilities(
+                    logging = EmptyJsonObject,
+                ),
+            ),
+        )
+
+        val client = Client(
+            clientInfo = Implementation(name = "test client", version = "1.0"),
+            options = ClientOptions(
+                capabilities = ClientCapabilities(),
+            ),
+        )
+
+        val (clientTransport, serverTransport) = InMemoryTransport.createLinkedPair()
+
+        val receivedMessages = mutableListOf<LoggingMessageNotification>()
+        client.setNotificationHandler<LoggingMessageNotification>(Method.Defined.NotificationsMessage) { notification ->
+            receivedMessages.add(notification)
+            CompletableDeferred(Unit)
+        }
+
+        val serverSessionResult = CompletableDeferred<ServerSession>()
+
+        listOf(
+            launch {
+                client.connect(clientTransport)
+                println("Client connected")
+            },
+            launch {
+                serverSessionResult.complete(server.connect(serverTransport))
+                println("Server connected")
+            },
+        ).joinAll()
+
+        val serverSession = serverSessionResult.await()
+
+        // Set logging level to warning
+        val result = client.setLoggingLevel(LoggingLevel.warning)
+        assertEquals(EmptyJsonObject, result._meta)
+
+        // Send messages of different levels
+        serverSession.sendLoggingMessage(
+            LoggingMessageNotification(
+                params = LoggingMessageNotification.Params(
+                    level = LoggingLevel.debug,
+                    data = buildJsonObject { put("message", "Debug - should be filtered") },
+                ),
+            ),
+        )
+
+        serverSession.sendLoggingMessage(
+            LoggingMessageNotification(
+                params = LoggingMessageNotification.Params(
+                    level = LoggingLevel.info,
+                    data = buildJsonObject { put("message", "Info - should be filtered") },
+                ),
+            ),
+        )
+
+        serverSession.sendLoggingMessage(
+            LoggingMessageNotification(
+                params = LoggingMessageNotification.Params(
+                    level = LoggingLevel.warning,
+                    data = buildJsonObject { put("message", "Warning - should pass") },
+                ),
+            ),
+        )
+
+        serverSession.sendLoggingMessage(
+            LoggingMessageNotification(
+                params = LoggingMessageNotification.Params(
+                    level = LoggingLevel.error,
+                    data = buildJsonObject { put("message", "Error - should pass") },
+                ),
+            ),
+        )
+
+        // Only warning and error should be received
+        assertEquals(2, receivedMessages.size, "Should receive only 2 messages (warning and error)")
+
+        val levels = receivedMessages.map { it.params.level }
+        assertTrue(levels.contains(LoggingLevel.warning), "Should receive warning message")
+        assertTrue(levels.contains(LoggingLevel.error), "Should receive error message")
+    }
+
     @Test
     fun `should handle server elicitation`() = runTest {
         val client = Client(