Added a Spring Boot Application example

Author: Robert Winkler

build.gradle.kts

@@ -2,7 +2,6 @@ plugins {
     kotlin("jvm") version "2.0.20"
     id("org.jlleitschuh.gradle.ktlint") version "12.1.0"
     id("org.jetbrains.kotlinx.kover") version "0.8.3"
-    id("org.cadixdev.licenser") version "0.6.1"
 }
 
 
@@ -11,18 +10,10 @@ subprojects {
     apply(plugin = "org.jetbrains.kotlin.jvm")
     apply(plugin = "org.jlleitschuh.gradle.ktlint")
     apply(plugin = "org.jetbrains.kotlinx.kover")
-    apply(plugin = "org.cadixdev.licenser")
 
     group = "ai.ancf.lmos"
     version = "1.0-SNAPSHOT"
 
-    license {
-        include("**/*.java")
-        include("**/*.kt")
-        include("**/*.yaml")
-        exclude("**/*.properties")
-    }
-
     dependencies {
         testImplementation(kotlin("test"))
         testImplementation ("org.jetbrains.kotlinx:kotlinx-coroutines-test")

kotlin-wot-integration-tests/build.gradle.kts

@@ -1,14 +1,24 @@
+plugins {
+    kotlin("plugin.spring") version "1.9.10"
+    id("org.springframework.boot") version "3.1.5" // Use the latest compatible version
+    id("io.spring.dependency-management") version "1.1.3"
+}
+
 dependencies {
     api(project(":kotlin-wot"))
     api(project(":kotlin-wot-binding-http"))
     api(project(":kotlin-wot-binding-mqtt"))
     api(project(":kotlin-wot-reflection"))
-    api("ch.qos.logback:logback-classic:1.5.12")
-    implementation("ai.ancf.lmos:arc-agents:0.98.0")
-    implementation("ai.ancf.lmos:arc-langchain4j-client:0.98.0")
+    implementation("ai.ancf.lmos:arc-agents:0.111.0")
+    //implementation("ai.ancf.lmos:arc-langchain4j-client:0.111.0")
+    implementation("org.springframework.boot:spring-boot-starter")
+    implementation("org.springframework.boot:spring-boot-starter-logging")
+
+    implementation("ai.ancf.lmos:arc-azure-client:0.111.0")
+    implementation("ai.ancf.lmos:arc-spring-boot-starter:0.111.0")
 
-    implementation("dev.langchain4j:langchain4j-azure-open-ai:0.35.0")
-    implementation("dev.langchain4j:langchain4j:0.35.0")
+    //implementation("dev.langchain4j:langchain4j-azure-open-ai:0.35.0")
+    //implementation("dev.langchain4j:langchain4j:0.35.0")
     testImplementation("com.hivemq:hivemq-mqtt-client:1.3.3")
     implementation("org.testcontainers:testcontainers:1.20.3")
 }

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

@@ -0,0 +1,26 @@
+package ai.ancf.lmos.wot.integration
+
+import ai.ancf.lmos.arc.spring.Agents
+import ai.ancf.lmos.wot.Wot
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+
+@Configuration
+class AgentConfiguration {
+
+    @Bean
+    fun myAgent(agent: Agents) = agent {
+        name = "My Agent"
+        prompt { "you are a helpful weather agent." }
+        model = { "GPT-4o" }
+    }
+
+    @Bean
+    fun servient() = createServient("HTTP")
+
+    @Bean
+    fun wot() = Wot.create(servient())
+
+
+}

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

@@ -2,13 +2,12 @@ package ai.ancf.lmos.wot.integration
 
 import ai.ancf.lmos.wot.Wot
 import ai.ancf.lmos.wot.reflection.ExposedThingBuilder
-import ai.ancf.lmos.wot.reflection.annotations.ThingAgent
 import ai.ancf.lmos.wot.thing.schema.WoTExposedThing
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 
-
+/*
 fun main(): Unit = runBlocking {
 
     val agent = ThingAgent()
@@ -34,4 +33,4 @@ fun main(): Unit = runBlocking {
     println("Exposed Agent on HTTP Server")
     // Keep the application running until process is stopped
     Job().join()
-}
+}*/

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

@@ -1,13 +1,6 @@
 package ai.ancf.lmos.wot.integration
 
-import ai.ancf.lmos.wot.Wot
-import ai.ancf.lmos.wot.reflection.ExposedThingBuilder
-import ai.ancf.lmos.wot.reflection.annotations.ThingAgent
-import ai.ancf.lmos.wot.thing.schema.WoTExposedThing
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-
+/*
 
 fun main(): Unit = runBlocking {
     val agent = ThingAgent()
@@ -32,4 +25,5 @@ fun main(): Unit = runBlocking {
     println("Exposed Thing:${exposedThing.toJson()}")
     // Keep the application running until process is stopped
     Job().join()
-}
+}
+ */

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

@@ -0,0 +1,68 @@
+package ai.ancf.lmos.wot.integration
+
+import ai.ancf.lmos.wot.Servient
+import ai.ancf.lmos.wot.Wot
+import ai.ancf.lmos.wot.reflection.ExposedThingBuilder
+import ai.ancf.lmos.wot.thing.schema.WoTExposedThing
+import jakarta.annotation.PreDestroy
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.runBlocking
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.CommandLineRunner
+import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.runApplication
+
+
+fun main(args: Array<String>) {
+    runApplication<ThingAgentApplication>(*args)
+}
+
+@SpringBootApplication
+class ThingAgentApplication : CommandLineRunner {
+
+    @Autowired
+    private lateinit var servient: Servient
+
+    @Autowired
+    private lateinit var wot: Wot
+
+    @Autowired
+    private lateinit var agent: ThingAgent
+
+    companion object {
+        private val log: Logger = LoggerFactory.getLogger(ThingAgentApplication::class.java)
+    }
+
+    @PreDestroy
+    fun onExit() {
+        log.info("###STOPing###")
+        log.info("###STOP FROM THE LIFECYCLE###")
+    }
+
+    override fun run(vararg args: String?) = runBlocking {
+
+        // Protocol can be "HTTP" or "MQTT"
+        val servient = createServient("HTTP")
+
+        // Register a shutdown hook
+        Runtime.getRuntime().addShutdownHook(Thread {
+            println("Application is shutting down. Performing cleanup...")
+            runBlocking { servient.shutdown() }
+        })
+
+        val wot = Wot.create(servient)
+        val exposedThing = ExposedThingBuilder.createExposedThing(wot, agent, ThingAgent::class)
+
+        // Start `servient` in a separate coroutine
+        servient.start()
+        // Add and expose the thing after `start()` has had time to begin
+        servient.addThing(exposedThing as WoTExposedThing)
+        servient.expose("agent")
+
+        println("Exposed Agent on HTTP Server")
+        Job().join()
+    }
+}
+

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

@@ -1,34 +1,50 @@
-package ai.ancf.lmos.wot.reflection.annotations
-
-import dev.langchain4j.model.azure.AzureOpenAiChatModel
+package ai.ancf.lmos.wot.integration
+
+import ai.ancf.lmos.arc.agents.AgentProvider
+import ai.ancf.lmos.arc.agents.ChatAgent
+import ai.ancf.lmos.arc.agents.User
+import ai.ancf.lmos.arc.agents.conversation.AssistantMessage
+import ai.ancf.lmos.arc.agents.conversation.latest
+import ai.ancf.lmos.arc.agents.conversation.toConversation
+import ai.ancf.lmos.arc.agents.getAgentByName
+import ai.ancf.lmos.arc.core.getOrThrow
+import ai.ancf.lmos.wot.reflection.annotations.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
+import org.springframework.stereotype.Component
 
 
 @Thing(id= "agent", title="Agent",
     description= "A simple agent.")
 @VersionInfo(instance = "1.0.0")
-class ThingAgent(@Property(name = "modelTemperature", readOnly = true)
+@Component
+class ThingAgent(val agentProvider: AgentProvider, @Property(name = "modelTemperature", readOnly = true)
                  val modelConfiguration: ModelConfiguration = ModelConfiguration(0.5, 50)) {
 
     private val messageFlow = MutableSharedFlow<String>(replay = 1) // Replay last emitted value
 
+
+    /*
     private val model: AzureOpenAiChatModel = AzureOpenAiChatModel.builder()
         .apiKey("af12dab9c046453e82dcf4b24af90bca")
         .deploymentName("GPT35T-1106")
         .endpoint("https://gpt4-uk.openai.azure.com/")
         .temperature(modelConfiguration.modelTemperature)
         .build();
+     */
 
     @Property(name = "observableProperty", title = "Observable Property", readOnly = true)
     val observableProperty : MutableStateFlow<String> = MutableStateFlow("Hello World")
 
     @Action(name = "ask", title = "Ask", description = "Ask the agent a question.")
-    suspend fun  ask(message : String) : String {
-        val response = model.generate(message)
-        messageFlow.emit(response)
-        return model.generate(response)
+    suspend fun ask(message : String) : String {
+        val agent = agentProvider.getAgentByName("My Agent") as ChatAgent? ?: error("Agent not found!")
+        val conversation = message.toConversation(User("anonymous"))
+        val assistantMessage = agent.execute(conversation).getOrThrow().latest<AssistantMessage>() ?:
+            throw RuntimeException("No Assistant response")
+        messageFlow.emit(assistantMessage.content)
+        return assistantMessage.content
     }
 
     @Event(name = "messageGenerated", title = "Generated message")

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

@@ -6,7 +6,6 @@ import ai.ancf.lmos.wot.binding.http.HttpProtocolClientFactory
 import ai.ancf.lmos.wot.binding.http.HttpProtocolServer
 import ai.ancf.lmos.wot.binding.mqtt.MqttClientConfig
 import ai.ancf.lmos.wot.binding.mqtt.MqttProtocolServer
-import ai.ancf.lmos.wot.reflection.annotations.ThingAgent
 import ai.ancf.lmos.wot.thing.ExposedThing
 import ai.ancf.lmos.wot.thing.Type
 import ai.ancf.lmos.wot.thing.schema.*

kotlin-wot-integration-tests/src/main/resources/application.yaml

@@ -0,0 +1,8 @@
+arc:
+  ai:
+    clients:
+      - id: GPT-4o
+        model-name: GPT35T-1106
+        api-key: af12dab9c046453e82dcf4b24af90bca
+        client: azure
+        url: https://gpt4-uk.openai.azure.com

kotlin-wot-reflection/src/main/kotlin/reflection/ExposedThingBuilder.kt

@@ -1,29 +1,26 @@
 package ai.ancf.lmos.wot.reflection
 
 import ai.ancf.lmos.wot.Wot
-import ai.ancf.lmos.wot.reflection.annotations.Action
-import ai.ancf.lmos.wot.reflection.annotations.Event
-import ai.ancf.lmos.wot.reflection.annotations.Property
-import ai.ancf.lmos.wot.reflection.annotations.Thing
+import ai.ancf.lmos.wot.reflection.annotations.*
 import ai.ancf.lmos.wot.reflection.annotations.VersionInfo
 import ai.ancf.lmos.wot.thing.ExposedThing
 import ai.ancf.lmos.wot.thing.schema.*
+import ai.ancf.lmos.wot.thing.schema.ArraySchema
+import ai.ancf.lmos.wot.thing.schema.IntegerSchema
+import ai.ancf.lmos.wot.thing.schema.NumberSchema
+import ai.ancf.lmos.wot.thing.schema.StringSchema
 import ai.ancf.lmos.wot.thing.thingDescription
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.launch
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import kotlin.reflect.*
-import kotlin.reflect.full.declaredMemberFunctions
-import kotlin.reflect.full.findAnnotation
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.*
 
 /**
  * This utility class helps in constructing a [ExposedThing] for a given Kotlin class
@@ -393,9 +390,18 @@ object ExposedThingBuilder {
                 val args = function.parameters.associateWith { param ->
                     if (param.kind == KParameter.Kind.INSTANCE) instance
                     else toKotlinObject(input.value(), param.type)
+                }.toMutableMap()
+                // Check if the function is a suspending function
+                if (function.isSuspend) {
+                    // Call the suspending function with the continuation
+                    val result = function.callSuspendBy(args)
+                    // Return the result from the continuation
+                    InteractionInput.Value(DataSchemaValue.toDataSchemaValue(result))
+                } else {
+                    // Regular function call
+                    val result = function.callBy(args)
+                    InteractionInput.Value(DataSchemaValue.toDataSchemaValue(result))
                 }
-                val result = function.callBy(args)
-                InteractionInput.Value(DataSchemaValue.toDataSchemaValue(result))
             }
         }
     }