@lota-sdk/core 0.2.3 → 0.3.1

package/src/services/{workstream-message.service.ts → thread-message.service.ts}

@@ -10,54 +10,54 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { WorkstreamMessageRowSchema } from '../db/workstream-message-row'
-import type { WorkstreamMessageRow } from '../db/workstream-message-row'
+import { ThreadMessageRowSchema } from '../db/thread-message-row'
+import type { ThreadMessageRow } from '../db/thread-message-row'
 
-const WorkstreamMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
+const ThreadMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
 
 function toMessageId(value: string | RecordIdRef): string {
-  return recordIdToString(value, TABLES.WORKSTREAM_MESSAGE)
+  return recordIdToString(value, TABLES.THREAD_MESSAGE)
 }
 
 /**
- * Builds a collision-free row id by hashing the workstream + message id pair.
+ * Builds a collision-free row id by hashing the thread + message id pair.
  * Previous implementation replaced non-alphanumeric chars with '_', which was
  * lossy (e.g. "msg:foo" and "msg_foo" mapped to the same row id).
  * Now uses a 32-char SHA-256 hex prefix -- short enough for ergonomic ids,
  * long enough (128 bits) to make collisions negligible.
  */
-function toWorkstreamMessageRowId(workstreamId: RecordIdRef, messageId: string): RecordId {
-  const workstreamStr = recordIdToString(workstreamId, TABLES.WORKSTREAM)
-  const digest = new Bun.CryptoHasher('sha256').update(`${workstreamStr}\0${messageId}`).digest('hex').slice(0, 32)
-  return new RecordId(TABLES.WORKSTREAM_MESSAGE, digest)
+function toThreadMessageRowId(threadId: RecordIdRef, messageId: string): RecordId {
+  const threadStr = recordIdToString(threadId, TABLES.THREAD)
+  const digest = new Bun.CryptoHasher('sha256').update(`${threadStr}\0${messageId}`).digest('hex').slice(0, 32)
+  return new RecordId(TABLES.THREAD_MESSAGE, digest)
 }
 
-function toWorkstreamRef(workstreamId: RecordIdRef): RecordId {
-  return ensureRecordId(workstreamId, TABLES.WORKSTREAM)
+function toThreadRef(threadId: RecordIdRef): RecordId {
+  return ensureRecordId(threadId, TABLES.THREAD)
 }
 
-function toChatMessage(row: WorkstreamMessageRow): ChatMessage {
+function toChatMessage(row: ThreadMessageRow): ChatMessage {
   const rowCreatedAt = requireTimestamp(row.createdAt)
   const metadata = withCreatedAtMetadata(parseRowMetadata(row.metadata), rowCreatedAt)
 
   return { id: row.messageId, role: row.role, parts: row.parts as ChatMessage['parts'], metadata }
 }
 
-const workstreamPaginationConfig: CursorPaginationConfig = {
-  table: TABLES.WORKSTREAM_MESSAGE,
-  parentFilterField: 'workstreamId',
-  toRowId: toWorkstreamMessageRowId,
-  parseRow: (row: unknown) => WorkstreamMessageRowSchema.parse(row),
-  toMessage: (row: unknown) => toChatMessage(WorkstreamMessageRowSchema.parse(row)),
+const threadPaginationConfig: CursorPaginationConfig = {
+  table: TABLES.THREAD_MESSAGE,
+  parentFilterField: 'threadId',
+  toRowId: toThreadMessageRowId,
+  parseRow: (row: unknown) => ThreadMessageRowSchema.parse(row),
+  toMessage: (row: unknown) => toChatMessage(ThreadMessageRowSchema.parse(row)),
   queryLatest: (parentId, limit) => surql`
-    SELECT * FROM workstreamMessage
-    WHERE workstreamId = ${parentId}
+    SELECT * FROM threadMessage
+    WHERE threadId = ${parentId}
     ORDER BY createdAt DESC, id DESC
     LIMIT ${limit}
   `,
   queryBefore: (parentId, cursorCreatedAt, cursorId, limit) => surql`
-    SELECT * FROM workstreamMessage
-    WHERE workstreamId = ${parentId}
+    SELECT * FROM threadMessage
+    WHERE threadId = ${parentId}
       AND (
         createdAt < ${cursorCreatedAt}
         OR (createdAt = ${cursorCreatedAt} AND id < ${cursorId})
@@ -67,9 +67,9 @@ const workstreamPaginationConfig: CursorPaginationConfig = {
   `,
 }
 
-class WorkstreamMessageService {
-  async upsertMessages(params: { workstreamId: RecordIdRef; messages: ChatMessage[] }): Promise<void> {
-    const workstreamId = toWorkstreamRef(params.workstreamId)
+class ThreadMessageService {
+  async upsertMessages(params: { threadId: RecordIdRef; messages: ChatMessage[] }): Promise<void> {
+    const threadId = toThreadRef(params.threadId)
 
     const upsertPromises = params.messages.map(async (message) => {
       const messageId = message.id.trim()
@@ -81,82 +81,82 @@ class WorkstreamMessageService {
         : []
       if (parts.length === 0) {
         if (role === 'assistant') return
-        throw new Error(`Refusing to persist workstream message "${messageId}" with empty parts`)
+        throw new Error(`Refusing to persist thread message "${messageId}" with empty parts`)
       }
-      const rowId = toWorkstreamMessageRowId(workstreamId, messageId)
+      const rowId = toThreadMessageRowId(threadId, messageId)
       const existingRow = await databaseService.findOne(
-        TABLES.WORKSTREAM_MESSAGE,
-        { workstreamId, messageId },
-        WorkstreamMessageExistingRowSchema,
+        TABLES.THREAD_MESSAGE,
+        { threadId, messageId },
+        ThreadMessageExistingRowSchema,
       )
       const persistedCreatedAt =
         existingRow === null ? requireTimestamp(message.metadata?.createdAt) : requireTimestamp(existingRow.createdAt)
       const metadata = withCreatedAtMetadata({ ...message.metadata, createdAt: persistedCreatedAt })
 
       await databaseService.upsert(
-        TABLES.WORKSTREAM_MESSAGE,
+        TABLES.THREAD_MESSAGE,
         rowId,
         {
-          workstreamId,
+          threadId,
           messageId,
           role,
           parts,
           metadata,
           createdAt: existingRow ? existingRow.createdAt : new Date(persistedCreatedAt),
         },
-        WorkstreamMessageRowSchema,
+        ThreadMessageRowSchema,
         { mutation: 'content' },
       )
     })
     await Promise.all(upsertPromises)
   }
 
-  async listMessages(workstreamId: RecordIdRef): Promise<ChatMessage[]> {
-    const workstreamRef = toWorkstreamRef(workstreamId)
+  async listMessages(threadId: RecordIdRef): Promise<ChatMessage[]> {
+    const threadRef = toThreadRef(threadId)
     const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM workstreamMessage
-      WHERE workstreamId = ${workstreamRef}
+      SELECT * FROM threadMessage
+      WHERE threadId = ${threadRef}
       ORDER BY createdAt ASC, id ASC
     `)
 
-    return rows.map((row) => WorkstreamMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
+    return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
   }
 
   async listMessageHistoryPage(params: {
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     take: number
     beforeMessageId?: string
   }): Promise<MessageHistoryPage> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
-    return listMessageHistoryPage(workstreamPaginationConfig, {
-      parentId: workstreamRef,
+    const threadRef = toThreadRef(params.threadId)
+    return listMessageHistoryPage(threadPaginationConfig, {
+      parentId: threadRef,
       take: params.take,
       beforeMessageId: params.beforeMessageId,
     })
   }
 
-  async listMessagesAfterCursor(workstreamId: RecordIdRef, afterMessageId?: string): Promise<ChatMessage[]> {
-    const workstreamRef = toWorkstreamRef(workstreamId)
+  async listMessagesAfterCursor(threadId: RecordIdRef, afterMessageId?: string): Promise<ChatMessage[]> {
+    const threadRef = toThreadRef(threadId)
     const cursorMessageId = afterMessageId?.trim()
     if (!cursorMessageId) {
-      return this.listMessages(workstreamRef)
+      return this.listMessages(threadRef)
     }
 
     const cursorRow = await databaseService.findOne(
-      TABLES.WORKSTREAM_MESSAGE,
-      { workstreamId: workstreamRef, messageId: cursorMessageId },
+      TABLES.THREAD_MESSAGE,
+      { threadId: threadRef, messageId: cursorMessageId },
       CursorRowSchema,
     )
 
     if (!cursorRow) {
-      throw new Error(`Workstream cursor message not found: ${cursorMessageId}`)
+      throw new Error(`Thread cursor message not found: ${cursorMessageId}`)
     }
 
     const cursorCreatedAt = cursorRow.createdAt
-    const cursorId = toWorkstreamMessageRowId(workstreamRef, cursorMessageId)
+    const cursorId = toThreadMessageRowId(threadRef, cursorMessageId)
     const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM workstreamMessage
-      WHERE workstreamId = ${workstreamRef}
+      SELECT * FROM threadMessage
+      WHERE threadId = ${threadRef}
         AND (
           createdAt > ${cursorCreatedAt}
           OR (createdAt = ${cursorCreatedAt} AND id > ${cursorId})
@@ -164,26 +164,26 @@ class WorkstreamMessageService {
       ORDER BY createdAt ASC, id ASC
     `)
 
-    return rows.map((row) => WorkstreamMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
+    return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
   }
 
-  async listRecentMessages(workstreamId: RecordIdRef, limit: number): Promise<ChatMessage[]> {
-    const workstreamRef = toWorkstreamRef(workstreamId)
+  async listRecentMessages(threadId: RecordIdRef, limit: number): Promise<ChatMessage[]> {
+    const threadRef = toThreadRef(threadId)
     const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM workstreamMessage
-      WHERE workstreamId = ${workstreamRef}
+      SELECT * FROM threadMessage
+      WHERE threadId = ${threadRef}
       ORDER BY createdAt DESC, id DESC
       LIMIT ${Math.max(1, limit)}
     `)
 
     return rows
-      .map((row) => WorkstreamMessageRowSchema.parse(row))
+      .map((row) => ThreadMessageRowSchema.parse(row))
       .reverse()
       .map((row) => toChatMessage(row))
   }
 
   async searchMessages(params: {
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     role: 'user' | 'assistant'
     query: string
     limit: number
@@ -191,7 +191,7 @@ class WorkstreamMessageService {
     const normalizedQuery = params.query.trim().toLowerCase()
     if (!normalizedQuery) return []
 
-    const messages = await this.listMessages(toWorkstreamRef(params.workstreamId))
+    const messages = await this.listMessages(toThreadRef(params.threadId))
     return messages
       .filter((message) => message.role === params.role)
       .map((message) => ({
@@ -209,10 +209,10 @@ class WorkstreamMessageService {
 
   async addUserMessage(params: {
     messageId: RecordIdRef
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     content: string
   }): Promise<ChatMessage> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
+    const threadRef = toThreadRef(params.threadId)
     const message: ChatMessage = {
       id: toMessageId(params.messageId),
       role: 'user',
@@ -220,17 +220,17 @@ class WorkstreamMessageService {
       metadata: { createdAt: Date.now() },
     }
 
-    await this.upsertMessages({ workstreamId: workstreamRef, messages: [message] })
+    await this.upsertMessages({ threadId: threadRef, messages: [message] })
     return message
   }
 
   async addAgentMessage(params: {
     messageId: RecordIdRef
-    workstreamId: RecordIdRef
+    threadId: RecordIdRef
     parts: ChatMessage['parts']
     metadata?: ChatMessage['metadata']
   }): Promise<ChatMessage> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
+    const threadRef = toThreadRef(params.threadId)
     const message: ChatMessage = {
       id: toMessageId(params.messageId),
       role: 'assistant',
@@ -238,20 +238,16 @@ class WorkstreamMessageService {
       metadata: withCreatedAtMetadata(params.metadata, Date.now()),
     }
 
-    await this.upsertMessages({ workstreamId: workstreamRef, messages: [message] })
+    await this.upsertMessages({ threadId: threadRef, messages: [message] })
     return message
   }
 
-  async ensureBootstrapWelcomeMessage(params: {
-    workstreamId: RecordIdRef
-    agentId: string
-    text: string
-  }): Promise<void> {
-    const workstreamRef = toWorkstreamRef(params.workstreamId)
+  async ensureBootstrapWelcomeMessage(params: { threadId: RecordIdRef; agentId: string; text: string }): Promise<void> {
+    const threadRef = toThreadRef(params.threadId)
     const existingRow = await databaseService.findOne(
-      TABLES.WORKSTREAM_MESSAGE,
-      { workstreamId: workstreamRef },
-      WorkstreamMessageExistingRowSchema,
+      TABLES.THREAD_MESSAGE,
+      { threadId: threadRef },
+      ThreadMessageExistingRowSchema,
     )
     if (existingRow) return
 
@@ -259,7 +255,7 @@ class WorkstreamMessageService {
     if (!messageText) return
 
     await this.upsertMessages({
-      workstreamId: workstreamRef,
+      threadId: threadRef,
       messages: [
         {
           id: Bun.randomUUIDv7(),
@@ -276,4 +272,4 @@ class WorkstreamMessageService {
   }
 }
 
-export const workstreamMessageService = new WorkstreamMessageService()
+export const threadMessageService = new ThreadMessageService()

package/src/services/thread-plan-registry.service.ts

@@ -0,0 +1,22 @@
+import type { PlanRunRecord, SerializableExecutionPlan } from '@lota-sdk/shared'
+
+import type { RecordIdInput } from '../db/record-id'
+import { planRunService } from './plan-run.service'
+
+class ThreadPlanRegistryService {
+  async listActiveRuns(threadId: RecordIdInput): Promise<PlanRunRecord[]> {
+    return planRunService.getActiveRunRecords(threadId)
+  }
+
+  async countActiveRuns(threadId: RecordIdInput): Promise<number> {
+    const runs = await this.listActiveRuns(threadId)
+    return runs.length
+  }
+
+  async listActivePlans(threadId: RecordIdInput): Promise<SerializableExecutionPlan[]> {
+    const runs = await this.listActiveRuns(threadId)
+    return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run)))
+  }
+}
+
+export const threadPlanRegistryService = new ThreadPlanRegistryService()

package/src/services/thread-title.service.ts

@@ -0,0 +1,39 @@
+import { THREAD } from '@lota-sdk/shared'
+
+import { chatLogger } from '../config/logger'
+import type { RecordIdRef } from '../db/record-id'
+import { createHelperModelRuntime } from '../runtime/helper-model'
+import { deriveTitle, limitTitleWords, normalizeTitle } from '../runtime/title-helpers'
+import { createThreadTitleGeneratorAgent, THREAD_TITLE_GENERATOR_PROMPT } from '../system-agents/title-generator.agent'
+import { threadService } from './thread.service'
+
+const THREAD_TITLE_TIMEOUT_MS = 30_000
+
+class ThreadTitleService {
+  helperRuntime = createHelperModelRuntime()
+
+  async generateAndPersistTitle(threadId: RecordIdRef, sourceText: string): Promise<void> {
+    let title = ''
+    try {
+      title = normalizeTitle(
+        await this.helperRuntime.generateHelperText({
+          tag: 'thread-title',
+          createAgent: createThreadTitleGeneratorAgent,
+          defaultSystemPrompt: THREAD_TITLE_GENERATOR_PROMPT,
+          timeoutMs: THREAD_TITLE_TIMEOUT_MS,
+          messages: [{ role: 'user', content: sourceText }],
+        }),
+      )
+    } catch (error) {
+      chatLogger.warn`Failed to generate thread title via LLM (non-fatal): ${error}`
+    }
+
+    if (!title) {
+      title = limitTitleWords(deriveTitle(sourceText || THREAD.DEFAULT_TITLE))
+    }
+
+    await threadService.update(threadId, { title, nameGenerated: true })
+  }
+}
+
+export const threadTitleService = new ThreadTitleService()