Initial Kotlin-SDK

Author: Robert Winkler

build.gradle.kts

@@ -10,7 +10,7 @@ subprojects {
     apply(plugin = "maven-publish")
 
     group = "ai.ancf.lmos"
-    version = "0.1.0-SNAPSHOT"
+    version = "0.1.3-SNAPSHOT"
 
     dependencies {
         testImplementation(kotlin("test"))

kotlin-wot-binding-http/src/main/kotlin/http/HttpProtocolClient.kt

@@ -124,8 +124,15 @@ fun createHttpClient(): HttpClient {
             engine {
                 proxy = ProxyBuilder.http(proxyUrl)
             }
+            install(HttpTimeout) {
+                requestTimeoutMillis = 50000
+            }
         }
     } else {
-        HttpClient(CIO)
+        HttpClient(CIO) {
+            install(HttpTimeout) {
+                requestTimeoutMillis = 50000
+            }
+        }
     }
 }

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

@@ -3,22 +3,23 @@ import org.springframework.boot.gradle.tasks.run.BootRun
 import java.net.URI
 
 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"
+    kotlin("plugin.spring") version "1.9.25"
+    id("org.springframework.boot") version "3.4.2"
+    id("io.spring.dependency-management") version "1.1.7"
 }
 
-tasks.named<Test>("test") {
-    enabled = false
-}
+//tasks.named<Test>("test") {
+//    enabled = false
+//}
 
 dependencies {
     // Replace the following with the starter dependencies of specific modules you wish to use
     api(project(":kotlin-wot-binding-http"))
     api(project(":kotlin-wot-binding-websocket"))
     api(project(":kotlin-wot-binding-mqtt"))
     api(project(":kotlin-wot-spring-boot-starter"))
-    api(project(":kotlin-wot-lmos-protocol"))
+    api(project(":lmos-kotlin-sdk-client"))
+    api(project(":lmos-kotlin-sdk-server"))
     implementation("org.eclipse.lmos:arc-azure-client:0.1.0-SNAPSHOT")
 
     api("org.eclipse.lmos:arc-spring-boot-starter:0.1.0-SNAPSHOT")
@@ -40,6 +41,8 @@ dependencies {
     //implementation("io.opentelemetry:opentelemetry-exporter-otlp")
 
     implementation("dev.langchain4j:langchain4j-azure-open-ai:1.0.0-beta1")
+    implementation("org.jsoup:jsoup:1.7.2")
+
     //implementation("dev.langchain4j:langchain4j:0.35.0")
     testImplementation("org.springframework.boot:spring-boot-starter-test")
     testImplementation("com.hivemq:hivemq-mqtt-client:1.3.3")

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

@@ -7,6 +7,7 @@ import ai.ancf.lmos.wot.security.SecurityScheme
 import ai.ancf.lmos.wot.thing.schema.WoTConsumedThing
 import com.fasterxml.jackson.module.kotlin.readValue
 import kotlinx.coroutines.runBlocking
+import org.eclipse.lmos.arc.agents.dsl.AllTools
 import org.eclipse.lmos.arc.agents.functions.LLMFunction
 import org.eclipse.lmos.arc.spring.Agents
 import org.eclipse.lmos.arc.spring.Functions
@@ -22,14 +23,15 @@ import org.springframework.context.annotation.Configuration
 @EnableConfigurationProperties(ToolProperties::class)
 class AgentConfiguration {
 
-    private lateinit var thingDescriptionsMap : Map<String, WoTConsumedThing>
+    private lateinit var thingDescriptionsMap: Map<String, WoTConsumedThing>
 
-    private val log : Logger = LoggerFactory.getLogger(AgentConfiguration::class.java)
+    private val log: Logger = LoggerFactory.getLogger(AgentConfiguration::class.java)
 
     @Bean
     fun chatArcAgent(agent: Agents) = agent {
         name = "ChatAgent"
-        prompt { """
+        prompt {
+            """
             You are a professional smart home assistant.  
             ## Instructions  
 
@@ -63,7 +65,8 @@ class AgentConfiguration {
             - "Set the thermostat to 72°F."  
             - "Lock the front door."  
             
-        """.trimIndent() }
+        """.trimIndent()
+        }
         model = { "GPT-4o" }
         filterInput { -"Hello world" }
         tools = listOf("devices")
@@ -81,11 +84,13 @@ class AgentConfiguration {
         name = "ScraperAgent"
         prompt { "You can scrape a page by using the scraper tool." }
         model = { "GPT-4o" }
-        tools = listOf("fetchContent")
+        tools = AllTools
     }
 
     @Bean
-    fun agentEventListener(applicationEventPublisher: ApplicationEventPublisher) = ArcEventListener(applicationEventPublisher)
+    fun agentEventListener(applicationEventPublisher: ApplicationEventPublisher) =
+        ArcEventListener(applicationEventPublisher)
+
 
     @Bean
     fun discoverTools(toolProperties: ToolProperties, functions: Functions, wot: Wot) : List<LLMFunction> = runBlocking {
@@ -108,12 +113,19 @@ class AgentConfiguration {
         }
     }
 
-}
-
-data class Resources(
-    val milk: Int,
-    val water: Int ,
-    val chocolate : Int,
-    val coffeeBeans: Int
-)
+    /*
+    @Bean
+    fun discoverLocalTools(functions: Functions, wot: Wot, scraperTool: ScraperTool) : List<LLMFunction>{
+        log.info("Map Scraper to LLM Functions")
+        val exposedThing = ExposedThingBuilder.createExposedThing(wot, scraperTool, ScraperTool::class)
+        return if(exposedThing != null) {
+            ThingToFunctionsMapper
+                .mapThingDescriptionToFunctions2(functions, "scraper",
+                    exposedThing.getThingDescription()).toList()
+        }else{
+            emptyList()
+        }
+    }
+    */
 
+}

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

@@ -1,35 +1,26 @@
 package ai.ancf.lmos.wot.integration
 
-import ai.ancf.lmos.wot.protocol.ConversationalAgent
-import io.opentelemetry.api.trace.Span
-import io.opentelemetry.instrumentation.annotations.SpanAttribute
+
+import ai.ancf.lmos.sdk.agents.ConversationalAgent
+import ai.ancf.lmos.sdk.model.AgentRequest
+import ai.ancf.lmos.sdk.model.AgentResult
+import integration.executeAgent
 import io.opentelemetry.instrumentation.annotations.WithSpan
 import org.eclipse.lmos.arc.agents.AgentProvider
-import org.eclipse.lmos.arc.agents.User
-import org.eclipse.lmos.arc.agents.conversation.AssistantMessage
-import org.eclipse.lmos.arc.agents.conversation.latest
-import org.eclipse.lmos.arc.agents.conversation.toConversation
 import org.eclipse.lmos.arc.agents.getAgentByName
-import org.eclipse.lmos.arc.core.getOrThrow
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
 
 @Component
-class ArcConversationalAgent(agentProvider: AgentProvider) : ConversationalAgent<String, String> {
+class ArcConversationalAgent(agentProvider: AgentProvider) : ConversationalAgent {
 
     private val agent = agentProvider.getAgentByName("ChatAgent") as org.eclipse.lmos.arc.agents.ChatAgent
 
     private val log : Logger = LoggerFactory.getLogger(ArcConversationalAgent::class.java)
 
     @WithSpan
-    override suspend fun chat(@SpanAttribute message: String): String {
-        log.info("Chat input: $message")
-        val assistantMessage = agent.execute(message.toConversation(User("myId"))).getOrThrow().latest<AssistantMessage>()
-            ?: throw RuntimeException("No Assistant response")
-
-        val currentSpan = Span.current()
-        currentSpan.setAttribute("assistantMessage", assistantMessage.content)
-        return assistantMessage.content
+    override suspend fun chat(message: AgentRequest): AgentResult {
+        return executeAgent(message, agent::execute)
     }
 }

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

@@ -1,6 +1,8 @@
 package ai.ancf.lmos.wot.integration
 
 
+
+import ai.ancf.lmos.sdk.model.AgentEvent
 import ai.ancf.lmos.wot.JsonMapper
 import org.eclipse.lmos.arc.agents.events.Event
 import org.eclipse.lmos.arc.agents.events.EventHandler
@@ -10,8 +12,14 @@ import org.springframework.context.ApplicationEventPublisher
 class ArcEventListener(private val applicationEventPublisher: ApplicationEventPublisher) : EventHandler<Event> {
 
     override fun onEvent(event: Event) {
-        applicationEventPublisher.publishEvent(AgentEvent(JsonMapper.instance.writeValueAsString(event)))
+        applicationEventPublisher.publishEvent(SpringApplicationAgentEvent(
+            AgentEvent(
+                event::class.simpleName.toString(),
+                JsonMapper.instance.writeValueAsString(event),
+                event.context["conversationId"],
+                event.context["turnId"])
+        ))
     }
 }
 
-data class AgentEvent(val message: String) : ApplicationEvent(message)
+data class SpringApplicationAgentEvent(val event: AgentEvent) : ApplicationEvent(event)

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

@@ -0,0 +1,29 @@
+package integration
+
+import ai.ancf.lmos.sdk.model.AgentRequest
+import ai.ancf.lmos.sdk.model.AgentResult
+import ai.ancf.lmos.sdk.model.Message
+import org.eclipse.lmos.arc.agents.AgentFailedException
+import org.eclipse.lmos.arc.agents.User
+import org.eclipse.lmos.arc.agents.conversation.AssistantMessage
+import org.eclipse.lmos.arc.agents.conversation.Conversation
+import org.eclipse.lmos.arc.agents.conversation.latest
+import org.eclipse.lmos.arc.agents.conversation.toConversation
+import org.eclipse.lmos.arc.core.Result
+import org.eclipse.lmos.arc.core.getOrThrow
+
+suspend fun executeAgent(message: AgentRequest, function: suspend (Conversation) -> Result<Conversation, AgentFailedException>): AgentResult {
+    val lastMessage : String = message.messages.last().content
+    val assistantMessage = function(lastMessage.toConversation(User("myId"))).getOrThrow().latest<AssistantMessage>()
+        ?: throw RuntimeException("No Assistant response")
+    return AgentResult(
+        messages = listOf(
+            Message(
+                role = "assistant",
+                content = assistantMessage.content,
+                turnId = assistantMessage.turnId
+            )
+        )
+    )
+}
+

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

@@ -1,8 +1,10 @@
 package ai.ancf.lmos.wot.integration
 
-import ai.ancf.lmos.wot.JsonMapper
-import ai.ancf.lmos.wot.protocol.ConversationalAgent
-import ai.ancf.lmos.wot.protocol.LMOSContext
+import ai.ancf.lmos.sdk.LMOSContext
+import ai.ancf.lmos.sdk.agents.ConversationalAgent
+import ai.ancf.lmos.sdk.model.AgentEvent
+import ai.ancf.lmos.sdk.model.AgentRequest
+import ai.ancf.lmos.sdk.model.AgentResult
 import ai.ancf.lmos.wot.protocol.LMOSThingType
 import ai.ancf.lmos.wot.reflection.annotations.*
 import kotlinx.coroutines.CoroutineScope
@@ -20,25 +22,25 @@ import org.springframework.stereotype.Component
 @Link(href = "lmos/capabilities", rel = "service-meta", type = "application/json")
 @VersionInfo(instance = "1.0.0")
 @Component
-class ChatAgent(private val arcAgent: ConversationalAgent<String, String>): ApplicationListener<AgentEvent> {
+class ChatAgent(private val arcAgent: ConversationalAgent): ApplicationListener<SpringApplicationAgentEvent> {
 
-    private val agentEventFlow = MutableSharedFlow<String>(replay = 1) // Replay last emitted value
+    private val agentEventFlow = MutableSharedFlow<AgentEvent>(replay = 1) // Replay last emitted value
 
     @Action(title = "Chat", description = "Ask the agent a question.")
     @ActionInput(title = "The question", description = "A question")
-    @ActionOutput(title = "The question", description = "A question")
-    suspend fun chat(message: String) : String {
+    @ActionOutput(title = "The answer", description = "The Answer")
+    suspend fun chat(message: AgentRequest) : AgentResult {
         return arcAgent.chat(message)
     }
 
     @Event(title = "Agent Event", description = "An event from the agent.")
-    fun agentEvent() : Flow<String> {
+    fun agentEvent() : Flow<AgentEvent> {
         return agentEventFlow
     }
 
-    override fun onApplicationEvent(event: AgentEvent) {
+    override fun onApplicationEvent(event: SpringApplicationAgentEvent) {
         CoroutineScope(Dispatchers.IO).launch {
-            agentEventFlow.emit(JsonMapper.instance.writeValueAsString(event))
+            agentEventFlow.emit(event.event)
         }
     }
 }

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

@@ -1,20 +1,18 @@
 package ai.ancf.lmos.wot.integration
 
 
+import ai.ancf.lmos.sdk.model.AgentRequest
+import ai.ancf.lmos.sdk.model.AgentResult
 import ai.ancf.lmos.wot.protocol.LMOSContext
 import ai.ancf.lmos.wot.protocol.LMOSThingType
 import ai.ancf.lmos.wot.reflection.annotations.Action
 import ai.ancf.lmos.wot.reflection.annotations.Context
 import ai.ancf.lmos.wot.reflection.annotations.Thing
 import ai.ancf.lmos.wot.reflection.annotations.VersionInfo
+import integration.executeAgent
 import kotlinx.coroutines.flow.MutableSharedFlow
 import org.eclipse.lmos.arc.agents.AgentProvider
-import org.eclipse.lmos.arc.agents.User
-import org.eclipse.lmos.arc.agents.conversation.AssistantMessage
-import org.eclipse.lmos.arc.agents.conversation.latest
-import org.eclipse.lmos.arc.agents.conversation.toConversation
 import org.eclipse.lmos.arc.agents.getAgentByName
-import org.eclipse.lmos.arc.core.getOrThrow
 import org.springframework.stereotype.Component
 
 
@@ -30,10 +28,8 @@ class ResearcherAgent(agentProvider: AgentProvider) {
     val agent = agentProvider.getAgentByName("ResearcherAgent") as org.eclipse.lmos.arc.agents.ChatAgent
 
     @Action(title = "Chat", description = "Ask the agent a question.")
-    suspend fun chat(message : String) : String {
-        val assistantMessage = agent.execute(message.toConversation(User("myId"))).getOrThrow().latest<AssistantMessage>() ?:
-            throw RuntimeException("No Assistant response")
-        return assistantMessage.content
+    suspend fun chat(message : AgentRequest) : AgentResult {
+        return executeAgent(message, agent::execute)
     }
 }
 

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

@@ -1,18 +1,21 @@
 package ai.ancf.lmos.wot.integration
 
 
+import ai.ancf.lmos.sdk.model.AgentEvent
+import ai.ancf.lmos.sdk.model.AgentRequest
+import ai.ancf.lmos.sdk.model.AgentResult
 import ai.ancf.lmos.wot.protocol.LMOSContext
 import ai.ancf.lmos.wot.protocol.LMOSThingType
 import ai.ancf.lmos.wot.reflection.annotations.*
+import integration.executeAgent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.launch
 import org.eclipse.lmos.arc.agents.AgentProvider
-import org.eclipse.lmos.arc.agents.User
-import org.eclipse.lmos.arc.agents.conversation.AssistantMessage
-import org.eclipse.lmos.arc.agents.conversation.latest
-import org.eclipse.lmos.arc.agents.conversation.toConversation
 import org.eclipse.lmos.arc.agents.getAgentByName
-import org.eclipse.lmos.arc.core.getOrThrow
+import org.springframework.context.ApplicationListener
 import org.springframework.stereotype.Component
 
 
@@ -21,23 +24,26 @@ import org.springframework.stereotype.Component
 @Context(prefix = LMOSContext.prefix, url = LMOSContext.url)
 @VersionInfo(instance = "1.0.0")
 @Component
-class ScraperAgent(agentProvider: AgentProvider) {
+class ScraperAgent(agentProvider: AgentProvider) : ApplicationListener<SpringApplicationAgentEvent> {
 
-    private val messageFlow = MutableSharedFlow<String>(replay = 1) // Replay last emitted value
+    private val agentEventFlow = MutableSharedFlow<AgentEvent>()
 
     val agent = agentProvider.getAgentByName("ScraperAgent") as org.eclipse.lmos.arc.agents.ChatAgent
 
-    @Event(description = "HTML Content of the scraped web site")
-    fun contentRetrieved() : Flow<String> {
-        return messageFlow
+    @Action(title = "chat", description = "Ask the agent a question.")
+    suspend fun chat(message: AgentRequest) : AgentResult {
+        return executeAgent(message, agent::execute)
     }
 
-    @Action(title = "chat", description = "Ask the agent a question.")
-    suspend fun chat(message: String) : String {
-        val assistantMessage = agent.execute(message.toConversation(User("myId"))).getOrThrow().latest<AssistantMessage>() ?:
-        throw RuntimeException("No Assistant response")
-        messageFlow.emit(assistantMessage.content)
-        return assistantMessage.content
+    @Event(title = "Agent Event", description = "An event from the agent.")
+    fun agentEvent() : Flow<AgentEvent> {
+        return agentEventFlow
+    }
+
+    override fun onApplicationEvent(event: SpringApplicationAgentEvent) {
+        CoroutineScope(Dispatchers.IO).launch {
+            agentEventFlow.emit(event.event)
+        }
     }
 }