Implemented exploreDirectory function

Author: Robert Winkler

kotlin-wot-integration-tests/src/main/kotlin/integration/AgentConfiguration.kt

@@ -6,26 +6,34 @@ import ai.ancf.lmos.arc.agents.functions.ParameterSchema
 import ai.ancf.lmos.arc.agents.functions.ParameterType
 import ai.ancf.lmos.arc.spring.Agents
 import ai.ancf.lmos.arc.spring.Functions
-import ai.ancf.lmos.wot.JsonMapper
 import ai.ancf.lmos.wot.Wot
 import ai.ancf.lmos.wot.security.BearerSecurityScheme
 import ai.ancf.lmos.wot.security.SecurityScheme
 import ai.ancf.lmos.wot.thing.schema.*
 import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.node.BooleanNode
+import com.fasterxml.jackson.databind.node.DecimalNode
+import com.fasterxml.jackson.databind.node.IntNode
 import com.fasterxml.jackson.databind.node.TextNode
-import com.fasterxml.jackson.module.kotlin.convertValue
 import kotlinx.coroutines.runBlocking
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
+import java.math.BigDecimal
 
 
 @Configuration
 class AgentConfiguration {
 
+    private lateinit var thingDescriptionsMap : Map<String, WoTConsumedThing>
+
+    private val log : Logger = LoggerFactory.getLogger(AgentConfiguration::class.java)
+
     @Bean
     fun chatArcAgent(agent: Agents) = agent {
         name = "ChatAgent"
-        prompt { "You are a helpful smart home agent that can control devices." }
+        prompt { "You are a helpful smart home agent that can control devices. But never print thingIds to the customer" }
         model = { "GPT-4o" }
         tools = AllTools
     }
@@ -49,8 +57,40 @@ class AgentConfiguration {
     @Bean
     fun discoverTools(functions: Functions, wot: Wot) : List<LLMFunction> = runBlocking {
         //discoverTool(wot, functions, "http://localhost:8081/scraper")
+        /*
         discoverTool(wot, functions, "https://plugfest.webthings.io/things/virtual-things-2",
             BearerSecurityScheme())
+        */
+        exploreToolDirectory(wot, functions, "https://plugfest.webthings.io/.well-known/wot",
+            BearerSecurityScheme())
+    }
+
+    private suspend fun exploreToolDirectory(wot: Wot, functions: Functions, url : String,
+                                     securityScheme: SecurityScheme) : List<LLMFunction> {
+        val thingDescriptions = wot.exploreDirectory(url, securityScheme)
+
+        val retrieveAllFunction = functions(
+            "retrieveAllThings",
+            "Retrieves the metadata information of all things/devices available. " +
+                    "Can be used to understand which device types are available and retrieve the " +
+                    "thingIds to control multiple devices. The types tell you the capabilities of a device.",
+            "all_things"
+        ) {
+            summarizeThingDescriptions(thingDescriptions)
+        }
+
+        val consumedThings = thingDescriptions.map { wot.consume(it) }
+        thingDescriptionsMap = consumedThings.associateBy { it.getThingDescription().id }
+
+        return retrieveAllFunction + consumedThings
+            .flatMap { mapThingDescriptionToFunctions(functions, it) }
+    }
+
+    fun summarizeThingDescriptions(things: Set<WoTThingDescription>): String {
+        return things.joinToString(separator = "\n") { thing ->
+            val types = thing.objectType?.types?.joinToString(", ") ?: "N/A"
+            "thingId: ${thing.id}, Title: ${thing.title ?: "N/A"}, Types: $types"
+        }
     }
 
     private suspend fun discoverTool(wot: Wot, functions: Functions, url : String,
@@ -60,28 +100,43 @@ class AgentConfiguration {
 
         val thing = wot.consume(thingDescription)
 
-        return mapThingDescriptionToFunctions(thingDescription, functions, thing)
+        return mapThingDescriptionToFunctions(functions, thing)
     }
 
     private suspend fun mapThingDescriptionToFunctions(
-        thingDescription: WoTThingDescription,
         functions: Functions,
         thing: WoTConsumedThing
     ): List<LLMFunction> {
+        val thingDescription = thing.getThingDescription()
+
+        val defaultParams = listOf(Pair(ParameterSchema(
+            name = "thingId",
+            description = "The unique identifier of the thing",
+            type = ParameterType("string"),
+            enum = emptyList()
+        ), true))
+
         val actionFunctions = thingDescription.actions.flatMap { (actionName, action) ->
 
-            val params = action.input?.let { input ->
+            val actionParams = action.input?.let { input ->
                 listOf(Pair(mapDataSchemaToParam(input), true))
-            }
+            } ?: emptyList()
+
+            val params = defaultParams + actionParams
 
             functions(
                 actionName,
                 action.description ?: "No Description available",
                 thingDescription.title,
-                params ?: emptyList(),
+                params,
             ) {
-                (url) ->
-                thing.invokeAction(actionName, TextNode(url)).asText()
+                (thingId, input) ->
+                try {
+                    thingDescriptionsMap[thingId]?.invokeAction(actionName, TextNode(input))?.asText()?: "Function call failed"
+                }catch (e: Exception) {
+                    log.error("Error invoking action $actionName", e)
+                    "Function call failed"
+                }
             }
         }
         val propertiesFunctions = functions(
@@ -101,38 +156,68 @@ class AgentConfiguration {
                     property.description ?: "Can be used to read the $propertyName property",
                     thingDescription.title
                 ) {
-                    thing.readProperty(propertyName).value().asText()
+                    (thingId) ->
+                    try {
+                        thingDescriptionsMap[thingId]?.readProperty(propertyName)?.value()?.asText() ?: "Function call failed"
+                    } catch (e: Exception) {
+                        log.error("Error reading property $propertyName", e)
+                        "Function call failed"
+                    }
                 }
             } else if (property.writeOnly) {
+                val params = defaultParams + listOf(Pair(mapDataSchemaToParam(property), true))
+
                 functions(
                     "set$propertyName",
                     property.description ?: "Can be used to set the $propertyName property",
                     thingDescription.title,
-                    listOf(Pair(mapDataSchemaToParam(property), true))
+                    params
                 ) {
-                    (propertyValue) ->
-                    thing.writeProperty(propertyName, TextNode(propertyValue))
-                    "Property $propertyName set to $propertyValue"
+                    (thingId, propertyValue) ->
+                    if(propertyValue != null){
+                        try {
+                            val propertyAffordance = thing.getThingDescription().properties[propertyName]!!
+                            thingDescriptionsMap[thingId]?.writeProperty(propertyName, mapSchemaToJsonNode(propertyAffordance, propertyValue))  ?: "Function failed"
+                            "Property $propertyName set to $propertyValue"
+                        } catch (e: Exception) {
+                            log.error("Error writing property $propertyName", e)
+                            "Function call failed"
+                        }
+                    }else{
+                        "Function call failed"
+                    }
                 }
             } else {
                 functions(
                     "read$propertyName",
                     property.description ?: "Can be used to read the $propertyName property",
                     thingDescription.title
                 ) {
-                    thing.readProperty(propertyName).value().asText()
+                    (thingId) ->
+                    try {
+                        thingDescriptionsMap[thingId]?.readProperty(propertyName)?.value()?.asText() ?: "Function failed"
+                    } catch (e: Exception) {
+                        log.error("Error reading property $propertyName", e)
+                        "Function call failed"
+                    }
                 }
+                val params = defaultParams + listOf(Pair(mapDataSchemaToParam(property), true))
                 functions(
                     "set$propertyName",
                     property.description ?: "Can be used to set the $propertyName property",
                     thingDescription.title,
-                    listOf(Pair(mapDataSchemaToParam(property), true))
+                    params
                 ) {
-                        (propertyValue) ->
+                    (thingId, propertyValue) ->
                     if(propertyValue != null){
-                        val input : JsonNode = JsonMapper.instance.convertValue(propertyValue)
-                        thing.writeProperty(propertyName, input)
-                        "Property $propertyName set to $propertyValue"
+                        try {
+                            val propertyAffordance = thing.getThingDescription().properties[propertyName]!!
+                            thingDescriptionsMap[thingId]?.writeProperty(propertyName, mapSchemaToJsonNode(propertyAffordance, propertyValue))  ?: "Function failed"
+                            "Property $propertyName set to $propertyValue"
+                        } catch (e: Exception) {
+                            log.error("Error writing property $propertyName", e)
+                            "Function call failed"
+                        }
                     }else{
                         "Function call failed"
                     }
@@ -142,7 +227,24 @@ class AgentConfiguration {
         return actionFunctions + propertyFunctions + propertiesFunctions
     }
 
-
+    fun mapSchemaToJsonNode(schema: DataSchema<*>, value: String): JsonNode {
+        return when (schema) {
+            is StringSchema -> TextNode(value)
+            is IntegerSchema -> {
+                val intValue = value.toIntOrNull() ?: 0
+                IntNode(intValue)
+            }
+            is NumberSchema -> {
+                val numberValue = value.toBigDecimalOrNull() ?: BigDecimal.ZERO
+                DecimalNode(numberValue)
+            }
+            is BooleanSchema -> {
+                val boolValue = value?.toBooleanStrictOrNull() ?: false
+                BooleanNode.valueOf(boolValue)
+            }
+            else -> throw IllegalArgumentException("Unsupported schema type: ${schema::class.simpleName}")
+        }
+    }
 
     /*
 

kotlin-wot-integration-tests/src/test/kotlin/integration/QuickTest.kt

@@ -9,7 +9,7 @@ class QuickTest {
     fun `should control my lamp`() = runBlocking {
         val agent = ConversationalAgent.create("http://localhost:8080/chatagent")
         //val command = "What is the state of my lamp?"
-        val command = "Turn on the lamp"
+        val command = "Set all my color lights to green"
         println("User: $command")
         val answer = agent.chat(command)
         println("Agent: $answer")

kotlin-wot/src/main/kotlin/DefaultWot.kt

@@ -24,15 +24,19 @@ class DefaultWot(private val servient: Servient) : Wot {
                 '}'
     }
     @Throws(WotException::class)
-    override suspend fun discover(filter: ThingFilter): Flow<WoTExposedThing> {
+    override fun discover(filter: ThingFilter): Flow<WoTThingDescription> {
         return servient.discover(filter)
     }
 
     @Throws(WotException::class)
-    override suspend fun discover(): Flow<WoTExposedThing> {
+    override fun discover(): Flow<WoTThingDescription> {
         return discover(ThingFilter(method = DiscoveryMethod.ANY))
     }
 
+    override suspend fun exploreDirectory(directoryUrl: String, securityScheme: SecurityScheme): Set<WoTThingDescription> {
+        return servient.exploreDirectory(directoryUrl, securityScheme)
+    }
+
     override fun produce(thingDescription: WoTThingDescription): WoTExposedThing {
         val exposedThing = ExposedThing(servient, thingDescription)
         return if (servient.addThing(exposedThing)) {

kotlin-wot/src/main/kotlin/Servient.kt

@@ -10,7 +10,9 @@ import ai.ancf.lmos.wot.thing.filter.DiscoveryMethod.*
 import ai.ancf.lmos.wot.thing.filter.ThingFilter
 import ai.ancf.lmos.wot.thing.form.Form
 import ai.ancf.lmos.wot.thing.schema.WoTExposedThing
+import ai.ancf.lmos.wot.thing.schema.WoTThingDescription
 import ai.anfc.lmos.wot.binding.*
+import com.fasterxml.jackson.module.kotlin.treeToValue
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
@@ -314,7 +316,7 @@ class Servient(
      * @return
      */
 
-    suspend fun discover(): Flow<WoTExposedThing> {
+    fun discover(): Flow<WoTThingDescription> {
         return discover(ThingFilter(method = ANY))
     }
 
@@ -331,7 +333,7 @@ class Servient(
      * @return
      */
 
-    suspend fun discover(filter: ThingFilter): Flow<WoTExposedThing> {
+    fun discover(filter: ThingFilter): Flow<WoTThingDescription> {
         return when (filter.method) {
             DIRECTORY -> discoverDirectory(filter)
             LOCAL -> discoverLocal(filter)
@@ -341,7 +343,7 @@ class Servient(
 
     // Discover any available Things across all protocols
     @Throws(ServientException::class)
-    private suspend fun discoverAny(filter: ThingFilter): Flow<WoTExposedThing> = flow {
+    private fun discoverAny(filter: ThingFilter): Flow<WoTThingDescription> = flow {
         var foundAtLeastOne = false
         // Try to run a discovery with every available protocol binding
         for (factory in clientFactories.values) {
@@ -364,7 +366,7 @@ class Servient(
         emitAll(discoverLocal(filter))
     }
 
-    private suspend fun discoverDirectory(
+    private fun discoverDirectory(
         filter: ThingFilter
     ): Flow<ExposedThing> = flow {
         //val discoveredThings = filter.url?.let { fetchDirectory(it) } TODO
@@ -376,7 +378,7 @@ class Servient(
         filteredThings?.forEach { emit(it) } // Emit each thing one by one
     }
 
-    private fun discoverLocal(filter: ThingFilter): Flow<WoTExposedThing> = flow {
+    private fun discoverLocal(filter: ThingFilter): Flow<WoTThingDescription> = flow {
         val myThings = things.values.toList()
 
         // Apply the filter query if available
@@ -386,6 +388,16 @@ class Servient(
 
     fun hasClientFor(scheme: String): Boolean = clientFactories.containsKey(scheme)
 
+    suspend fun exploreDirectory(directoryUrl: String, securityScheme: SecurityScheme): Set<WoTThingDescription> {
+        val directoryThingDescription = fetch(directoryUrl, securityScheme)
+        val consumedDirectory = ConsumedThing(this@Servient, directoryThingDescription)
+        val thingsPropertyOutput = consumedDirectory.readProperty("things")
+        val thingsAsJsonNode = thingsPropertyOutput.value()
+
+        val thingDescriptions : Set<ThingDescription> = JsonMapper.instance.treeToValue<Set<ThingDescription>>(thingsAsJsonNode)
+        return thingDescriptions
+    }
+
     companion object {
         private val log = LoggerFactory.getLogger(Servient::class.java)
         val addresses: Set<String>

kotlin-wot/src/main/kotlin/Wot.kt

@@ -24,15 +24,23 @@ interface Wot {
      * @param filter
      * @return
      */
-    suspend fun discover(filter: ThingFilter): Flow<WoTExposedThing>
+    fun discover(filter: ThingFilter): Flow<WoTThingDescription>
 
     /**
      * Starts the discovery process that will provide all available Things.
      *
      * @return
      */
+    fun discover(): Flow<WoTThingDescription>
 
-    suspend fun discover(): Flow<WoTExposedThing>
+    /**
+     * Starts the discovery process that will provide Things that match the `filter`
+     * argument from a given Thing Directory.
+     *
+     * @param filter
+     * @return
+     */
+    suspend fun exploreDirectory(directoryUrl: String, securityScheme: SecurityScheme = NoSecurityScheme()): Set<WoTThingDescription>
 
     /**
      * Accepts a `thing` argument of type [ThingDescription] and returns an [ ] object.<br></br> The result can be used to start exposing interfaces for thing

kotlin-wot/src/main/kotlin/content/ContentManager.kt

@@ -147,7 +147,7 @@ object ContentManager {
      * @param contentType
      * @return
      */
-    internal fun getMediaType(contentType: String?): String {
+     fun getMediaType(contentType: String?): String {
         if (contentType == null) {
             return DEFAULT_MEDIA_TYPE
         }

kotlin-wot/src/main/kotlin/thing/ConsumedThing.kt

@@ -78,7 +78,7 @@ data class ConsumedThing(
 
         // Check if returned media type matches the expected media type from TD
         form.response?.let { response ->
-            if (content.type != response.contentType) {
+            if (ContentManager.getMediaType(content.type) != ContentManager.getMediaType(response.contentType)) {
                 throw IllegalArgumentException(
                     "Unexpected type '${content.type}' in response. Expected '${response.contentType}'"
                 )