Fix compilation and tests for meta.

small refactoring

Author: devcrocod

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

@@ -51,11 +51,11 @@ import kotlinx.collections.immutable.minus
 import kotlinx.collections.immutable.persistentMapOf
 import kotlinx.collections.immutable.toPersistentSet
 import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.add
 import kotlinx.serialization.json.buildJsonArray
 import kotlinx.serialization.json.buildJsonObject
 import kotlin.coroutines.cancellation.CancellationException
@@ -189,20 +189,14 @@ public open class Client(private val clientInfo: Implementation, options: Client
                 }
             }
 
-            Method.Defined.PromptsGet,
-            Method.Defined.PromptsList,
-            Method.Defined.CompletionComplete,
-            -> {
+            Method.Defined.PromptsGet, Method.Defined.PromptsList, Method.Defined.CompletionComplete -> {
                 if (serverCapabilities?.prompts == null) {
                     throw IllegalStateException("Server does not support prompts (required for $method)")
                 }
             }
 
-            Method.Defined.ResourcesList,
-            Method.Defined.ResourcesTemplatesList,
-            Method.Defined.ResourcesRead,
-            Method.Defined.ResourcesSubscribe,
-            Method.Defined.ResourcesUnsubscribe,
+            Method.Defined.ResourcesList, Method.Defined.ResourcesTemplatesList,
+            Method.Defined.ResourcesRead, Method.Defined.ResourcesSubscribe, Method.Defined.ResourcesUnsubscribe,
             -> {
                 val resCaps = serverCapabilities?.resources
                     ?: error("Server does not support resources (required for $method)")
@@ -214,17 +208,13 @@ public open class Client(private val clientInfo: Implementation, options: Client
                 }
             }
 
-            Method.Defined.ToolsCall,
-            Method.Defined.ToolsList,
-            -> {
+            Method.Defined.ToolsCall, Method.Defined.ToolsList -> {
                 if (serverCapabilities?.tools == null) {
                     throw IllegalStateException("Server does not support tools (required for $method)")
                 }
             }
 
-            Method.Defined.Initialize,
-            Method.Defined.Ping,
-            -> {
+            Method.Defined.Initialize, Method.Defined.Ping -> {
                 // No specific capability required
             }
 
@@ -604,31 +594,37 @@ public open class Client(private val clientInfo: Implementation, options: Client
     private fun validateMetaKeys(keys: Set<String>) {
         val labelPattern = Regex("[a-zA-Z]([a-zA-Z0-9-]*[a-zA-Z0-9])?")
         val namePattern = Regex("[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?")
-        
+
         keys.forEach { key ->
             require(key.isNotEmpty()) { "Meta key cannot be empty" }
-            
+
             val (prefix, name) = key.split('/', limit = 2).let { parts ->
                 when (parts.size) {
                     1 -> null to parts[0]
-                    else -> parts[0] to parts[1]
+                    2 -> parts[0] to parts[1]
+                    else -> throw IllegalArgumentException("Unexpected split result for key: $key")
                 }
             }
-            
+
             // Validate prefix if present
             prefix?.let {
                 require(it.isNotEmpty()) { "Invalid _meta key '$key': prefix cannot be empty" }
-                
+
                 val labels = it.split('.')
                 require(labels.all { label -> label.matches(labelPattern) }) {
                     "Invalid _meta key '$key': prefix labels must start with a letter, end with letter/digit, and contain only letters, digits, or hyphens"
                 }
-                
-                require(labels.none { label -> label.equals("modelcontextprotocol", ignoreCase = true) || label.equals("mcp", ignoreCase = true) }) {
+
+                require(
+                    labels.none { label ->
+                        label.equals("modelcontextprotocol", ignoreCase = true) ||
+                            label.equals("mcp", ignoreCase = true)
+                    },
+                ) {
                     "Invalid _meta key '$key': prefix cannot contain reserved labels 'modelcontextprotocol' or 'mcp'"
                 }
             }
-            
+
             // Validate name (empty allowed)
             require(name.isEmpty() || name.matches(namePattern)) {
                 "Invalid _meta key '$key': name must start and end with alphanumeric characters, and contain only alphanumerics, hyphens, underscores, or dots"
@@ -648,45 +644,53 @@ public open class Client(private val clientInfo: Implementation, options: Client
     @OptIn(ExperimentalUnsignedTypes::class, ExperimentalSerializationApi::class)
     private fun convertToJsonElement(value: Any?): JsonElement = when (value) {
         null -> JsonNull
+
         is JsonElement -> value
+
         is String -> JsonPrimitive(value)
+
         is Number -> JsonPrimitive(value)
+
         is Boolean -> JsonPrimitive(value)
+
         is Char -> JsonPrimitive(value.toString())
+
         is Enum<*> -> JsonPrimitive(value.name)
 
-        is Map<*, *> -> buildJsonObject {
-            value.forEach { (k, v) ->
-                put(k.toString(), convertToJsonElement(v))
-            }
-        }
+        is Map<*, *> -> buildJsonObject { value.forEach { (k, v) -> put(k.toString(), convertToJsonElement(v)) } }
 
-        is Collection<*> -> buildJsonArray {
-            value.forEach { add(convertToJsonElement(it)) }
-        }
+        is Collection<*> -> buildJsonArray { value.forEach { add(convertToJsonElement(it)) } }
 
-        is Array<*> -> buildJsonArray {
-            value.forEach { add(convertToJsonElement(it)) }
-        }
+        is Array<*> -> buildJsonArray { value.forEach { add(convertToJsonElement(it)) } }
 
-        // Primitive arrays - use iterator for unified handling
+        // Primitive arrays
         is IntArray -> buildJsonArray { value.forEach { add(it) } }
+
         is LongArray -> buildJsonArray { value.forEach { add(it) } }
+
         is FloatArray -> buildJsonArray { value.forEach { add(it) } }
+
         is DoubleArray -> buildJsonArray { value.forEach { add(it) } }
+
         is BooleanArray -> buildJsonArray { value.forEach { add(it) } }
+
         is ShortArray -> buildJsonArray { value.forEach { add(it) } }
+
         is ByteArray -> buildJsonArray { value.forEach { add(it) } }
+
         is CharArray -> buildJsonArray { value.forEach { add(it.toString()) } }
 
-        // ExperimentalUnsignedTypes
-        is UIntArray -> buildJsonArray { value.forEach { add(it) } }
-        is ULongArray -> buildJsonArray { value.forEach { add(it) } }
-        is UShortArray -> buildJsonArray { value.forEach { add(it) } }
-        is UByteArray -> buildJsonArray { value.forEach { add(it) } }
+        // Unsigned arrays
+        is UIntArray -> buildJsonArray { value.forEach { add(JsonPrimitive(it)) } }
+
+        is ULongArray -> buildJsonArray { value.forEach { add(JsonPrimitive(it)) } }
+
+        is UShortArray -> buildJsonArray { value.forEach { add(JsonPrimitive(it)) } }
+
+        is UByteArray -> buildJsonArray { value.forEach { add(JsonPrimitive(it)) } }
 
         else -> {
-            logger.debug { "Converting unknown type ${value::class.simpleName} to string: $value" }
+            logger.debug { "Converting unknown type ${value::class} to string: $value" }
             JsonPrimitive(value.toString())
         }
     }

kotlin-sdk-client/src/commonTest/kotlin/io/modelcontextprotocol/kotlin/sdk/client/ClientMetaParameterTest.kt

@@ -83,7 +83,7 @@ class ClientMetaParameterTest {
     fun `should reject mcp reserved prefix`() = runTest {
         val invalidMeta = mapOf("mcp/internal" to "value")
 
-        val exception = assertFailsWith<Error> {
+        val exception = assertFailsWith<IllegalArgumentException> {
             client.callTool("test-tool", emptyMap(), invalidMeta)
         }
 
@@ -97,7 +97,7 @@ class ClientMetaParameterTest {
     fun `should reject modelcontextprotocol reserved prefix`() = runTest {
         val invalidMeta = mapOf("modelcontextprotocol/config" to "value")
 
-        val exception = assertFailsWith<Error> {
+        val exception = assertFailsWith<IllegalArgumentException> {
             client.callTool("test-tool", emptyMap(), invalidMeta)
         }
 
@@ -120,7 +120,7 @@ class ClientMetaParameterTest {
         )
 
         invalidKeys.forEach { key ->
-            val exception = assertFailsWith<Error>(
+            val exception = assertFailsWith<IllegalArgumentException>(
                 message = "Should reject nested reserved key: $key",
             ) {
                 client.callTool("test-tool", emptyMap(), mapOf(key to "value"))
@@ -144,7 +144,7 @@ class ClientMetaParameterTest {
         )
 
         invalidKeys.forEach { key ->
-            val exception = assertFailsWith<Error>(
+            val exception = assertFailsWith<IllegalArgumentException>(
                 message = "Should reject case-insensitive reserved key: $key",
             ) {
                 client.callTool("test-tool", emptyMap(), mapOf(key to "value"))
@@ -169,15 +169,11 @@ class ClientMetaParameterTest {
         )
 
         invalidKeys.forEach { key ->
-            val exception = assertFailsWith<Error>(
+            assertFailsWith<IllegalArgumentException>(
                 message = "Should reject invalid key format: '$key'",
             ) {
                 client.callTool("test-tool", emptyMap(), mapOf(key to "value"))
             }
-            assertContains(
-                charSequence = exception.message ?: "",
-                other = "Invalid _meta key",
-            )
         }
     }
 

kotlin-sdk-test/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/integration/kotlin/AbstractToolIntegrationTest.kt

@@ -484,7 +484,7 @@ abstract class AbstractToolIntegrationTest : KotlinTestBase() {
                   "result" : 11.0,
                   "formattedResult" : "11,000",
                   "precision" : 3,
-                  "tags" : [ ]
+                  "tags" : ["test", "calculator", "integration"]
                 }
         """.trimIndent()