bump multiple dependencies to latest stable versions, including Kotlin, Vaadin, and Ktor, and update related configurations across projects

Author: devcrocod

projects/mcp/brave/build.gradle.kts

@@ -9,6 +9,7 @@ repositories {
 
 dependencies {
     implementation(libs.mcp.kotlin)
+    implementation(libs.ktor.server.cio)
     implementation(libs.slf4j)
 }
 

projects/mcp/brave/gradle/libs.versions.toml

@@ -4,10 +4,12 @@
 [versions]
 kotlin = "2.2.21"
 mcp = "0.8.0"
+ktor = "3.3.3"
 slf4j = "2.0.9"
 
 [libraries]
 mcp-kotlin = { group = "io.modelcontextprotocol", name = "kotlin-sdk", version.ref = "mcp" }
+ktor-server-cio = { group = "io.ktor", name = "ktor-server-cio", version.ref = "ktor" }
 slf4j = { group = "org.slf4j", name = "slf4j-nop", version.ref = "slf4j"}
 
 [plugins]

projects/mcp/brave/src/main/kotlin/io/github/devcrocod/example/main.kt

@@ -1,15 +1,14 @@
 package io.github.devcrocod.example
 
-import io.ktor.server.application.Application
-import io.ktor.server.cio.CIO
-import io.ktor.server.engine.embeddedServer
-import io.ktor.server.request.receiveText
-import io.ktor.server.response.respondText
-import io.ktor.server.routing.post
-import io.ktor.server.routing.routing
-import io.modelcontextprotocol.kotlin.sdk.Implementation
+import io.ktor.server.application.*
+import io.ktor.server.cio.*
+import io.ktor.server.engine.*
+import io.ktor.server.request.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
 import io.modelcontextprotocol.kotlin.sdk.client.Client
 import io.modelcontextprotocol.kotlin.sdk.client.StdioClientTransport
+import io.modelcontextprotocol.kotlin.sdk.types.Implementation
 import kotlinx.coroutines.runBlocking
 import kotlinx.io.asSink
 import kotlinx.io.asSource
@@ -58,7 +57,7 @@ fun Application.module() {
             logger.info("The following question has been received: $question")
 
             // Request a list of available tools from the server.
-            val tools = runBlocking { client.listTools()?.tools } ?: emptyList()
+            val tools = client.listTools().tools
             if (tools.isEmpty()) {
                 call.respondText("Tools not found")
                 return@post
@@ -68,8 +67,8 @@ fun Application.module() {
             val toolName = tools.first().name
 
             // Call the tool, passing the "query" field with the question text as an argument
-            val toolResult = runBlocking { client.callTool(toolName, mapOf("query" to question)) }
-            val resultContent = toolResult?.content?.toString() ?: "No result"
+            val toolResult = client.callTool(toolName, mapOf("query" to question))
+            val resultContent = toolResult.content.toString()
 
             // Returning the result to the client
             call.respondText(resultContent)

projects/mcp/mcp-demo/composeApp/src/desktopMain/kotlin/io/github/devcrocod/MCPClient.kt

@@ -4,20 +4,15 @@ import com.openai.client.OpenAIClient
 import com.openai.client.okhttp.OpenAIOkHttpClient
 import com.openai.core.JsonValue
 import com.openai.models.*
-import com.openai.models.chat.completions.ChatCompletionAssistantMessageParam
-import com.openai.models.chat.completions.ChatCompletionCreateParams
-import com.openai.models.chat.completions.ChatCompletionMessageParam
-import com.openai.models.chat.completions.ChatCompletionSystemMessageParam
-import com.openai.models.chat.completions.ChatCompletionTool
-import com.openai.models.chat.completions.ChatCompletionUserMessageParam
+import com.openai.models.chat.completions.*
 import io.ktor.client.*
 import io.ktor.client.plugins.contentnegotiation.*
 import io.ktor.client.plugins.sse.*
 import io.ktor.serialization.kotlinx.json.*
-import io.modelcontextprotocol.kotlin.sdk.Implementation
-import io.modelcontextprotocol.kotlin.sdk.Tool
 import io.modelcontextprotocol.kotlin.sdk.client.Client
 import io.modelcontextprotocol.kotlin.sdk.client.mcpSse
+import io.modelcontextprotocol.kotlin.sdk.types.Implementation
+import io.modelcontextprotocol.kotlin.sdk.types.Tool
 import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.json.Json
 import kotlin.jvm.optionals.getOrNull
@@ -31,7 +26,7 @@ import kotlin.jvm.optionals.getOrNull
  */
 private fun List<Tool>.toListChatCompletionTools(): List<ChatCompletionTool> {
     return this.map { tool ->
-        ChatCompletionTool.builder()
+        val functionTool = ChatCompletionFunctionTool.builder()
             .function(
                 FunctionDefinition.builder()
                     .name(tool.name)
@@ -46,6 +41,7 @@ private fun List<Tool>.toListChatCompletionTools(): List<ChatCompletionTool> {
                     .build()
             )
             .build()
+        ChatCompletionTool.ofFunction(functionTool)
     }
 }
 
@@ -86,9 +82,9 @@ class MCPClient : AutoCloseable {
         println("Connected to the MCP server: ${mcpClient.serverVersion}")
 
         // Getting a list of available tools
-        val tools = mcpClient.listTools()?.tools
-        availableTools = tools?.toListChatCompletionTools() ?: emptyList()
-        println("Available tools: ${tools?.map { it.name } ?: "No tools found"}")
+        val tools = mcpClient.listTools().tools
+        availableTools = tools.toListChatCompletionTools()
+        println("Available tools: ${tools.map { it.name }}")
     }
 
     /**
@@ -136,8 +132,9 @@ class MCPClient : AutoCloseable {
             }
             // Process any tool calls returned by the assistant
             for (toolCall in choice.message().toolCalls().getOrNull() ?: emptyList()) {
-                val toolName = toolCall.function().name()
-                val args = Json {}.decodeFromString<Map<String, String>>(toolCall.function().arguments())
+                val functionToolCall = toolCall.asFunction()
+                val toolName = functionToolCall.function().name()
+                val args = Json {}.decodeFromString<Map<String, String>>(functionToolCall.function().arguments())
 
                 // Call the MCP tool with parsed arguments
                 val result = mcpClient.callTool(toolName, args)
@@ -160,8 +157,8 @@ class MCPClient : AutoCloseable {
                             .content(
                                 """
                                     "type": "tool_result",
-                                    "tool_use_id": ${toolCall.id()},
-                                    "result": ${result?.content?.joinToString()}
+                                    "tool_use_id": ${functionToolCall.id()},
+                                    "result": ${result.content.joinToString()}
                                 """.trimIndent()
                             )
                             .build()

projects/mcp/mcp-demo/gradle/libs.versions.toml

@@ -19,6 +19,7 @@ androidx-lifecycle-runtime-compose = { group = "org.jetbrains.androidx.lifecycle
 kotlinx-coroutines-swing = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-swing", version.ref = "kotlinx-coroutines" }
 mcp-kotlin = { group = "io.modelcontextprotocol", name = "kotlin-sdk", version.ref = "mcp" }
 slf4j = { group = "org.slf4j", name = "slf4j-nop", version.ref = "slf4j" }
+ktor-server-cio = { group = "io.ktor", name = "ktor-server-cio", version.ref = "ktor" }
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
 ktor-serialization = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }

projects/mcp/mcp-demo/server/build.gradle.kts

@@ -17,6 +17,7 @@ dependencies {
     implementation(libs.ktor.client.content.negotation)
     implementation(libs.ktor.serialization)
     implementation(libs.ktor.client.logging)
+    implementation(libs.ktor.server.cio)
 }
 
 java {

projects/mcp/mcp-demo/server/src/main/kotlin/io/github/devcrocod/example/server.kt

@@ -9,15 +9,13 @@ import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.application.*
 import io.ktor.server.cio.*
 import io.ktor.server.engine.*
+import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import io.ktor.server.sse.*
 import io.ktor.util.collections.*
 import io.ktor.utils.io.streams.*
-import io.modelcontextprotocol.kotlin.sdk.*
-import io.modelcontextprotocol.kotlin.sdk.server.Server
-import io.modelcontextprotocol.kotlin.sdk.server.ServerOptions
-import io.modelcontextprotocol.kotlin.sdk.server.SseServerTransport
-import io.modelcontextprotocol.kotlin.sdk.server.StdioServerTransport
+import io.modelcontextprotocol.kotlin.sdk.server.*
+import io.modelcontextprotocol.kotlin.sdk.types.*
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.runBlocking
 import kotlinx.io.asSink
@@ -75,17 +73,14 @@ fun configureServer(): Server {
             For example, an investor may want to use the full-quote quote endpoint to get a sense of what a stock is trading at before placing a trade.
             Or, an investor may want to use the full-quote quote endpoint to track the performance of a stock over time.
         """.trimIndent(),
-        inputSchema = Tool.Input(
+        inputSchema = ToolSchema(
             properties = JsonObject(mapOf("symbol" to JsonPrimitive("string"))),
             required = listOf("symbol")
         )
     ) { request ->
-        val symbol = request.arguments["symbol"]
-        if (symbol == null) {
-            return@addTool CallToolResult(
-                content = listOf(TextContent("The 'symbol' parameter is required."))
-            )
-        }
+        val symbol = request.arguments?.get("symbol") ?: return@addTool CallToolResult(
+            content = listOf(TextContent("The 'symbol' parameter is required."))
+        )
         val price = httpClient.getCurrentPrice(symbol.jsonPrimitive.content)
         if (price != null) {
             CallToolResult(
@@ -119,7 +114,7 @@ fun configureServer(): Server {
             For example, an investor might look for stocks that are in an uptrend or a downtrend.
             Investors can also use the FMP Daily Chart endpoint to identify support and resistance levels.
         """.trimIndent(),
-        inputSchema = Tool.Input(
+        inputSchema = ToolSchema(
             properties = JsonObject(
                 mapOf(
                     "symbol" to JsonPrimitive("string"),
@@ -130,9 +125,9 @@ fun configureServer(): Server {
             required = listOf("symbol")
         )
     ) { request ->
-        val symbol = request.arguments["symbol"]
-        val from = request.arguments["from"]?.jsonPrimitive?.contentOrNull
-        val to = request.arguments["to"]?.jsonPrimitive?.contentOrNull
+        val symbol = request.arguments?.get("symbol")
+        val from = request.arguments?.get("from")?.jsonPrimitive?.contentOrNull
+        val to = request.arguments?.get("to")?.jsonPrimitive?.contentOrNull
         if (symbol == null) {
             return@addTool CallToolResult(
                 content = listOf(TextContent("The 'symbol' parameter is required."))
@@ -177,7 +172,7 @@ fun `run mcp server using stdio`() {
     )
 
     runBlocking {
-        server.connect(transport)
+        server.createSession(transport)
         val done = Job()
         server.onClose {
             done.complete()
@@ -194,28 +189,32 @@ fun `run mcp server using stdio`() {
  * @param port The port number on which the SSE server should be started.
  */
 fun `run sse mcp server`(port: Int): Unit = runBlocking {
-    val servers = ConcurrentMap<String, Server>()
+    val serverSessions = ConcurrentMap<String, ServerSession>()
 
     val server = configureServer()
-    embeddedServer(CIO, host = "0.0.0.0", port = port) {
+
+    embeddedServer(CIO, host = "127.0.0.1", port = port) {
         install(SSE)
         routing {
             sse("/sse") {
                 val transport = SseServerTransport("/message", this)
-
-                servers[transport.sessionId] = server
+                val serverSession = server.createSession(transport)
+                serverSessions[transport.sessionId] = serverSession
 
                 server.onClose {
-                    servers.remove(transport.sessionId)
+                    serverSessions.remove(transport.sessionId)
                 }
-
-                server.connect(transport)
             }
             post("/message") {
-                val sessionId: String = call.request.queryParameters["sessionId"]!!
-                val transport = servers[sessionId]?.transport as? SseServerTransport
+                val sessionId = call.request.queryParameters["sessionId"]
+                if (sessionId == null) {
+                    call.respond(HttpStatusCode.BadRequest, "Missing sessionId parameter")
+                    return@post
+                }
+
+                val transport = serverSessions[sessionId]?.transport as? SseServerTransport
                 if (transport == null) {
-                    call.respond("Session not found", null)
+                    call.respond(HttpStatusCode.NotFound, "Session not found")
                     return@post
                 }