Store chat history in threads.

jasperblues · jasperblues · commit 3ecf4caf7027 · 2026-01-16T14:31:09.000+11:00
diff --git a/pom.xml b/pom.xml
@@ -46,7 +46,7 @@
         <dependency>
             <groupId>org.drivine</groupId>
             <artifactId>drivine4j-spring-boot-starter</artifactId>
-            <version>0.0.18</version>
+            <version>0.0.19</version>
         </dependency>
 
 
diff --git a/src/main/kotlin/com/embabel/guide/chat/controller/ChatApiController.kt b/src/main/kotlin/com/embabel/guide/chat/controller/ChatApiController.kt
@@ -10,13 +10,13 @@ import org.springframework.web.bind.annotation.RestController
 @RequestMapping("/api/messages")
 class ChatApiController(private val jesseService: JesseService) {
 
-    data class SendMessageRequest(val threadId: String, val fromUserId: String, val body: String)
+    data class SendMessageRequest(val threadId: String, val fromWebUserId: String, val body: String)
 
     @PostMapping("/send")
     fun sendMessage(@RequestBody req: SendMessageRequest) {
         jesseService.receiveMessage(
             threadId = req.threadId,
-            fromUserId = req.fromUserId,
+            fromWebUserId = req.fromWebUserId,
             message = req.body
         )
     }
diff --git a/src/main/kotlin/com/embabel/guide/chat/controller/ChatController.kt b/src/main/kotlin/com/embabel/guide/chat/controller/ChatController.kt
@@ -2,22 +2,27 @@ package com.embabel.guide.chat.controller
 
 import com.embabel.guide.chat.model.ChatMessage
 import com.embabel.guide.chat.service.JesseService
+import org.slf4j.LoggerFactory
 import org.springframework.messaging.handler.annotation.MessageMapping
 import org.springframework.stereotype.Controller
 import java.security.Principal
 
 @Controller
 class ChatController(private val jesseService: JesseService) {
 
+    private val logger = LoggerFactory.getLogger(ChatController::class.java)
+
     /**
      * Receive a chat message and send it to Jesse for processing.
      * Messages are persisted to the specified thread.
      */
     @MessageMapping("chat.send")
     fun receive(principal: Principal, payload: ChatMessage) {
+        logger.info("ChatController received message from webUser {} in thread {}: {}",
+            principal.name, payload.threadId, payload.body)
         jesseService.receiveMessage(
             threadId = payload.threadId,
-            fromUserId = principal.name,
+            fromWebUserId = principal.name,
             message = payload.body
         )
     }
diff --git a/src/main/kotlin/com/embabel/guide/chat/model/ChatMessage.kt b/src/main/kotlin/com/embabel/guide/chat/model/ChatMessage.kt
@@ -2,8 +2,9 @@ package com.embabel.guide.chat.model
 
 /**
  * Incoming chat message from a client.
+ * Default values required for STOMP message converter deserialization.
  */
 data class ChatMessage(
-    val threadId: String,
-    val body: String
+    val threadId: String = "",
+    val body: String = ""
 )
diff --git a/src/main/kotlin/com/embabel/guide/chat/model/ThreadTimeline.kt b/src/main/kotlin/com/embabel/guide/chat/model/ThreadTimeline.kt
@@ -9,7 +9,7 @@ import org.drivine.annotation.Root
 /**
  * Thread timeline with messages.
  * Each message includes its current version text and author.
- * Messages are sorted by messageId (UUIDv7 = chronological order).
+ * Messages are sorted by messageId (UUIDv7 = chronological order) via DSL deep sorting.
  */
 @GraphView
 data class ThreadTimeline(
@@ -19,12 +19,9 @@ data class ThreadTimeline(
     val owner: GuideUser,
 
     @GraphRelationship(type = "HAS_MESSAGE", direction = Direction.OUTGOING)
-    private val _messages: List<MessageWithVersion>
+    val messages: List<MessageWithVersion> = emptyList()
 ) {
-    /** Messages sorted by messageId (UUIDv7 = chronological order). Sorted once on first access. */
-    val messages: List<MessageWithVersion> by lazy { _messages.sortedBy { it.message.messageId } }
-
     /** Returns a copy of this timeline with an additional message. */
     fun withMessage(message: MessageWithVersion): ThreadTimeline =
-        copy(_messages = _messages + message)
+        copy(messages = messages + message)
 }
diff --git a/src/main/kotlin/com/embabel/guide/chat/repository/ThreadRepositoryImpl.kt b/src/main/kotlin/com/embabel/guide/chat/repository/ThreadRepositoryImpl.kt
@@ -22,6 +22,9 @@ class ThreadRepositoryImpl(
             where {
                 thread.threadId eq threadId
             }
+            orderBy {
+                messages.message.messageId.asc()
+            }
         }
         return Optional.ofNullable(results.firstOrNull())
     }
@@ -32,6 +35,9 @@ class ThreadRepositoryImpl(
             where {
                 owner.core.id eq ownerId
             }
+            orderBy {
+                messages.message.messageId.asc()
+            }
         }
     }
 
@@ -68,7 +74,7 @@ class ThreadRepositoryImpl(
                 createdAt = now
             ),
             owner = owner,
-            _messages = listOf(
+            messages = listOf(
                 MessageWithVersion(
                     message = MessageData(
                         messageId = messageId,
diff --git a/src/main/kotlin/com/embabel/guide/chat/service/FakeRagServiceAdapter.kt b/src/main/kotlin/com/embabel/guide/chat/service/FakeRagServiceAdapter.kt
@@ -74,4 +74,15 @@ class FakeRagServiceAdapter : RagServiceAdapter {
         logger.debug("Fake RAG response generated for user: {}", fromUserId)
         return response
     }
+
+    override suspend fun generateTitle(content: String, fromUserId: String): String {
+        logger.debug("Generating fake title for content from user: {}", fromUserId)
+        // Return first few words of content as title, or a default
+        val words = content.trim().split("\\s+".toRegex())
+        return if (words.size <= 4) {
+            content.take(50)
+        } else {
+            words.take(4).joinToString(" ") + "..."
+        }
+    }
 }
diff --git a/src/main/kotlin/com/embabel/guide/chat/service/GuideRagServiceAdapter.kt b/src/main/kotlin/com/embabel/guide/chat/service/GuideRagServiceAdapter.kt
@@ -155,4 +155,33 @@ class GuideRagServiceAdapter(
             waited += POLL_INTERVAL_MS.toInt()
         }
     }
+
+    /**
+     * Generates a short title from message content using a one-shot call.
+     * This does NOT use the user's session to avoid polluting conversation history.
+     */
+    override suspend fun generateTitle(content: String, fromUserId: String): String = withContext(Dispatchers.IO) {
+        logger.debug("Generating title for content from user: {}", fromUserId)
+
+        val responseBuilder = StringBuilder()
+        var isComplete = false
+
+        val outputChannel = createOutputChannel(responseBuilder, {}) { isComplete = true }
+
+        try {
+            val guideUser = guideUserRepository.findById(fromUserId)
+                .orElseThrow { RuntimeException("No user found with id: $fromUserId") }
+
+            // Create a one-shot session (not cached) for title generation
+            val session = chatbot.createSession(guideUser, outputChannel, null)
+            session.onUserMessage(UserMessage(RagServiceAdapter.TITLE_PROMPT + content))
+
+            waitForResponse { isComplete }
+
+            responseBuilder.toString().trim().take(100).ifBlank { "New conversation" }
+        } catch (e: Exception) {
+            logger.error("Error generating title for user {}: {}", fromUserId, e.message, e)
+            "New conversation"  // Fallback title on error
+        }
+    }
 }
diff --git a/src/main/kotlin/com/embabel/guide/chat/service/JesseService.kt b/src/main/kotlin/com/embabel/guide/chat/service/JesseService.kt
@@ -3,6 +3,7 @@ package com.embabel.guide.chat.service
 import com.embabel.guide.chat.model.DeliveredMessage
 import com.embabel.guide.chat.model.MessageWithVersion
 import com.embabel.guide.chat.model.StatusMessage
+import com.embabel.guide.domain.GuideUserService
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -17,7 +18,8 @@ class JesseService(
     private val chatService: ChatService,
     private val presenceService: PresenceService,
     private val ragAdapter: RagServiceAdapter,
-    private val threadService: ThreadService
+    private val threadService: ThreadService,
+    private val guideUserService: GuideUserService
 ) {
     private val logger = LoggerFactory.getLogger(JesseService::class.java)
     private val coroutineScope = CoroutineScope(Dispatchers.IO)
@@ -59,26 +61,33 @@ class JesseService(
      * Receive a message from a user, persist it, get AI response, and send back.
      *
      * @param threadId the thread to add messages to
-     * @param fromUserId the user sending the message (GuideUser ID)
+     * @param fromWebUserId the WebUser ID from the JWT principal
      * @param message the message text
      */
-    fun receiveMessage(threadId: String, fromUserId: String, message: String) {
-        logger.info("Jesse received message from user {} in thread {}", fromUserId, threadId)
+    fun receiveMessage(threadId: String, fromWebUserId: String, message: String) {
+        logger.info("Jesse received message from webUser {} in thread {}", fromWebUserId, threadId)
 
         coroutineScope.launch {
             try {
+                // Look up the GuideUser by WebUser ID
+                val guideUser = guideUserService.findByWebUserId(fromWebUserId).orElseThrow {
+                    IllegalArgumentException("User not found for webUserId: $fromWebUserId")
+                }
+                val guideUserId = guideUser.core.id
+
                 // Save the user's message to the thread
                 threadService.addMessage(
                     threadId = threadId,
                     text = message,
                     role = ThreadService.ROLE_USER,
-                    authorId = fromUserId
+                    authorId = guideUserId
                 )
 
                 // Send status updates to the user while processing
-                val response = ragAdapter.sendMessage(message, fromUserId) { event ->
-                    logger.debug("RAG event for user {}: {}", fromUserId, event)
-                    sendStatusToUser(fromUserId, event)
+                // Use WebUser ID for WebSocket delivery (that's the principal in the session)
+                val response = ragAdapter.sendMessage(message, guideUserId) { event ->
+                    logger.debug("RAG event for user {}: {}", fromWebUserId, event)
+                    sendStatusToUser(fromWebUserId, event)
                 }
 
                 // Save the assistant's response to the thread
@@ -89,11 +98,11 @@ class JesseService(
                     authorId = null  // System-generated response
                 )
 
-                // Send the response to the user via WebSocket
-                sendMessageToUser(fromUserId, assistantMessage, threadId)
+                // Send the response to the user via WebSocket (use WebUser ID)
+                sendMessageToUser(fromWebUserId, assistantMessage, threadId)
             } catch (e: Exception) {
-                logger.error("Error processing message from user {}: {}", fromUserId, e.message, e)
-                sendStatusToUser(fromUserId, "Error processing your request")
+                logger.error("Error processing message from webUser {}: {}", fromWebUserId, e.message, e)
+                sendStatusToUser(fromWebUserId, "Error processing your request")
 
                 // Save error message to thread and send to user
                 val errorMessage = threadService.addMessage(
@@ -102,7 +111,7 @@ class JesseService(
                     role = ThreadService.ROLE_ASSISTANT,
                     authorId = null
                 )
-                sendMessageToUser(fromUserId, errorMessage, threadId)
+                sendMessageToUser(fromWebUserId, errorMessage, threadId)
             }
         }
     }
diff --git a/src/main/kotlin/com/embabel/guide/chat/service/RagServiceAdapter.kt b/src/main/kotlin/com/embabel/guide/chat/service/RagServiceAdapter.kt
@@ -8,6 +8,11 @@ package com.embabel.guide.chat.service
  */
 interface RagServiceAdapter {
 
+    companion object {
+        const val TITLE_PROMPT = "Generate a short title (max 6 words) for this message. " +
+            "Reply with ONLY the title, no quotes or punctuation: "
+    }
+
     /**
      * Sends a message to the RAG system and returns the response.
      *
@@ -25,4 +30,16 @@ interface RagServiceAdapter {
         fromUserId: String,
         onEvent: (String) -> Unit = {}
     ): String
+
+    /**
+     * Generates a short title from message content.
+     *
+     * @param content The message content to generate a title from
+     * @param fromUserId The ID of the user (for session context)
+     * @return A short title (typically 3-6 words)
+     */
+    suspend fun generateTitle(content: String, fromUserId: String): String {
+        val response = sendMessage(TITLE_PROMPT + content, fromUserId)
+        return response.trim().take(100)  // Safety limit
+    }
 }
diff --git a/src/main/kotlin/com/embabel/guide/chat/service/ThreadService.kt b/src/main/kotlin/com/embabel/guide/chat/service/ThreadService.kt
@@ -40,6 +40,15 @@ class ThreadService(
         return threadRepository.findByOwnerId(ownerId)
     }
 
+    /**
+     * Find all threads owned by a user, sorted by most recent activity.
+     * Threads with the most recent messages appear first.
+     */
+    fun findByOwnerIdByRecentActivity(ownerId: String): List<ThreadTimeline> {
+        return threadRepository.findByOwnerId(ownerId)
+            .sortedByDescending { it.messages.lastOrNull()?.message?.messageId ?: "" }
+    }
+
     /**
      * Create a new thread with an initial message.
      *
@@ -113,6 +122,28 @@ class ThreadService(
         )
     }
 
+    /**
+     * Create a new thread from user message content.
+     * Generates a title from the content using AI.
+     *
+     * @param ownerId the user who owns the thread
+     * @param content the initial message content
+     * @return the created thread timeline
+     */
+    suspend fun createThreadFromContent(
+        ownerId: String,
+        content: String
+    ): ThreadTimeline = withContext(Dispatchers.IO) {
+        val title = ragAdapter.generateTitle(content, ownerId)
+        createThread(
+            ownerId = ownerId,
+            title = title,
+            message = content,
+            role = ROLE_USER,
+            authorId = ownerId
+        )
+    }
+
     /**
      * Add a message to an existing thread.
      *
diff --git a/src/main/kotlin/com/embabel/hub/HubApiController.kt b/src/main/kotlin/com/embabel/hub/HubApiController.kt
@@ -4,6 +4,7 @@ import com.embabel.guide.chat.model.DeliveredMessage
 import com.embabel.guide.chat.service.ThreadService
 import com.embabel.guide.domain.GuideUser
 import com.embabel.guide.domain.GuideUserService
+import kotlinx.coroutines.runBlocking
 import org.springframework.security.core.Authentication
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
@@ -60,14 +61,35 @@ class HubApiController(
     }
 
     data class ThreadSummary(val id: String, val title: String?)
+    data class CreateThreadRequest(val content: String)
+    data class CreateThreadResponse(val threadId: String, val title: String?)
+
+    @PostMapping("/threads")
+    fun createThread(
+        @RequestBody request: CreateThreadRequest,
+        authentication: Authentication?
+    ): CreateThreadResponse {
+        val webUserId = authentication?.principal as? String
+            ?: throw UnauthorizedException()
+        val guideUser = guideUserService.findByWebUserId(webUserId)
+            .orElseThrow { UnauthorizedException() }
+
+        val timeline = runBlocking {
+            threadService.createThreadFromContent(
+                ownerId = guideUser.core.id,
+                content = request.content
+            )
+        }
+        return CreateThreadResponse(timeline.thread.threadId, timeline.thread.title)
+    }
 
     @GetMapping("/threads")
     fun listThreads(authentication: Authentication?): List<ThreadSummary> {
         val webUserId = authentication?.principal as? String
             ?: throw UnauthorizedException()
         val guideUser = guideUserService.findByWebUserId(webUserId)
             .orElseThrow { UnauthorizedException() }
-        return threadService.findByOwnerId(guideUser.core.id)
+        return threadService.findByOwnerIdByRecentActivity(guideUser.core.id)
             .map { ThreadSummary(it.thread.threadId, it.thread.title) }
     }
 
diff --git a/src/main/kotlin/com/embabel/hub/HubService.kt b/src/main/kotlin/com/embabel/hub/HubService.kt
diff --git a/src/test/kotlin/com/embabel/guide/chat/repository/ThreadRepositoryImplTest.kt b/src/test/kotlin/com/embabel/guide/chat/repository/ThreadRepositoryImplTest.kt
diff --git a/src/test/kotlin/com/embabel/hub/HubApiControllerTest.kt b/src/test/kotlin/com/embabel/hub/HubApiControllerTest.kt

Original file line number	Diff line number	Diff line change
`@@ -10,13 +10,13 @@ import org.springframework.web.bind.annotation.RestController`
`10`	`10`	`@RequestMapping("/api/messages")`
`11`	`11`	`class ChatApiController(private val jesseService: JesseService) {`
`12`	`12`
`13`		`- data class SendMessageRequest(val threadId: String, val fromUserId: String, val body: String)`
	`13`	`+ data class SendMessageRequest(val threadId: String, val fromWebUserId: String, val body: String)`
`14`	`14`
`15`	`15`	`@PostMapping("/send")`
`16`	`16`	`fun sendMessage(@RequestBody req: SendMessageRequest) {`
`17`	`17`	`jesseService.receiveMessage(`
`18`	`18`	`threadId = req.threadId,`
`19`		`- fromUserId = req.fromUserId,`
	`19`	`+ fromWebUserId = req.fromWebUserId,`
`20`	`20`	`message = req.body`
`21`	`21`	`)`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,9 @@ class ThreadRepositoryImpl(`
`22`	`22`	`where {`
`23`	`23`	`thread.threadId eq threadId`
`24`	`24`	`}`
	`25`	`+ orderBy {`
	`26`	`+ messages.message.messageId.asc()`
	`27`	`+ }`
`25`	`28`	`}`
`26`	`29`	`return Optional.ofNullable(results.firstOrNull())`
`27`	`30`	`}`
`@@ -32,6 +35,9 @@ class ThreadRepositoryImpl(`
`32`	`35`	`where {`
`33`	`36`	`owner.core.id eq ownerId`
`34`	`37`	`}`
	`38`	`+ orderBy {`
	`39`	`+ messages.message.messageId.asc()`
	`40`	`+ }`
`35`	`41`	`}`
`36`	`42`	`}`
`37`	`43`
`@@ -68,7 +74,7 @@ class ThreadRepositoryImpl(`
`68`	`74`	`createdAt = now`
`69`	`75`	`),`
`70`	`76`	`owner = owner,`
`71`		`- _messages = listOf(`
	`77`	`+ messages = listOf(`
`72`	`78`	`MessageWithVersion(`
`73`	`79`	`message = MessageData(`
`74`	`80`	`messageId = messageId,`