@lota-sdk/core 0.1.14 → 0.1.16

package/src/services/workstream-message.service.ts

@@ -1,4 +1,6 @@
-import { parseRowMetadata, toTimestamp, withCreatedAtMetadata } from '@lota-sdk/shared'
+import { createHash } from 'node:crypto'
+
+import { parseRowMetadata, recordIdSchema, requireTimestamp, withCreatedAtMetadata } from '@lota-sdk/shared'
 import type { ChatMessage } from '@lota-sdk/shared'
 import { RecordId, surql } from 'surrealdb'
 import { z } from 'zod'
@@ -10,40 +12,33 @@ import { 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'
 
-const WorkstreamMessageRowSchema = z.object({
-  id: z.unknown(),
-  workstreamId: z.unknown(),
-  messageId: z.string(),
-  role: z.enum(['system', 'user', 'assistant']),
-  parts: z.array(z.record(z.string(), z.unknown())).optional(),
-  metadata: z.record(z.string(), z.unknown()).nullish(),
-  createdAt: z.union([z.date(), z.string(), z.number()]),
-  updatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
-})
-
-type WorkstreamMessageRow = z.infer<typeof WorkstreamMessageRowSchema>
-
-const WorkstreamMessageExistingRowSchema = z.object({
-  id: z.unknown(),
-  createdAt: z.union([z.date(), z.string(), z.number()]),
-})
+const WorkstreamMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
 
 function toMessageId(value: string | RecordIdRef): string {
   return recordIdToString(value, TABLES.WORKSTREAM_MESSAGE)
 }
 
+/**
+ * Builds a collision-free row id by hashing the workstream + 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 workstreamPart = recordIdToString(workstreamId, TABLES.WORKSTREAM).replace(/[^a-zA-Z0-9_-]/g, '_')
-  const messagePart = messageId.replace(/[^a-zA-Z0-9_-]/g, '_')
-  return new RecordId(TABLES.WORKSTREAM_MESSAGE, `${workstreamPart}__${messagePart}`)
+  const workstreamStr = recordIdToString(workstreamId, TABLES.WORKSTREAM)
+  const digest = createHash('sha256').update(`${workstreamStr}\0${messageId}`).digest('hex').slice(0, 32)
+  return new RecordId(TABLES.WORKSTREAM_MESSAGE, digest)
 }
 
 function toChatMessage(row: WorkstreamMessageRow): ChatMessage {
-  const rowCreatedAt = toTimestamp(row.createdAt)
+  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 }
+  return { id: row.messageId, role: row.role, parts: row.parts as ChatMessage['parts'], metadata }
 }
 
 const workstreamPaginationConfig: CursorPaginationConfig = {
@@ -74,16 +69,16 @@ class WorkstreamMessageService {
   async upsertMessages(params: { workstreamId: RecordIdRef; messages: ChatMessage[] }): Promise<void> {
     const workstreamId = params.workstreamId
 
-    for (const message of params.messages) {
+    const upsertPromises = params.messages.map(async (message) => {
       const messageId = message.id.trim()
-      if (!messageId) continue
+      if (!messageId) return
 
       const role = message.role
       const parts = Array.isArray(message.parts)
         ? message.parts.map((part) => structuredClone(part) as Record<string, unknown>)
         : []
       if (parts.length === 0) {
-        if (role === 'assistant') continue
+        if (role === 'assistant') return
         throw new Error(`Refusing to persist workstream message "${messageId}" with empty parts`)
       }
       const rowId = toWorkstreamMessageRowId(workstreamId, messageId)
@@ -93,7 +88,7 @@ class WorkstreamMessageService {
         WorkstreamMessageExistingRowSchema,
       )
       const persistedCreatedAt =
-        existingRow === null ? toTimestamp(message.metadata?.createdAt) : toTimestamp(existingRow.createdAt)
+        existingRow === null ? requireTimestamp(message.metadata?.createdAt) : requireTimestamp(existingRow.createdAt)
       const metadata = withCreatedAtMetadata({ ...message.metadata, createdAt: persistedCreatedAt })
 
       await databaseService.upsert(
@@ -105,12 +100,13 @@ class WorkstreamMessageService {
           role,
           parts,
           metadata,
-          createdAt: existingRow ? new Date(toTimestamp(existingRow.createdAt)) : new Date(persistedCreatedAt),
+          createdAt: existingRow ? existingRow.createdAt : new Date(persistedCreatedAt),
         },
         WorkstreamMessageRowSchema,
         { mutation: 'content' },
       )
-    }
+    })
+    await Promise.all(upsertPromises)
   }
 
   async listMessages(workstreamId: RecordIdRef): Promise<ChatMessage[]> {
@@ -138,7 +134,7 @@ class WorkstreamMessageService {
   async listMessagesAfterCursor(workstreamId: RecordIdRef, afterMessageId?: string): Promise<ChatMessage[]> {
     const cursorMessageId = afterMessageId?.trim()
     if (!cursorMessageId) {
-      return await this.listMessages(workstreamId)
+      return this.listMessages(workstreamId)
     }
 
     const cursorRow = await databaseService.findOne(
@@ -151,7 +147,7 @@ class WorkstreamMessageService {
       throw new Error(`Workstream cursor message not found: ${cursorMessageId}`)
     }
 
-    const cursorCreatedAt = new Date(toTimestamp(cursorRow.createdAt))
+    const cursorCreatedAt = cursorRow.createdAt
     const cursorId = toWorkstreamMessageRowId(workstreamId, cursorMessageId)
     const rows = await databaseService.query<unknown>(surql`
       SELECT * FROM workstreamMessage
@@ -195,7 +191,7 @@ class WorkstreamMessageService {
       .map((message) => ({
         id: message.id,
         role: message.role as 'user' | 'assistant',
-        createdAt: new Date(toTimestamp(message.metadata?.createdAt)).toISOString(),
+        createdAt: new Date(requireTimestamp(message.metadata?.createdAt)).toISOString(),
         content: message.parts
           .flatMap((part) => (part.type === 'text' && typeof part.text === 'string' ? [part.text] : []))
           .join('\n')
@@ -231,7 +227,7 @@ class WorkstreamMessageService {
       id: toMessageId(params.messageId),
       role: 'assistant',
       parts: params.parts,
-      metadata: withCreatedAtMetadata(params.metadata),
+      metadata: withCreatedAtMetadata(params.metadata, Date.now()),
     }
 
     await this.upsertMessages({ workstreamId: params.workstreamId, messages: [message] })
@@ -269,14 +265,6 @@ class WorkstreamMessageService {
       ],
     })
   }
-
-  async listAllMessages(workstreamId: RecordIdRef): Promise<ChatMessage[]> {
-    return await this.listMessages(workstreamId)
-  }
-
-  async addAttachments(): Promise<void> {
-    // Attachments are no longer persisted via workstreamMessage service in AI SDK mode.
-  }
 }
 
 export const workstreamMessageService = new WorkstreamMessageService()

package/src/services/workstream-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 WorkstreamPlanRegistryService {
+  async listActiveRuns(workstreamId: RecordIdInput): Promise<PlanRunRecord[]> {
+    return planRunService.getActiveRunRecords(workstreamId)
+  }
+
+  async countActiveRuns(workstreamId: RecordIdInput): Promise<number> {
+    const runs = await this.listActiveRuns(workstreamId)
+    return runs.length
+  }
+
+  async listActivePlans(workstreamId: RecordIdInput): Promise<SerializableExecutionPlan[]> {
+    const runs = await this.listActiveRuns(workstreamId)
+    return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run)))
+  }
+}
+
+export const workstreamPlanRegistryService = new WorkstreamPlanRegistryService()

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

@@ -3,20 +3,14 @@ import { WORKSTREAM } 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 } from '../runtime/title-helpers'
+import { deriveTitle, limitTitleWords, normalizeTitle } from '../runtime/title-helpers'
 import {
   createWorkstreamTitleGeneratorAgent,
   WORKSTREAM_TITLE_GENERATOR_PROMPT,
 } from '../system-agents/title-generator.agent'
-import { compactWhitespace } from '../utils/string'
 import { workstreamService } from './workstream.service'
 
-function normalizeTitle(value: string): string {
-  const normalized = compactWhitespace(value)
-    .replace(/^["'`]+|["'`]+$/g, '')
-    .replace(/[.!?,;:]+$/g, '')
-  return normalized.length <= 80 ? normalized : normalized.slice(0, 80).trim()
-}
+const WORKSTREAM_TITLE_TIMEOUT_MS = 5_000
 
 class WorkstreamTitleService {
   helperRuntime = createHelperModelRuntime()
@@ -29,7 +23,7 @@ class WorkstreamTitleService {
           tag: 'workstream-title',
           createAgent: createWorkstreamTitleGeneratorAgent,
           defaultSystemPrompt: WORKSTREAM_TITLE_GENERATOR_PROMPT,
-          timeoutMs: 30_000,
+          timeoutMs: WORKSTREAM_TITLE_TIMEOUT_MS,
           messages: [{ role: 'user', content: sourceText }],
         }),
       )