@lota-sdk/core 0.1.14 → 0.1.16

package/src/config/logger.ts

@@ -1,7 +1,9 @@
 import type { LogLevel } from '@logtape/logtape'
 import { configure, getAnsiColorFormatter, getConsoleSink, getLogger as getLogTapeLogger } from '@logtape/logtape'
 
-export async function configureLotaLogger(logLevel: LogLevel): Promise<void> {
+const LOG_CATEGORY = 'lota-sdk'
+
+export async function configureLotaLogger(logLevel: LogLevel = 'info'): Promise<void> {
   const formatter = getAnsiColorFormatter({ level: 'FULL' })
 
   await configure({
@@ -10,7 +12,7 @@ export async function configureLotaLogger(logLevel: LogLevel): Promise<void> {
     loggers: [
       { category: ['logtape', 'meta'], lowestLevel: 'warning', sinks: ['console'] },
       { category: ['server'], lowestLevel: logLevel, sinks: ['console'] },
-      { category: ['lota-sdk'], lowestLevel: logLevel, sinks: ['console'] },
+      { category: [LOG_CATEGORY], lowestLevel: logLevel, sinks: ['console'] },
       { category: ['hono'], lowestLevel: logLevel, sinks: ['console'] },
     ],
   })
@@ -20,10 +22,6 @@ export function getLogger(category: readonly string[]) {
   return getLogTapeLogger([...category])
 }
 
-export async function configureLogger(logLevel?: LogLevel): Promise<void> {
-  await configureLotaLogger(logLevel ?? 'info')
-}
-
-export const serverLogger = getLogger(['lota-sdk'])
-export const chatLogger = getLogger(['lota-sdk', 'chat'])
-export const aiLogger = getLogger(['lota-sdk', 'ai'])
+export const serverLogger = getLogger([LOG_CATEGORY])
+export const chatLogger = getLogger([LOG_CATEGORY, 'chat'])
+export const aiLogger = getLogger([LOG_CATEGORY, 'ai'])

package/src/config/model-constants.ts

@@ -1,34 +1,16 @@
-export const OPENAI_REASONING_MODEL_ID = 'openai/gpt-5.4' as const
-
-export const OPENROUTER_TEAM_AGENT_MODEL_ID = 'openrouter/google/gemini-3.1-pro-preview' as const
-export const OPENROUTER_STRUCTURED_HELPER_MODEL_ID = 'openrouter/google/gemini-3-flash-preview:exacto' as const
-export const OPENROUTER_DELEGATED_REASONING_MODEL_ID = 'openrouter/google/gemini-3-flash-preview:exacto' as const
-export const OPENROUTER_WEB_RESEARCH_MODEL_ID = 'openrouter/stepfun/step-3.5-flash' as const
-export const OPENROUTER_FAST_REASONING_MODEL_ID = 'openrouter/openai/gpt-oss-120b:nitro' as const
-export const OPENROUTER_STRUCTURED_REASONING_MODEL_ID = 'openrouter/openai/gpt-oss-120b:exacto' as const
-
-export const BIFROST_REASONING_SUMMARY_LEVEL = 'detailed' as const
-
-export const OPENAI_HIGH_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
-} as const
-
-export const OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
-} as const
-
-export const OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'xhigh', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
-} as const
-
-export const OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'medium', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
-} as const
-
-export const OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'low', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
-} as const
-
-export const OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'minimal', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
-} as const
+export {
+  BIFROST_REASONING_SUMMARY_LEVEL,
+  OPENAI_HIGH_REASONING_PROVIDER_OPTIONS,
+  OPENAI_REASONING_MODEL_ID,
+  OPENROUTER_DELEGATED_REASONING_MODEL_ID,
+  OPENROUTER_FAST_REASONING_MODEL_ID,
+  OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+  OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
+  OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
+  OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
+  OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
+  OPENROUTER_STRUCTURED_REASONING_MODEL_ID,
+  OPENROUTER_TEAM_AGENT_MODEL_ID,
+  OPENROUTER_WEB_RESEARCH_MODEL_ID,
+  OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS,
+} from '@lota-sdk/shared'

package/src/config/search.ts

@@ -1,17 +1,3 @@
-/**
- * Search-related constants for vector search and hybrid search
- */
+export { VECTOR_SEARCH_OVERFETCH_MULTIPLIER } from '@lota-sdk/shared'
 
-/**
- * Multiplier for vector search fetch limit.
- * We fetch more candidates than needed (limit * multiplier) to allow for:
- * - RRF (Reciprocal Rank Fusion) re-ranking
- * - Hybrid search combining vector + full-text results
- * - Filtering out low-quality matches before returning final results
- */
-export const VECTOR_SEARCH_OVERFETCH_MULTIPLIER = 2
-
-/**
- * Default limit for memory search queries
- */
 export const DEFAULT_MEMORY_SEARCH_LIMIT = 10

package/src/create-runtime.ts

@@ -0,0 +1,453 @@
+import type { ChatMessage } from '@lota-sdk/shared'
+
+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 { ensureRecordId } from './db/record-id'
+import { computeSchemaFingerprint } from './db/schema-fingerprint'
+import { LOTA_SDK_DATABASE_NAME } from './db/sdk-database'
+import type { SurrealDBService } from './db/service'
+import { SurrealDBService as SurrealDBServiceClass, setDatabaseService } from './db/service'
+import { publishDatabaseBootstrap } from './db/startup'
+import { TABLES } from './db/tables'
+import type { RedisConnectionManager } from './redis/connection'
+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 { configureGraphDesigner } from './runtime/graph-designer'
+import type { LotaPlugin, SystemNodeExecutor } from './runtime/plugin-types'
+import { configureRuntimeConfig, LOTA_RUNTIME_ENV_KEYS, parseLotaRuntimeConfig } from './runtime/runtime-config'
+import type { LotaRuntimeConfig, ResolvedLotaRuntimeConfig } from './runtime/runtime-config'
+import { configureRuntimeExtensions } from './runtime/runtime-extensions'
+import type { LotaRuntimeWorkers } from './runtime/runtime-worker-registry'
+import { buildRuntimeWorkerRegistry } from './runtime/runtime-worker-registry'
+import type { attachmentService } from './services/attachment.service'
+import { attachmentService as attachmentServiceSingleton } from './services/attachment.service'
+import { coordinationRegistryService as coordinationRegistryServiceSingleton } from './services/coordination-registry.service'
+import type { documentChunkService } from './services/document-chunk.service'
+import { documentChunkService as documentChunkServiceSingleton } from './services/document-chunk.service'
+import { domainAgentExecutorService } from './services/domain-agent-executor.service'
+import type { executionPlanService } from './services/execution-plan.service'
+import { executionPlanService as executionPlanServiceSingleton } from './services/execution-plan.service'
+import type { memoryService } from './services/memory.service'
+import { memoryService as memoryServiceSingleton } from './services/memory.service'
+import type { verifyMutatingApproval } from './services/mutating-approval.service'
+import { verifyMutatingApproval as verifyMutatingApprovalSingleton } from './services/mutating-approval.service'
+import { configureNotificationService } from './services/notification.service'
+import type { organizationMemberService } from './services/organization-member.service'
+import { organizationMemberService as organizationMemberServiceSingleton } from './services/organization-member.service'
+import type { organizationService } from './services/organization.service'
+import { organizationService as organizationServiceSingleton } from './services/organization.service'
+import { playbookRegistryService } from './services/playbook-registry.service'
+import type { recentActivityTitleService } from './services/recent-activity-title.service'
+import { recentActivityTitleService as recentActivityTitleServiceSingleton } from './services/recent-activity-title.service'
+import type { recentActivityService } from './services/recent-activity.service'
+import { recentActivityService as recentActivityServiceSingleton } from './services/recent-activity.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 {
+  createWorkstreamApprovalContinuationStream,
+  createWorkstreamNativeToolApprovalStream,
+  createWorkstreamTurnStream,
+  runWorkstreamTurnInBackground,
+} from './services/workstream-turn'
+import {
+  createWorkstreamApprovalContinuationStream as createWorkstreamApprovalContinuationStreamSingleton,
+  createWorkstreamNativeToolApprovalStream as createWorkstreamNativeToolApprovalStreamSingleton,
+  createWorkstreamTurnStream as createWorkstreamTurnStreamSingleton,
+  isApprovalContinuationRequest as isApprovalContinuationRequestSingleton,
+  runWorkstreamTurnInBackground as runWorkstreamTurnInBackgroundSingleton,
+} from './services/workstream-turn'
+import type { workstreamService } from './services/workstream.service'
+import { workstreamService as workstreamServiceSingleton } from './services/workstream.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],
+  status?: 'archived',
+) => ReturnType<typeof workstreamServiceSingleton.updateStatus>
+
+type UnarchiveSdkWorkstream = (
+  workstreamId: Parameters<typeof workstreamServiceSingleton.updateStatus>[0],
+  status?: 'regular',
+) => ReturnType<typeof workstreamServiceSingleton.updateStatus>
+
+let activeRuntimeToken: symbol | null = null
+
+function claimRuntimeToken(): symbol {
+  if (activeRuntimeToken) {
+    throw new Error('createLotaRuntime() is process-scoped. Disconnect the active runtime before creating another one.')
+  }
+
+  const token = Symbol('lota-runtime')
+  activeRuntimeToken = token
+  return token
+}
+
+function releaseRuntimeToken(token: symbol) {
+  if (activeRuntimeToken === token) {
+    activeRuntimeToken = null
+  }
+}
+
+export interface LotaRuntime {
+  services: {
+    database: SurrealDBService
+    redis: RedisConnectionManager
+    closeRedisConnection: () => Promise<void>
+    attachmentService: typeof attachmentService
+    documentChunkService: typeof documentChunkService
+    generatedDocumentStorageService: typeof generatedDocumentStorageService
+    memoryService: typeof memoryService
+    verifyMutatingApproval: typeof verifyMutatingApproval
+    organizationService: typeof organizationService
+    organizationMemberService: typeof organizationMemberService
+    userService: typeof userService
+    recentActivityService: typeof recentActivityService
+    recentActivityTitleService: typeof recentActivityTitleService
+    executionPlanService: typeof executionPlanService
+    workstreamMessageService: typeof workstreamMessageService
+    workstreamService: typeof workstreamService
+    workstreamTitleService: typeof workstreamTitleService
+    createWorkstreamApprovalContinuationStream: typeof createWorkstreamApprovalContinuationStream
+    createWorkstreamNativeToolApprovalStream: typeof createWorkstreamNativeToolApprovalStream
+    createWorkstreamTurnStream: typeof createWorkstreamTurnStream
+    isApprovalContinuationRequest: typeof isApprovalContinuationRequest
+    runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
+    syncPlaybookTemplates: typeof playbookRegistryService.syncPlaybookTemplates
+  }
+  lota: {
+    organizations: {
+      create: typeof organizationServiceSingleton.createOrganization
+      upsert: typeof organizationServiceSingleton.upsertOrganization
+      get: typeof organizationServiceSingleton.getOrganization
+      list: typeof organizationServiceSingleton.listOrganizations
+      update: typeof organizationServiceSingleton.updateOrganization
+      delete: typeof organizationServiceSingleton.deleteOrganization
+    }
+    users: {
+      upsert: typeof userServiceSingleton.upsertUser
+      get: typeof userServiceSingleton.getUser
+      list: typeof userServiceSingleton.listUsers
+      update: typeof userServiceSingleton.updateUser
+      delete: typeof userServiceSingleton.deleteUser
+    }
+    memberships: {
+      add: typeof organizationMemberServiceSingleton.addMembership
+      listForOrganization: typeof organizationMemberServiceSingleton.listMembershipsForOrganization
+      listForUser: typeof organizationMemberServiceSingleton.listMembershipsForUser
+      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>
+      sendMessage: (params: {
+        workstreamId: string
+        organizationId: string
+        userId: string
+        userName: string
+        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createWorkstreamTurnStream>>>
+      continueApproval: (params: {
+        workstreamId: string
+        organizationId: string
+        userId: string
+        userName: string
+        messages: Parameters<typeof routeWorkstreamChatMessages>[0]
+      }) => Promise<Awaited<ReturnType<typeof createWorkstreamApprovalContinuationStream>>>
+      uploadAttachment: typeof attachmentServiceSingleton.uploadWorkstreamAttachment
+    }
+  }
+  redis: {
+    manager: RedisConnectionManager
+    getConnection: () => ReturnType<RedisConnectionManager['getConnection']>
+    getConnectionForBullMQ: () => ReturnType<RedisConnectionManager['getConnectionForBullMQ']>
+    closeConnection: () => Promise<void>
+  }
+  workers: LotaRuntimeWorkers
+  schemaFiles: Array<string | URL>
+  contributions: { envKeys: readonly string[]; schemaFiles: Array<string | URL> }
+  config: ResolvedLotaRuntimeConfig
+  plugins: Record<string, LotaPlugin>
+  systemExecutors: Record<string, SystemNodeExecutor>
+  connectPluginDatabases(): Promise<void>
+  connect(): Promise<void>
+  disconnect(): Promise<void>
+}
+
+export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
+  const runtimeToken = claimRuntimeToken()
+
+  try {
+    const resolvedConfig = parseLotaRuntimeConfig(config)
+    const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
+    const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
+    configureRuntimeConfig(runtimeConfig)
+
+    await configureLotaLogger(runtimeConfig.logging.level)
+
+    const db = new SurrealDBServiceClass({
+      url: runtimeConfig.database.url,
+      namespace: runtimeConfig.database.namespace,
+      database: LOTA_SDK_DATABASE_NAME,
+      username: runtimeConfig.database.username,
+      password: runtimeConfig.database.password,
+    })
+    setDatabaseService(db)
+
+    const redisManager = createRedisConnectionManager({ url: runtimeConfig.redis.url })
+    setRedisConnectionManager(redisManager)
+    configureEmbeddingCache(redisManager.getConnection(), runtimeConfig.memory.embeddingCacheTtlSeconds)
+    configureBackgroundProcessing(runtimeConfig.backgroundProcessing)
+
+    configureAgents({
+      roster: runtimeConfig.agents.roster,
+      leadAgentId: runtimeConfig.agents.leadAgentId,
+      displayNames: runtimeConfig.agents.displayNames,
+      shortDisplayNames: runtimeConfig.agents.shortDisplayNames,
+      teamConsultParticipants: runtimeConfig.agents.teamConsultParticipants,
+      getCoreWorkstreamProfile: runtimeConfig.agents.getCoreWorkstreamProfile,
+    })
+    configureAgentFactory({
+      createAgent: runtimeConfig.agents.createAgent,
+      buildAgentTools: runtimeConfig.agents.buildAgentTools,
+      getAgentRuntimeConfig: runtimeConfig.agents.getAgentRuntimeConfig,
+      pluginRuntime: runtimeConfig.pluginRuntime,
+    })
+    configureWorkstreams({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.workstreams })
+    configureNotificationService(runtimeConfig.notificationService ?? null)
+    configureRuntimeExtensions({
+      adapters: runtimeConfig.runtimeAdapters,
+      turnHooks: runtimeConfig.turnHooks,
+      toolProviders: (runtimeConfig.toolProviders ?? {}) as never,
+      extraWorkers: runtimeConfig.extraWorkers,
+    })
+
+    const pluginRuntime = runtimeConfig.pluginRuntime ?? {}
+    domainAgentExecutorService.configure(pluginRuntime)
+    if (runtimeConfig.graphDesigner) {
+      configureGraphDesigner(runtimeConfig.graphDesigner)
+    }
+
+    for (const [pluginRef, plugin] of Object.entries(pluginRuntime)) {
+      const signals = plugin.contributions.signals
+      if (signals && signals.length > 0) {
+        coordinationRegistryServiceSingleton.register(pluginRef, [...signals])
+      }
+    }
+    coordinationRegistryServiceSingleton.validate()
+    // Collect playbook contributions early to fail fast on misconfiguration
+    playbookRegistryService.collectPlaybooks()
+
+    const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
+    const schemaFiles = [...getBuiltInSchemaFiles(), ...(runtimeConfig.extraSchemaFiles ?? [])]
+    const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
+    const contributionEnvKeys = [...LOTA_RUNTIME_ENV_KEYS, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
+    const connectPluginDatabases = createPluginDatabaseConnector(pluginRuntime)
+    const workers = buildRuntimeWorkerRegistry(runtimeConfig.extraWorkers)
+
+    const lota = {
+      organizations: {
+        create: organizationServiceSingleton.createOrganization.bind(organizationServiceSingleton),
+        upsert: organizationServiceSingleton.upsertOrganization.bind(organizationServiceSingleton),
+        get: organizationServiceSingleton.getOrganization.bind(organizationServiceSingleton),
+        list: organizationServiceSingleton.listOrganizations.bind(organizationServiceSingleton),
+        update: organizationServiceSingleton.updateOrganization.bind(organizationServiceSingleton),
+        delete: organizationServiceSingleton.deleteOrganization.bind(organizationServiceSingleton),
+      },
+      users: {
+        upsert: userServiceSingleton.upsertUser.bind(userServiceSingleton),
+        get: userServiceSingleton.getUser.bind(userServiceSingleton),
+        list: userServiceSingleton.listUsers.bind(userServiceSingleton),
+        update: userServiceSingleton.updateUser.bind(userServiceSingleton),
+        delete: userServiceSingleton.deleteUser.bind(userServiceSingleton),
+      },
+      memberships: {
+        add: organizationMemberServiceSingleton.addMembership.bind(organizationMemberServiceSingleton),
+        listForOrganization: organizationMemberServiceSingleton.listMembershipsForOrganization.bind(
+          organizationMemberServiceSingleton,
+        ),
+        listForUser: organizationMemberServiceSingleton.listMembershipsForUser.bind(organizationMemberServiceSingleton),
+        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),
+          )
+          const message = messages.find((candidate) => candidate.id === messageId)
+          if (!message) {
+            throw new Error(`Workstream 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)
+          if (routed.kind !== 'turn') {
+            throw new Error(routed.kind === 'invalid' ? routed.message : 'Expected a user turn payload.')
+          }
+
+          return createWorkstreamTurnStreamSingleton({
+            workstream,
+            workstreamRef,
+            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)
+          if (routed.kind !== 'approval-continuation') {
+            throw new Error(
+              routed.kind === 'invalid' ? routed.message : 'Expected approval continuation messages payload.',
+            )
+          }
+
+          return createWorkstreamApprovalContinuationStreamSingleton({
+            workstream,
+            workstreamRef,
+            orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
+            userRef: ensureRecordId(userId, TABLES.USER),
+            userName,
+            approvalMessages: routed.approvalMessages,
+          })
+        },
+        uploadAttachment: attachmentServiceSingleton.uploadWorkstreamAttachment.bind(attachmentServiceSingleton),
+      },
+    } satisfies LotaRuntime['lota']
+
+    let disconnected = false
+
+    return {
+      services: {
+        database: db,
+        redis: redisManager,
+        closeRedisConnection: async () => await redisManager.closeConnection(),
+        attachmentService: attachmentServiceSingleton,
+        documentChunkService: documentChunkServiceSingleton,
+        generatedDocumentStorageService: generatedDocumentStorageServiceSingleton,
+        memoryService: memoryServiceSingleton,
+        verifyMutatingApproval: verifyMutatingApprovalSingleton,
+        organizationService: organizationServiceSingleton,
+        organizationMemberService: organizationMemberServiceSingleton,
+        userService: userServiceSingleton,
+        recentActivityService: recentActivityServiceSingleton,
+        recentActivityTitleService: recentActivityTitleServiceSingleton,
+        executionPlanService: executionPlanServiceSingleton,
+        workstreamMessageService: workstreamMessageServiceSingleton,
+        workstreamService: workstreamServiceSingleton,
+        workstreamTitleService: workstreamTitleServiceSingleton,
+        createWorkstreamApprovalContinuationStream: createWorkstreamApprovalContinuationStreamSingleton,
+        createWorkstreamNativeToolApprovalStream: createWorkstreamNativeToolApprovalStreamSingleton,
+        createWorkstreamTurnStream: createWorkstreamTurnStreamSingleton,
+        isApprovalContinuationRequest: isApprovalContinuationRequestSingleton,
+        runWorkstreamTurnInBackground: runWorkstreamTurnInBackgroundSingleton,
+        syncPlaybookTemplates: playbookRegistryService.syncPlaybookTemplates.bind(playbookRegistryService),
+      },
+      lota,
+      redis: {
+        manager: redisManager,
+        getConnection: () => redisManager.getConnection(),
+        getConnectionForBullMQ: () => redisManager.getConnectionForBullMQ(),
+        closeConnection: async () => await redisManager.closeConnection(),
+      },
+      workers,
+      schemaFiles,
+      contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
+      config: runtimeConfig,
+      plugins: pluginRuntime,
+      systemExecutors,
+      async connectPluginDatabases() {
+        await connectPluginDatabases()
+      },
+      async connect() {
+        await db.connect()
+        const bunFiles = schemaFiles.map((schemaFile) =>
+          schemaFile instanceof URL ? Bun.file(schemaFile.pathname) : Bun.file(schemaFile),
+        )
+        await db.applySchema(bunFiles)
+        const schemaFingerprint = await computeSchemaFingerprint(schemaFiles)
+        await publishDatabaseBootstrap({ databaseService: db, schemaFingerprint })
+      },
+      async disconnect() {
+        if (disconnected) {
+          return
+        }
+        disconnected = true
+
+        try {
+          await closeSharedSubscriber()
+          await db.disconnect()
+          await redisManager.closeConnection()
+        } finally {
+          releaseRuntimeToken(runtimeToken)
+        }
+      },
+    }
+  } catch (error) {
+    releaseRuntimeToken(runtimeToken)
+    throw error
+  }
+}
+
+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/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),
+    new URL('../infrastructure/schema/05_recent_activity.surql', import.meta.url),
+    new URL('../infrastructure/schema/04_runtime_bootstrap.surql', import.meta.url),
+  ]
+}
+
+function createPluginDatabaseConnector(pluginRuntime: Record<string, LotaPlugin>): () => Promise<void> {
+  return async () => {
+    for (const plugin of Object.values(pluginRuntime)) {
+      const services = plugin.services
+      const connectDatabase = services.connectDatabase
+      if (typeof connectDatabase !== 'function') {
+        continue
+      }
+
+      await Reflect.apply(connectDatabase, services, [])
+    }
+  }
+}

package/src/db/cursor-pagination.ts

@@ -1,4 +1,3 @@
-import { toTimestamp } from '@lota-sdk/shared'
 import type { ChatMessage } from '@lota-sdk/shared'
 import type { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
@@ -7,7 +6,7 @@ import type { RecordIdRef } from './record-id'
 import { databaseService } from './service'
 import type { DatabaseTable } from './tables'
 
-export const CursorRowSchema = z.object({ createdAt: z.union([z.date(), z.string(), z.number()]) })
+export const CursorRowSchema = z.object({ createdAt: z.coerce.date() })
 
 export interface MessageHistoryPage {
   messages: ChatMessage[]
@@ -64,10 +63,8 @@ async function listRowsBefore(
     throw new Error(`Cursor message not found in ${config.table}: ${params.beforeMessageId}`)
   }
 
-  const cursorCreatedAt = new Date(toTimestamp(cursorRow.createdAt))
+  const cursorCreatedAt = cursorRow.createdAt
   const cursorId = config.toRowId(params.parentId, params.beforeMessageId)
 
-  return await databaseService.query<unknown>(
-    config.queryBefore(params.parentId, cursorCreatedAt, cursorId, params.take),
-  )
+  return databaseService.query<unknown>(config.queryBefore(params.parentId, cursorCreatedAt, cursorId, params.take))
 }

package/src/db/index.ts

@@ -1,3 +1,4 @@
+export * from './base.service'
 export * from './cursor-pagination'
 export * from './memory'
 export * from './memory-store'
@@ -7,4 +8,5 @@ export * from './record-id'
 export * from './sdk-database'
 export * from './service'
 export * from './startup'
+export * from './surreal-mutation'
 export * from './tables'

package/src/db/memory-store.rows.ts

@@ -13,17 +13,17 @@ export interface SurrealMemoryRow {
   importance: number
   accessCount: number
   needsReview: boolean
-  lastAccessedAt?: Date | string
-  createdAt: Date | string
-  updatedAt?: Date | string
-  validFrom: Date | string
-  validUntil?: Date | string
-  archivedAt?: Date | string
+  lastAccessedAt?: Date
+  createdAt: Date
+  updatedAt?: Date
+  validFrom: Date
+  validUntil?: Date
+  archivedAt?: Date
 }
 
 export interface BasicSearchRow {
   id: RecordIdInput
   content: string
   metadata: Record<string, unknown>
-  createdAt?: Date | string
+  createdAt?: Date
 }