Merge branch 'main' into feature/fix_sse_client_endpoint

Author: e5l

build.gradle.kts

@@ -219,6 +219,7 @@ kotlin {
                 implementation(libs.ktor.server.test.host)
                 implementation(libs.kotlinx.coroutines.test)
                 implementation(libs.kotlinx.coroutines.debug)
+                implementation(libs.kotest.assertions.json)
             }
         }
 

gradle/libs.versions.toml

@@ -13,6 +13,7 @@ logging = "7.0.0"
 jreleaser = "1.15.0"
 binaryCompatibilityValidatorPlugin = "0.17.0"
 slf4j = "2.0.16"
+kotest = "5.9.1"
 
 [libraries]
 # Kotlinx libraries
@@ -32,8 +33,7 @@ kotlinx-coroutines-debug = { group = "org.jetbrains.kotlinx", name = "kotlinx-co
 ktor-server-test-host = { group = "io.ktor", name = "ktor-server-test-host", version.ref = "ktor" }
 mockk = { group = "io.mockk", name = "mockk", version.ref = "mockk" }
 slf4j-simple = { group = "org.slf4j", name = "slf4j-simple", version.ref = "slf4j" }
-
-
+kotest-assertions-json = { group = "io.kotest", name = "kotest-assertions-json", version.ref = "kotest" }
 
 [plugins]
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }

samples/kotlin-mcp-server/build.gradle.kts

@@ -13,10 +13,8 @@ group = "org.example"
 version = "0.1.0"
 
 dependencies {
-    implementation("io.modelcontextprotocol:kotlin-sdk:0.2.0")
+    implementation("io.modelcontextprotocol:kotlin-sdk:0.3.0")
     implementation("org.slf4j:slf4j-nop:2.0.9")
-
-    testImplementation(kotlin("test"))
 }
 
 tasks.test {

samples/kotlin-mcp-server/src/main/kotlin/Main.kt

@@ -22,6 +22,9 @@ import io.modelcontextprotocol.kotlin.sdk.server.StdioServerTransport
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.runBlocking
+import kotlinx.io.asSink
+import kotlinx.io.asSource
+import kotlinx.io.buffered
 
 /**
  * Start sse-server mcp on port 3001.
@@ -35,9 +38,9 @@ fun main(args: Array<String>) {
     val command = args.firstOrNull() ?: "--sse-server-ktor"
     val port = args.getOrNull(1)?.toIntOrNull() ?: 3001
     when (command) {
-        "--stdio" -> `run mcp server using stdio`()
-        "--sse-server-ktor" -> `run sse mcp server using Ktor plugin`(port)
-        "--sse-server" -> `run sse mcp server with plain configuration`(port)
+        "--stdio" -> runMcpServerUsingStdio()
+        "--sse-server-ktor" -> runSseMcpServerUsingKtorPlugin(port)
+        "--sse-server" -> runSseMcpServerWithPlainConfiguration(port)
         else -> {
             System.err.println("Unknown command: $command")
         }
@@ -114,11 +117,14 @@ fun configureServer(): Server {
     return server
 }
 
-fun `run mcp server using stdio`() {
+fun runMcpServerUsingStdio() {
     // Note: The server will handle listing prompts, tools, and resources automatically.
     // The handleListResourceTemplates will return empty as defined in the Server code.
     val server = configureServer()
-    val transport = StdioServerTransport()
+    val transport = StdioServerTransport(
+        inputStream = System.`in`.asSource().buffered(),
+        outputStream = System.out.asSink().buffered()
+    )
 
     runBlocking {
         server.connect(transport)
@@ -132,7 +138,7 @@ fun `run mcp server using stdio`() {
     }
 }
 
-fun `run sse mcp server with plain configuration`(port: Int): Unit = runBlocking {
+fun runSseMcpServerWithPlainConfiguration(port: Int): Unit = runBlocking {
     val servers = ConcurrentMap<String, Server>()
     println("Starting sse server on port $port. ")
     println("Use inspector to connect to the http://localhost:$port/sse")
@@ -179,13 +185,13 @@ fun `run sse mcp server with plain configuration`(port: Int): Unit = runBlocking
  * @param port The port number on which the SSE MCP server will listen for client connections.
  * @return Unit This method does not return a value.
  */
-fun `run sse mcp server using Ktor plugin`(port: Int): Unit = runBlocking {
+fun runSseMcpServerUsingKtorPlugin(port: Int): Unit = runBlocking {
     println("Starting sse server on port $port")
     println("Use inspector to connect to the http://localhost:$port/sse")
 
     embeddedServer(CIO, host = "0.0.0.0", port = port) {
         MCP {
             return@MCP configureServer()
         }
-    }
+    }.start(wait = true)
 }

src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/shared/Protocol.kt

@@ -440,7 +440,7 @@ public abstract class Protocol(
         val serializer = McpJson.serializersModule.serializer(requestType)
 
         requestHandlers[method.value] = { request, extraHandler ->
-            val result = request.params?.let { McpJson.decodeFromJsonElement(serializer, it) }
+            val result = McpJson.decodeFromJsonElement(serializer, request.params)
             val response = if (result != null) {
                 @Suppress("UNCHECKED_CAST")
                 block(result as T, extraHandler)

src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/types.kt

@@ -215,7 +215,7 @@ public sealed interface JSONRPCMessage
 public data class JSONRPCRequest(
     val id: RequestId = RequestId.NumberId(REQUEST_MESSAGE_ID.incrementAndGet()),
     val method: String,
-    val params: JsonElement? = null,
+    val params: JsonElement = EmptyJsonObject,
     val jsonrpc: String = JSONRPC_VERSION,
 ) : JSONRPCMessage
 

src/commonTest/kotlin/ToolSerializationTest.kt

@@ -0,0 +1,57 @@
+package io.modelcontextprotocol.kotlin.sdk
+
+import io.kotest.assertions.json.shouldEqualJson
+import io.modelcontextprotocol.kotlin.sdk.shared.McpJson
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ToolSerializationTest {
+
+    // see https://docs.anthropic.com/en/docs/build-with-claude/tool-use
+    /* language=json */
+    private val getWeatherToolJson = """
+        {
+          "name": "get_weather",
+          "description": "Get the current weather in a given location",
+          "inputSchema": {
+            "type": "object",
+            "properties": {
+              "location": {
+                "type": "string",
+                "description": "The city and state, e.g. San Francisco, CA"
+              }
+            },
+            "required": ["location"]
+          }
+        }
+    """.trimIndent()
+
+    val getWeatherTool = Tool(
+        name = "get_weather",
+        description = "Get the current weather in a given location",
+        inputSchema = Tool.Input(
+            properties = buildJsonObject {
+                put("location", buildJsonObject {
+                    put("type", JsonPrimitive("string"))
+                    put("description", JsonPrimitive("The city and state, e.g. San Francisco, CA"))
+                })
+            },
+            required = listOf("location")
+        )
+    )
+
+    @Test
+    fun `should serialize get_weather tool`() {
+        McpJson.encodeToString(getWeatherTool) shouldEqualJson getWeatherToolJson
+    }
+
+    @Test
+    fun `should deserialize get_weather tool`() {
+        val tool = McpJson.decodeFromString<Tool>(getWeatherToolJson)
+        assertEquals(expected = getWeatherTool, actual = tool)
+    }
+
+}

src/jvmTest/kotlin/client/ClientTest.kt

@@ -24,6 +24,7 @@ import io.modelcontextprotocol.kotlin.sdk.Role
 import io.modelcontextprotocol.kotlin.sdk.SUPPORTED_PROTOCOL_VERSIONS
 import io.modelcontextprotocol.kotlin.sdk.ServerCapabilities
 import io.modelcontextprotocol.kotlin.sdk.TextContent
+import io.modelcontextprotocol.kotlin.sdk.Tool
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.TimeoutCancellationException
 import kotlinx.coroutines.cancel
@@ -38,6 +39,7 @@ import org.junit.jupiter.api.Test
 import io.modelcontextprotocol.kotlin.sdk.server.Server
 import io.modelcontextprotocol.kotlin.sdk.server.ServerOptions
 import io.modelcontextprotocol.kotlin.sdk.shared.AbstractTransport
+import org.junit.jupiter.api.assertInstanceOf
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
@@ -494,5 +496,79 @@ class ClientTest {
         }
     }
 
+    @Test
+    fun `JSONRPCRequest with ToolsList method and default params returns list of tools`() = runTest {
+        val serverOptions = ServerOptions(
+            capabilities = ServerCapabilities(
+                tools = ServerCapabilities.Tools(null)
+            )
+        )
+        val server = Server(
+            Implementation(name = "test server", version = "1.0"),
+            serverOptions
+        )
+
+        server.setRequestHandler<InitializeRequest>(Method.Defined.Initialize) { request, _ ->
+            InitializeResult(
+                protocolVersion = LATEST_PROTOCOL_VERSION,
+                capabilities = ServerCapabilities(
+                    resources = ServerCapabilities.Resources(null, null),
+                    tools = ServerCapabilities.Tools(null)
+                ),
+                serverInfo = Implementation(name = "test", version = "1.0")
+            )
+        }
+        val serverListToolsResult = ListToolsResult(
+            tools = listOf(
+                Tool(
+                    name = "testTool",
+                    description = "testTool description",
+                    inputSchema = Tool.Input()
+                )
+            ), nextCursor = null
+        )
+
+        server.setRequestHandler<ListToolsRequest>(Method.Defined.ToolsList) { request, _ ->
+            serverListToolsResult
+        }
+
+        val (clientTransport, serverTransport) = InMemoryTransport.createLinkedPair()
+
+        val client = Client(
+            clientInfo = Implementation(name = "test client", version = "1.0"),
+            options = ClientOptions(
+                capabilities = ClientCapabilities(sampling = EmptyJsonObject),
+            )
+        )
+
+        var receivedMessage: JSONRPCMessage? = null
+        clientTransport.onMessage { msg ->
+            receivedMessage = msg
+        }
+
+        listOf(
+            launch {
+                client.connect(clientTransport)
+            },
+            launch {
+                server.connect(serverTransport)
+            }
+        ).joinAll()
+
+        val serverCapabilities = client.serverCapabilities
+        assertEquals(ServerCapabilities.Tools(null), serverCapabilities?.tools)
+
+        val request = JSONRPCRequest(
+            method = Method.Defined.ToolsList.value
+        )
+        clientTransport.send(request)
+
+        assertInstanceOf<JSONRPCResponse>(receivedMessage)
+        val receivedAsResponse = receivedMessage as JSONRPCResponse
+        assertEquals(request.id, receivedAsResponse.id)
+        assertEquals(request.jsonrpc, receivedAsResponse.jsonrpc)
+        assertEquals(serverListToolsResult, receivedAsResponse.result)
+        assertEquals(null, receivedAsResponse.error)
+    }
 
 }