@lota-sdk/core 0.2.3 → 0.3.1

package/src/create-runtime.ts

@@ -4,7 +4,7 @@ import { configureEmbeddingCache } from './ai/embedding-cache'
 import { configureAgentFactory, configureAgents } from './config/agent-defaults'
 import { configureBackgroundProcessing } from './config/background-processing'
 import { configureLotaLogger } from './config/logger'
-import { configureWorkstreams } from './config/workstream-defaults'
+import { configureThreads } from './config/thread-defaults'
 import { ensureRecordId } from './db/record-id'
 import { computeSchemaFingerprint } from './db/schema-fingerprint'
 import { LOTA_SDK_DATABASE_NAME } from './db/sdk-database'
@@ -17,7 +17,7 @@ import { createRedisConnectionManager } from './redis/connection'
 import { setRedisConnectionManager } from './redis/index'
 import { closeSharedSubscriber } from './redis/stream-context'
 import type { isApprovalContinuationRequest } from './runtime/approval-continuation'
-import { routeWorkstreamChatMessages } from './runtime/chat-request-routing'
+import { routeThreadChatMessages } from './runtime/chat-request-routing'
 import { configureGraphDesigner } from './runtime/graph-designer'
 import type { LotaPlugin, SystemNodeExecutor } from './runtime/plugin-types'
 import { configureRuntimeConfig, LOTA_RUNTIME_ENV_KEYS, parseLotaRuntimeConfig } from './runtime/runtime-config'
@@ -57,41 +57,41 @@ import {
   socialChatHistoryService as socialChatHistoryServiceSingleton,
 } from './services/social-chat-history.service'
 import { getBuiltInSystemExecutors } from './services/system-executor.service'
-import type { userService } from './services/user.service'
-import { userService as userServiceSingleton } from './services/user.service'
-import type { workstreamMessageService } from './services/workstream-message.service'
-import { workstreamMessageService as workstreamMessageServiceSingleton } from './services/workstream-message.service'
-import type { workstreamTitleService } from './services/workstream-title.service'
-import { workstreamTitleService as workstreamTitleServiceSingleton } from './services/workstream-title.service'
+import type { threadMessageService } from './services/thread-message.service'
+import { threadMessageService as threadMessageServiceSingleton } from './services/thread-message.service'
+import type { threadTitleService } from './services/thread-title.service'
+import { threadTitleService as threadTitleServiceSingleton } from './services/thread-title.service'
 import type {
-  createWorkstreamApprovalContinuationStream,
-  createWorkstreamNativeToolApprovalStream,
-  createWorkstreamTurnStream,
-  runWorkstreamTurnInBackground,
+  createThreadApprovalContinuationStream,
+  createThreadNativeToolApprovalStream,
+  createThreadTurnStream,
+  runThreadTurnInBackground,
   triggerPlanNodeTurn,
-} from './services/workstream-turn'
+} from './services/thread-turn'
 import {
-  createWorkstreamApprovalContinuationStream as createWorkstreamApprovalContinuationStreamSingleton,
-  createWorkstreamNativeToolApprovalStream as createWorkstreamNativeToolApprovalStreamSingleton,
-  createWorkstreamTurnStream as createWorkstreamTurnStreamSingleton,
+  createThreadApprovalContinuationStream as createThreadApprovalContinuationStreamSingleton,
+  createThreadNativeToolApprovalStream as createThreadNativeToolApprovalStreamSingleton,
+  createThreadTurnStream as createThreadTurnStreamSingleton,
   isApprovalContinuationRequest as isApprovalContinuationRequestSingleton,
-  runWorkstreamTurnInBackground as runWorkstreamTurnInBackgroundSingleton,
+  runThreadTurnInBackground as runThreadTurnInBackgroundSingleton,
   triggerPlanNodeTurn as triggerPlanNodeTurnSingleton,
-} from './services/workstream-turn'
-import type { workstreamService } from './services/workstream.service'
-import { workstreamService as workstreamServiceSingleton } from './services/workstream.service'
+} from './services/thread-turn'
+import type { threadService } from './services/thread.service'
+import { threadService as threadServiceSingleton } from './services/thread.service'
+import type { userService } from './services/user.service'
+import { userService as userServiceSingleton } from './services/user.service'
 import type { generatedDocumentStorageService } from './storage/generated-document-storage.service'
 import { generatedDocumentStorageService as generatedDocumentStorageServiceSingleton } from './storage/generated-document-storage.service'
 
-type ArchiveSdkWorkstream = (
-  workstreamId: Parameters<typeof workstreamServiceSingleton.updateStatus>[0],
+type ArchiveSdkThread = (
+  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
   status?: 'archived',
-) => ReturnType<typeof workstreamServiceSingleton.updateStatus>
+) => ReturnType<typeof threadServiceSingleton.updateStatus>
 
-type UnarchiveSdkWorkstream = (
-  workstreamId: Parameters<typeof workstreamServiceSingleton.updateStatus>[0],
-  status?: 'regular',
-) => ReturnType<typeof workstreamServiceSingleton.updateStatus>
+type UnarchiveSdkThread = (
+  threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
+  status?: 'active',
+) => ReturnType<typeof threadServiceSingleton.updateStatus>
 
 let activeRuntimeToken: symbol | null = null
 
@@ -131,14 +131,14 @@ export interface LotaRuntime {
     socialChatHistoryService: typeof socialChatHistoryServiceSingleton
     executionPlanService: typeof executionPlanService
     planAgentQueryService: typeof planAgentQueryService
-    workstreamMessageService: typeof workstreamMessageService
-    workstreamService: typeof workstreamService
-    workstreamTitleService: typeof workstreamTitleService
-    createWorkstreamApprovalContinuationStream: typeof createWorkstreamApprovalContinuationStream
-    createWorkstreamNativeToolApprovalStream: typeof createWorkstreamNativeToolApprovalStream
-    createWorkstreamTurnStream: typeof createWorkstreamTurnStream
+    threadMessageService: typeof threadMessageService
+    threadService: typeof threadService
+    threadTitleService: typeof threadTitleService
+    createThreadApprovalContinuationStream: typeof createThreadApprovalContinuationStream
+    createThreadNativeToolApprovalStream: typeof createThreadNativeToolApprovalStream
+    createThreadTurnStream: typeof createThreadTurnStream
     isApprovalContinuationRequest: typeof isApprovalContinuationRequest
-    runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
+    runThreadTurnInBackground: typeof runThreadTurnInBackground
     triggerPlanNodeTurn: typeof triggerPlanNodeTurn
   }
   lota: {
@@ -164,32 +164,32 @@ export interface LotaRuntime {
       remove: typeof organizationMemberServiceSingleton.removeMembership
       isMember: typeof organizationMemberServiceSingleton.isMember
     }
-    workstreams: {
-      create: typeof workstreamServiceSingleton.createWorkstream
-      list: typeof workstreamServiceSingleton.listWorkstreams
-      get: typeof workstreamServiceSingleton.getWorkstream
-      update: typeof workstreamServiceSingleton.updateTitle
-      archive: ArchiveSdkWorkstream
-      unarchive: UnarchiveSdkWorkstream
-      delete: typeof workstreamServiceSingleton.deleteWorkstream
-      stop: typeof workstreamServiceSingleton.stopActiveRun
-      listMessages: typeof workstreamMessageServiceSingleton.listMessageHistoryPage
-      getMessage: (params: { workstreamId: string; messageId: string }) => Promise<ChatMessage>
+    threads: {
+      create: typeof threadServiceSingleton.createThread
+      list: typeof threadServiceSingleton.listThreads
+      get: typeof threadServiceSingleton.getThread
+      update: typeof threadServiceSingleton.updateTitle
+      archive: ArchiveSdkThread
+      unarchive: UnarchiveSdkThread
+      delete: typeof threadServiceSingleton.deleteThread
+      stop: typeof threadServiceSingleton.stopActiveRun
+      listMessages: typeof threadMessageServiceSingleton.listMessageHistoryPage
+      getMessage: (params: { threadId: string; messageId: string }) => Promise<ChatMessage>
       sendMessage: (params: {
-        workstreamId: string
+        threadId: string
         organizationId: string
         userId: string
         userName: string
-        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
-      }) => Promise<Awaited<ReturnType<typeof createWorkstreamTurnStream>>>
+        messages: Parameters<typeof routeThreadChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createThreadTurnStream>>>
       continueApproval: (params: {
-        workstreamId: string
+        threadId: string
         organizationId: string
         userId: string
         userName: string
-        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
-      }) => Promise<Awaited<ReturnType<typeof createWorkstreamApprovalContinuationStream>>>
-      uploadAttachment: typeof attachmentServiceSingleton.uploadWorkstreamAttachment
+        messages: Parameters<typeof routeThreadChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createThreadApprovalContinuationStream>>>
+      uploadAttachment: typeof attachmentServiceSingleton.uploadThreadAttachment
     }
   }
   redis: {
@@ -253,7 +253,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       descriptions: runtimeConfig.agents.descriptions,
       routerModelId: runtimeConfig.agents.routerModelId,
       teamConsultParticipants: runtimeConfig.agents.teamConsultParticipants,
-      getCoreWorkstreamProfile: runtimeConfig.agents.getCoreWorkstreamProfile,
+      getCoreThreadProfile: runtimeConfig.agents.getCoreThreadProfile,
     })
     configureAgentFactory({
       createAgent: runtimeConfig.agents.createAgent,
@@ -261,7 +261,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       getAgentRuntimeConfig: runtimeConfig.agents.getAgentRuntimeConfig,
       pluginRuntime: runtimeConfig.pluginRuntime,
     })
-    configureWorkstreams({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.workstreams })
+    configureThreads({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.threads })
     configureNotificationService(runtimeConfig.notificationService ?? null)
     configureRuntimeExtensions({
       adapters: runtimeConfig.runtimeAdapters,
@@ -311,65 +311,61 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         remove: organizationMemberServiceSingleton.removeMembership.bind(organizationMemberServiceSingleton),
         isMember: organizationMemberServiceSingleton.isMember.bind(organizationMemberServiceSingleton),
       },
-      workstreams: {
-        create: workstreamServiceSingleton.createWorkstream.bind(workstreamServiceSingleton),
-        list: workstreamServiceSingleton.listWorkstreams.bind(workstreamServiceSingleton),
-        get: workstreamServiceSingleton.getWorkstream.bind(workstreamServiceSingleton),
-        update: workstreamServiceSingleton.updateTitle.bind(workstreamServiceSingleton),
-        archive: async (workstreamId, status = 'archived') =>
-          await workstreamServiceSingleton.updateStatus(workstreamId, status),
-        unarchive: async (workstreamId, status = 'regular') =>
-          await workstreamServiceSingleton.updateStatus(workstreamId, status),
-        delete: workstreamServiceSingleton.deleteWorkstream.bind(workstreamServiceSingleton),
-        stop: workstreamServiceSingleton.stopActiveRun.bind(workstreamServiceSingleton),
-        listMessages: workstreamMessageServiceSingleton.listMessageHistoryPage.bind(workstreamMessageServiceSingleton),
-        getMessage: async ({ workstreamId, messageId }) => {
-          const messages = await workstreamMessageServiceSingleton.listMessages(
-            ensureRecordId(workstreamId, TABLES.WORKSTREAM),
-          )
+      threads: {
+        create: threadServiceSingleton.createThread.bind(threadServiceSingleton),
+        list: threadServiceSingleton.listThreads.bind(threadServiceSingleton),
+        get: threadServiceSingleton.getThread.bind(threadServiceSingleton),
+        update: threadServiceSingleton.updateTitle.bind(threadServiceSingleton),
+        archive: async (threadId, status = 'archived') => await threadServiceSingleton.updateStatus(threadId, status),
+        unarchive: async (threadId, status = 'active') => await threadServiceSingleton.updateStatus(threadId, status),
+        delete: threadServiceSingleton.deleteThread.bind(threadServiceSingleton),
+        stop: threadServiceSingleton.stopActiveRun.bind(threadServiceSingleton),
+        listMessages: threadMessageServiceSingleton.listMessageHistoryPage.bind(threadMessageServiceSingleton),
+        getMessage: async ({ threadId, messageId }) => {
+          const messages = await threadMessageServiceSingleton.listMessages(ensureRecordId(threadId, TABLES.THREAD))
           const message = messages.find((candidate) => candidate.id === messageId)
           if (!message) {
-            throw new Error(`Workstream message not found: ${messageId}`)
+            throw new Error(`Thread message not found: ${messageId}`)
           }
           return message
         },
-        sendMessage: async ({ workstreamId, organizationId, userId, userName, messages }) => {
-          const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-          const workstream = await workstreamServiceSingleton.getWorkstream(workstreamRef)
-          const routed = routeWorkstreamChatMessages(messages)
+        sendMessage: async ({ threadId, organizationId, userId, userName, messages }) => {
+          const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+          const thread = await threadServiceSingleton.getThread(threadRef)
+          const routed = routeThreadChatMessages(messages)
           if (routed.kind !== 'turn') {
             throw new Error(routed.kind === 'invalid' ? routed.message : 'Expected a user turn payload.')
           }
 
-          return createWorkstreamTurnStreamSingleton({
-            workstream,
-            workstreamRef,
+          return createThreadTurnStreamSingleton({
+            thread,
+            threadRef,
             orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
             userRef: ensureRecordId(userId, TABLES.USER),
             userName,
             inputMessage: routed.inputMessage,
           })
         },
-        continueApproval: async ({ workstreamId, organizationId, userId, userName, messages }) => {
-          const workstreamRef = ensureRecordId(workstreamId, TABLES.WORKSTREAM)
-          const workstream = await workstreamServiceSingleton.getWorkstream(workstreamRef)
-          const routed = routeWorkstreamChatMessages(messages)
+        continueApproval: async ({ threadId, organizationId, userId, userName, messages }) => {
+          const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+          const thread = await threadServiceSingleton.getThread(threadRef)
+          const routed = routeThreadChatMessages(messages)
           if (routed.kind !== 'approval-continuation') {
             throw new Error(
               routed.kind === 'invalid' ? routed.message : 'Expected approval continuation messages payload.',
             )
           }
 
-          return createWorkstreamApprovalContinuationStreamSingleton({
-            workstream,
-            workstreamRef,
+          return createThreadApprovalContinuationStreamSingleton({
+            thread,
+            threadRef,
             orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
             userRef: ensureRecordId(userId, TABLES.USER),
             userName,
             approvalMessages: routed.approvalMessages,
           })
         },
-        uploadAttachment: attachmentServiceSingleton.uploadWorkstreamAttachment.bind(attachmentServiceSingleton),
+        uploadAttachment: attachmentServiceSingleton.uploadThreadAttachment.bind(attachmentServiceSingleton),
       },
     } satisfies LotaRuntime['lota']
 
@@ -395,14 +391,14 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         socialChatHistoryService: socialChatHistoryServiceSingleton,
         executionPlanService: executionPlanServiceSingleton,
         planAgentQueryService: planAgentQueryServiceSingleton,
-        workstreamMessageService: workstreamMessageServiceSingleton,
-        workstreamService: workstreamServiceSingleton,
-        workstreamTitleService: workstreamTitleServiceSingleton,
-        createWorkstreamApprovalContinuationStream: createWorkstreamApprovalContinuationStreamSingleton,
-        createWorkstreamNativeToolApprovalStream: createWorkstreamNativeToolApprovalStreamSingleton,
-        createWorkstreamTurnStream: createWorkstreamTurnStreamSingleton,
+        threadMessageService: threadMessageServiceSingleton,
+        threadService: threadServiceSingleton,
+        threadTitleService: threadTitleServiceSingleton,
+        createThreadApprovalContinuationStream: createThreadApprovalContinuationStreamSingleton,
+        createThreadNativeToolApprovalStream: createThreadNativeToolApprovalStreamSingleton,
+        createThreadTurnStream: createThreadTurnStreamSingleton,
         isApprovalContinuationRequest: isApprovalContinuationRequestSingleton,
-        runWorkstreamTurnInBackground: runWorkstreamTurnInBackgroundSingleton,
+        runThreadTurnInBackground: runThreadTurnInBackgroundSingleton,
         triggerPlanNodeTurn: triggerPlanNodeTurnSingleton,
       },
       lota,
@@ -456,7 +452,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
 function getBuiltInSchemaFiles(): URL[] {
   return [
     new URL('../infrastructure/schema/00_identity.surql', import.meta.url),
-    new URL('../infrastructure/schema/00_workstream.surql', import.meta.url),
+    new URL('../infrastructure/schema/00_thread.surql', import.meta.url),
     new URL('../infrastructure/schema/01_memory.surql', import.meta.url),
     new URL('../infrastructure/schema/02_execution_plan.surql', import.meta.url),
     new URL('../infrastructure/schema/03_learned_skill.surql', import.meta.url),

package/src/db/record-id.ts

@@ -8,13 +8,18 @@ export interface RecordIdShape {
   id: RecordIdValue
 }
 
-export interface StringableRecordId {
+export type RecordIdInput = string | RecordId | StringRecordId | RecordIdShape
+export type RecordIdRef = RecordIdInput
+
+const SURREAL_RECORD_ID_CLASS_NAMES = new Set(['RecordId', 'StringRecordId'])
+
+interface SurrealRecordIdLike {
   toString(): string
 }
 
-export type RecordIdInput = string | RecordId | StringRecordId | RecordIdShape | StringableRecordId
-
-export type RecordIdRef = RecordIdInput
+interface NamedConstructor {
+  name?: unknown
+}
 
 class InvalidRecordIdError extends BadRequestError {
   constructor(message: string) {
@@ -23,18 +28,18 @@ class InvalidRecordIdError extends BadRequestError {
   }
 }
 
-export function readCustomStringValue(value: object): string | null {
-  const toStringValue: unknown = Reflect.get(value, 'toString')
-  if (typeof toStringValue !== 'function' || toStringValue === Object.prototype.toString) {
-    return null
+export function isSurrealRecordIdValue(value: unknown): boolean {
+  if (!value || typeof value !== 'object') {
+    return false
   }
 
-  const stringValue = Reflect.apply(toStringValue as (this: object) => unknown, value, [])
-  if (typeof stringValue !== 'string' || stringValue.length === 0) {
-    return null
+  const constructor = (value as { constructor?: unknown }).constructor
+  if (typeof constructor !== 'function') {
+    return false
   }
 
-  return stringValue
+  const constructorName = (constructor as NamedConstructor).name
+  return typeof constructorName === 'string' && SURREAL_RECORD_ID_CLASS_NAMES.has(constructorName)
 }
 
 export function ensureRecordId(value: RecordIdInput, fallbackTable?: string): RecordId {
@@ -42,8 +47,8 @@ export function ensureRecordId(value: RecordIdInput, fallbackTable?: string): Re
     return value
   }
 
-  if (value instanceof StringRecordId) {
-    return ensureRecordId(value.toString(), fallbackTable)
+  if (value instanceof StringRecordId || isSurrealRecordIdValue(value)) {
+    return ensureRecordId((value as SurrealRecordIdLike).toString(), fallbackTable)
   }
 
   if (typeof value === 'string') {
@@ -58,16 +63,11 @@ export function ensureRecordId(value: RecordIdInput, fallbackTable?: string): Re
     return new RecordId(fallbackTable, value)
   }
 
-  if (typeof value === 'object') {
+  if (typeof value === 'object' && Object.keys(value).length === 2) {
     const record = value as { tb?: string; id?: RecordIdValue }
-    if (record.tb && record.id !== undefined) {
+    if (typeof record.tb === 'string' && record.id !== undefined) {
       return new RecordId(record.tb, record.id)
     }
-
-    const stringValue = readCustomStringValue(value)
-    if (stringValue && stringValue !== '[object Object]') {
-      return ensureRecordId(stringValue, fallbackTable)
-    }
   }
 
   throw new InvalidRecordIdError('Invalid record id value')

package/src/db/service.ts

@@ -16,7 +16,7 @@ import { serverLogger } from '../config/logger'
 import { withTimeout } from '../utils/async'
 import { isRecord } from '../utils/string'
 import type { RecordIdInput } from './record-id'
-import { ensureRecordId, readCustomStringValue } from './record-id'
+import { ensureRecordId, isSurrealRecordIdValue } from './record-id'
 import type { DatabaseTable } from './tables'
 
 export class SurrealDBError extends Error {
@@ -103,19 +103,6 @@ function isBoundQueryLike(value: unknown): value is BoundQueryLike {
   return value.bindings === undefined || isRecord(value.bindings)
 }
 
-function toStringLikeValue(value: unknown): string | null {
-  if (!value || typeof value !== 'object') {
-    return null
-  }
-
-  const stringValue = readCustomStringValue(value)
-  if (typeof stringValue !== 'string' || stringValue.length === 0 || stringValue === '[object Object]') {
-    return null
-  }
-
-  return stringValue
-}
-
 const CONNECT_MAX_ATTEMPTS = 5
 const CONNECT_RETRY_BASE_DELAY_MS = 100
 const CONNECT_RETRY_JITTER_MS = 50
@@ -353,6 +340,10 @@ export class SurrealDBService {
       return value.map((entry) => this.normalizeParseValue(entry))
     }
 
+    if (isSurrealRecordIdValue(value)) {
+      return ensureRecordId(value as RecordIdInput)
+    }
+
     if (!isRecord(value)) {
       return value
     }
@@ -413,10 +404,6 @@ export class SurrealDBService {
     return new BoundQuery(query.query, this.normalizeBindings(query.bindings))
   }
 
-  private isSerializedRecordId(value: string): boolean {
-    return /^[a-zA-Z][a-zA-Z0-9_]*:(?:⟨.+⟩|.+)$/.test(value)
-  }
-
   private normalizeRuntimeValue(value: unknown): unknown {
     if (value === null || value === undefined) {
       return value
@@ -435,17 +422,16 @@ export class SurrealDBService {
       return value.map((entry) => this.normalizeRuntimeValue(entry))
     }
 
+    if (isSurrealRecordIdValue(value)) {
+      return ensureRecordId(value as RecordIdInput)
+    }
+
     if (!isRecord(value)) {
       return value
     }
 
     if ('tb' in value && 'id' in value && Object.keys(value).length === 2) {
-      return ensureRecordId(value as RecordIdInput)
-    }
-
-    const stringValue = toStringLikeValue(value)
-    if (stringValue && this.isSerializedRecordId(stringValue)) {
-      return ensureRecordId(stringValue)
+      return ensureRecordId(value as unknown as RecordIdInput)
     }
 
     const entries = Object.entries(value)
@@ -467,17 +453,23 @@ export class SurrealDBService {
   }
 
   private normalizeMutationFieldValue(value: unknown): unknown {
-    if (value === null || value === undefined) {
+    if (value === undefined) {
       return undefined
     }
 
+    if (value === null) {
+      return null
+    }
+
     return this.normalizeRuntimeValue(value)
   }
 
   // Cast is safe: normalizeRuntimeValue preserves Record shape when input is a Record
   private normalizeMutationData(data: Record<string, unknown>): Record<string, unknown> {
     return Object.fromEntries(
-      Object.entries(data).map(([key, value]) => [key, this.normalizeMutationFieldValue(value)]),
+      Object.entries(data)
+        .map(([key, value]) => [key, this.normalizeMutationFieldValue(value)] as const)
+        .filter((entry): entry is readonly [string, unknown] => entry[1] !== undefined),
     ) as Record<string, unknown>
   }
 
@@ -490,11 +482,6 @@ export class SurrealDBService {
       return new Table(value)
     }
 
-    const stringValue = toStringLikeValue(value)
-    if (stringValue) {
-      return new Table(stringValue)
-    }
-
     throw new SurrealDBError('Invalid table value')
   }
 
@@ -503,20 +490,17 @@ export class SurrealDBService {
       return true
     }
 
+    if (isSurrealRecordIdValue(value)) {
+      return true
+    }
+
     if (typeof value === 'string') {
       return /^[a-zA-Z][a-zA-Z0-9_]*:/.test(value)
     }
 
     if (value && typeof value === 'object') {
       const record = value as { tb?: unknown; id?: unknown }
-      if (typeof record.tb === 'string' && record.id !== undefined && Object.keys(value).length === 2) {
-        return true
-      }
-
-      const stringValue = toStringLikeValue(value)
-      if (stringValue) {
-        return /^[a-zA-Z][a-zA-Z0-9_]*:/.test(stringValue)
-      }
+      return typeof record.tb === 'string' && record.id !== undefined && Object.keys(value).length === 2
     }
 
     return false
@@ -689,7 +673,11 @@ export class SurrealDBService {
       for (const key of filterKeys) {
         this.assertValidIdentifier(key, 'filter field')
       }
-      const orderDir = options?.orderDir ?? 'ASC'
+      const rawOrderDir: unknown = options?.orderDir
+      if (rawOrderDir !== undefined && rawOrderDir !== 'ASC' && rawOrderDir !== 'DESC') {
+        throw new SurrealDBError(`Invalid orderDir value: ${this.describeInvalidValue(rawOrderDir)}`)
+      }
+      const orderDir = rawOrderDir ?? 'ASC'
       const limit = options?.limit
       const offset = options?.offset
       const vars: Record<string, unknown> = this.normalizeMutationData(filter)
@@ -730,6 +718,22 @@ export class SurrealDBService {
     }
   }
 
+  private describeInvalidValue(value: unknown): string {
+    if (typeof value === 'string') {
+      return value
+    }
+
+    try {
+      const serialized = JSON.stringify(value)
+      if (typeof serialized === 'string') {
+        return serialized
+      }
+      return Object.prototype.toString.call(value)
+    } catch {
+      return Object.prototype.toString.call(value)
+    }
+  }
+
   async create<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     data: Record<string, unknown>,

package/src/db/tables.ts

@@ -1,8 +1,8 @@
 export const TABLES = {
-  WORKSTREAM_MESSAGE: 'workstreamMessage',
-  WORKSTREAM: 'workstream',
+  THREAD: 'thread',
+  THREAD_MESSAGE: 'threadMessage',
+  THREAD_ATTACHMENT: 'threadAttachment',
   RUNTIME_BOOTSTRAP: 'runtimeBootstrap',
-  WORKSTREAM_ATTACHMENT: 'workstreamAttachment',
   MEMORY: 'memory',
   MEMORY_RELATION: 'memoryRelation',
   MEMORY_HISTORY: 'memoryHistory',

package/src/db/{workstream-message-row.ts → thread-message-row.ts}

@@ -1,9 +1,9 @@
 import { recordIdSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
-export const WorkstreamMessageRowSchema = z.object({
+export const ThreadMessageRowSchema = z.object({
   id: recordIdSchema,
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   messageId: z.string(),
   role: z.enum(['system', 'user', 'assistant']),
   parts: z.array(z.record(z.string(), z.unknown())).optional(),
@@ -12,4 +12,4 @@ export const WorkstreamMessageRowSchema = z.object({
   updatedAt: z.coerce.date().optional(),
 })
 
-export type WorkstreamMessageRow = z.infer<typeof WorkstreamMessageRowSchema>
+export type ThreadMessageRow = z.infer<typeof ThreadMessageRowSchema>

package/src/queues/context-compaction.queue.ts

@@ -4,11 +4,11 @@ import { ensureRecordId } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { contextCompactionService } from '../services/context-compaction.service'
-import { workstreamService } from '../services/workstream.service'
+import { threadService } from '../services/thread.service'
 import { createQueueFactory } from './queue-factory'
 
 interface ContextCompactionJob {
-  domain: 'workstream'
+  domain: 'thread'
   entityId: string
   contextSize?: number
 }
@@ -17,12 +17,12 @@ async function processContextCompactionJob(job: Job<ContextCompactionJob>): Prom
   await databaseService.connect()
 
   const { entityId, contextSize } = job.data
-  const workstreamRef = ensureRecordId(entityId, TABLES.WORKSTREAM)
-  await workstreamService.setCompacting(workstreamRef, true)
+  const threadRef = ensureRecordId(entityId, TABLES.THREAD)
+  await threadService.setCompacting(threadRef, true)
   try {
-    await contextCompactionService.compactWorkstreamHistory({ workstreamId: workstreamRef, contextSize })
+    await contextCompactionService.compactThreadHistory({ threadId: threadRef, contextSize })
   } finally {
-    await workstreamService.setCompacting(workstreamRef, false)
+    await threadService.setCompacting(threadRef, false)
   }
 }
 

package/src/queues/plan-agent-heartbeat.queue.ts

@@ -10,7 +10,7 @@ import { createQueueFactory } from './queue-factory'
 export interface PlanAgentHeartbeatWakeJob {
   type: 'wake-node'
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string
@@ -58,7 +58,7 @@ const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
 
 function buildWakeJobId(params: {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string
@@ -70,7 +70,7 @@ function buildWakeJobId(params: {
 
 export async function enqueuePlanAgentHeartbeatWake(params: {
   organizationId: string
-  workstreamId: string
+  threadId: string
   runId: string
   nodeId: string
   agentId: string

package/src/queues/post-chat-memory.queue.ts

@@ -13,7 +13,7 @@ interface PostChatMemoryMessage {
 
 interface PostChatMemoryExtractionJob {
   orgId: string
-  workstreamId: string
+  threadId: string
   sourceId: string
   source?: string
   sourceMetadata?: Record<string, unknown>