Add parsing of the values passed in resource templates

Author: KuechA

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

@@ -11,6 +11,17 @@ import io.modelcontextprotocol.kotlin.sdk.types.Resource
 import io.modelcontextprotocol.kotlin.sdk.types.ResourceTemplate
 import io.modelcontextprotocol.kotlin.sdk.types.Tool
 
+public interface UriTemplateArgumentExtractor {
+    /**
+     * Extracts the arguments from the given [input] string based on the URI template defined in this extractor.
+     *
+     * @param input The input string to extract arguments from.
+     * @return A map of argument names to their corresponding values extracted from the input string.
+     *         If the input does not match the URI template, an empty map is returned.
+     */
+    public fun extractArguments(input: String): Map<String, String>
+}
+
 /**
  * Represents a unique key for a feature and allows comparing inputs with the [key].
  */
@@ -51,8 +62,11 @@ public class StringFeatureKey(override val key: String) : FeatureKey<String>() {
  *
  * @property key The URI template string key identifying the feature.
  */
-public class UriTemplateFeatureKey(override val key: String) : FeatureKey<Regex>() {
+public class UriTemplateFeatureKey(override val key: String) :
+    FeatureKey<Regex>(),
+    UriTemplateArgumentExtractor {
     override val value: Regex
+    public val groups: MutableList<String> = mutableListOf<String>()
     init {
         // Convert URI template to regex as follows:
         // - A simple variable `{variable}` is replaced with `(?<variable>[^/]+)`
@@ -62,9 +76,10 @@ public class UriTemplateFeatureKey(override val key: String) : FeatureKey<Regex>
 
         val newRegex = Regex("\\{(<groupName>[^}*]*)(<wildcard>[*]?)}")
             .replace(uriWithoutQueryParameters) { matchResult ->
-                val groupName = matchResult.groups["groupName"]
+                val groupName = matchResult.groups["groupName"]?.value
                 checkNotNull(groupName) { "Invalid URI template: $this" }
-                if (matchResult.groups["wildcard"] != null) {
+                groups.add(groupName)
+                if (matchResult.groups["wildcard"]?.value != null) {
                     "(?<$groupName>.+)"
                 } else {
                     "(?<$groupName>[^/]*)"
@@ -74,8 +89,25 @@ public class UriTemplateFeatureKey(override val key: String) : FeatureKey<Regex>
     }
 
     override fun matches(input: String): Boolean = value.matches(input)
+
+    override fun extractArguments(input: String): TemplateValues {
+        val matchGroups = value.matchEntire(input)?.groups
+        return groups.mapNotNull { groupName ->
+            val groupValue = matchGroups?.get(groupName)?.value
+            if (groupValue != null) {
+                groupName to groupValue
+            } else {
+                null
+            }
+        }.toMap()
+    }
 }
 
+/**
+ * A map of template variable names to their corresponding values extracted from an input string based on a URI template.
+ */
+public typealias TemplateValues = Map<String, String>
+
 /**
  * The [FeatureKey] used for [Tool]s.
  */
@@ -148,7 +180,7 @@ public data class RegisteredResource(
  */
 public data class RegisteredResourceTemplate(
     val resourceTemplate: ResourceTemplate,
-    val readHandler: suspend (ReadResourceRequest) -> ReadResourceResult,
+    val readHandler: suspend (ReadResourceRequest, TemplateValues) -> ReadResourceResult,
 ) : Feature<ResourceTemplateFeatureKey> {
     override val key: ResourceTemplateFeatureKey = UriTemplateFeatureKey(resourceTemplate.uriTemplate)
 }

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

@@ -143,9 +143,9 @@ internal class FeatureRegistry<T : Feature<S>, S : FeatureKey<R>, R>(private val
      * @param key The key of the feature to retrieve.
      * @return The feature associated with the given key, or `null` if no such feature exists in the registry.
      */
-    internal fun get(key: String): T? {
+    internal fun get(key: String): Map.Entry<S, T>? {
         logger.info { "Getting $featureType: \"$key\"" }
-        val feature = registry.value.entries.singleOrNull { it.key.matches(key) }?.value
+        val feature = registry.value.entries.singleOrNull { it.key.matches(key) }
         if (feature != null) {
             logger.info { "Got $featureType: \"$key\"" }
         } else {

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

@@ -569,7 +569,7 @@ public open class Server(
         name: String,
         description: String,
         mimeType: String = "text/html",
-        readHandler: suspend (ReadResourceRequest) -> ReadResourceResult,
+        readHandler: suspend (ReadResourceRequest, TemplateValues) -> ReadResourceResult,
     ) {
         check(options.capabilities.resources != null) {
             logger.error { "Failed to add resource template '$name': Server does not support resources capability" }
@@ -653,7 +653,7 @@ public open class Server(
         logger.debug { "Handling tool call request for tool: ${requestParams.name}" }
 
         // Check if the tool exists
-        val tool = toolRegistry.get(requestParams.name) ?: run {
+        val tool = toolRegistry.get(requestParams.name)?.value ?: run {
             logger.error { "Tool not found: ${requestParams.name}" }
             return CallToolResult(
                 content = listOf(TextContent(text = "Tool ${requestParams.name} not found")),
@@ -684,7 +684,7 @@ public open class Server(
     private suspend fun handleGetPrompt(request: GetPromptRequest): GetPromptResult {
         val requestParams = request.params
         logger.debug { "Handling get prompt request for: ${requestParams.name}" }
-        val prompt = promptRegistry.get(requestParams.name)
+        val prompt = promptRegistry.get(requestParams.name)?.value
             ?: run {
                 logger.error { "Prompt not found: ${requestParams.name}" }
                 throw IllegalArgumentException("Prompt not found: ${requestParams.name}")
@@ -700,15 +700,15 @@ public open class Server(
     private suspend fun handleReadResource(request: ReadResourceRequest): ReadResourceResult {
         val requestParams = request.params
         logger.debug { "Handling read resource request for: ${requestParams.uri}" }
-        val resource = resourceRegistry.get(requestParams.uri)
+        val resource = resourceRegistry.get(requestParams.uri)?.value
             ?: run {
                 logger.debug { "Resource not found: ${requestParams.uri}" }
-                val resourceTemplate = resourceTemplateRegistry.get(requestParams.uri)
+                val (templateParser, resourceTemplate) = resourceTemplateRegistry.get(requestParams.uri)
                     ?: run {
                         logger.error { "Resource or resource template not found: ${requestParams.uri}" }
                         throw IllegalArgumentException("Resource or resource template not found: ${requestParams.uri}")
                     }
-                return resourceTemplate.readHandler(request)
+                return resourceTemplate.readHandler(request, templateParser.extractArguments(requestParams.uri))
             }
         return resource.readHandler(request)
     }