@lota-sdk/core 0.1.15 → 0.1.17

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

@@ -15,32 +15,45 @@ 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 type { LotaPlugin } from './runtime/plugin-types'
+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 { LotaRuntimeSocialChat } from './runtime/social-chat'
+import { createSocialChatRuntime } from './runtime/social-chat'
 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 {
+  configureSocialChatHistory,
+  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'
@@ -75,6 +88,24 @@ type UnarchiveSdkWorkstream = (
   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
@@ -90,6 +121,7 @@ export interface LotaRuntime {
     userService: typeof userService
     recentActivityService: typeof recentActivityService
     recentActivityTitleService: typeof recentActivityTitleService
+    socialChatHistoryService: typeof socialChatHistoryServiceSingleton
     executionPlanService: typeof executionPlanService
     workstreamMessageService: typeof workstreamMessageService
     workstreamService: typeof workstreamService
@@ -99,6 +131,7 @@ export interface LotaRuntime {
     createWorkstreamTurnStream: typeof createWorkstreamTurnStream
     isApprovalContinuationRequest: typeof isApprovalContinuationRequest
     runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
+    syncPlaybookTemplates: typeof playbookRegistryService.syncPlaybookTemplates
   }
   lota: {
     organizations: {
@@ -158,205 +191,263 @@ export interface LotaRuntime {
     closeConnection: () => Promise<void>
   }
   workers: LotaRuntimeWorkers
+  socialChat: LotaRuntimeSocialChat
   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 resolvedConfig = parseLotaRuntimeConfig(config)
-  configureRuntimeConfig(resolvedConfig)
+  const runtimeToken = claimRuntimeToken()
+
+  try {
+    const resolvedConfig = parseLotaRuntimeConfig(config)
+    const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
+    const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
+    configureRuntimeConfig(runtimeConfig)
 
-  await configureLotaLogger(resolvedConfig.logging.level)
+    await configureLotaLogger(runtimeConfig.logging.level)
 
-  const db = new SurrealDBServiceClass({
-    url: resolvedConfig.database.url,
-    namespace: resolvedConfig.database.namespace,
-    database: LOTA_SDK_DATABASE_NAME,
-    username: resolvedConfig.database.username,
-    password: resolvedConfig.database.password,
-  })
-  setDatabaseService(db)
+    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: resolvedConfig.redis.url })
-  setRedisConnectionManager(redisManager)
-  configureEmbeddingCache(redisManager.getConnection(), resolvedConfig.memory.embeddingCacheTtlSeconds)
-  configureBackgroundProcessing(resolvedConfig.backgroundProcessing)
+    const redisManager = createRedisConnectionManager({ url: runtimeConfig.redis.url })
+    setRedisConnectionManager(redisManager)
+    configureEmbeddingCache(redisManager.getConnection(), runtimeConfig.memory.embeddingCacheTtlSeconds)
+    configureBackgroundProcessing(runtimeConfig.backgroundProcessing)
+    configureSocialChatHistory({ keyPrefix: runtimeConfig.socialChat?.historyRedisKeyPrefix })
 
-  configureAgents({
-    roster: resolvedConfig.agents.roster,
-    leadAgentId: resolvedConfig.agents.leadAgentId,
-    displayNames: resolvedConfig.agents.displayNames,
-    shortDisplayNames: resolvedConfig.agents.shortDisplayNames,
-    teamConsultParticipants: resolvedConfig.agents.teamConsultParticipants,
-    getCoreWorkstreamProfile: resolvedConfig.agents.getCoreWorkstreamProfile,
-  })
-  configureAgentFactory({
-    createAgent: resolvedConfig.agents.createAgent,
-    buildAgentTools: resolvedConfig.agents.buildAgentTools,
-    getAgentRuntimeConfig: resolvedConfig.agents.getAgentRuntimeConfig,
-    pluginRuntime: resolvedConfig.pluginRuntime,
-  })
-  configureWorkstreams({ agentRoster: resolvedConfig.agents.roster, config: resolvedConfig.workstreams })
-  configureRuntimeExtensions({
-    adapters: resolvedConfig.runtimeAdapters,
-    turnHooks: resolvedConfig.turnHooks,
-    toolProviders: (resolvedConfig.toolProviders ?? {}) as never,
-    extraWorkers: resolvedConfig.extraWorkers,
-  })
+    const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'
+    const socialChatAgentDisplayName = runtimeConfig.socialChat?.agentDisplayName?.trim() || 'Lota'
+    if (runtimeConfig.socialChat && !runtimeConfig.agents.roster.includes(socialChatAgentId)) {
+      throw new Error(`socialChat.agentId must be present in agents.roster: ${socialChatAgentId}`)
+    }
+    const agentDisplayNames = runtimeConfig.socialChat
+      ? { ...runtimeConfig.agents.displayNames, [socialChatAgentId]: socialChatAgentDisplayName }
+      : runtimeConfig.agents.displayNames
 
-  const pluginRuntime = resolvedConfig.pluginRuntime ?? {}
-  const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
-  const schemaFiles = [...getBuiltInSchemaFiles(), ...(resolvedConfig.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(resolvedConfig.extraWorkers)
+    configureAgents({
+      roster: runtimeConfig.agents.roster,
+      leadAgentId: runtimeConfig.agents.leadAgentId,
+      displayNames: agentDisplayNames,
+      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 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.')
-        }
+    const pluginRuntime = runtimeConfig.pluginRuntime ?? {}
+    domainAgentExecutorService.configure(pluginRuntime)
+    if (runtimeConfig.graphDesigner) {
+      configureGraphDesigner(runtimeConfig.graphDesigner)
+    }
 
-        return await createWorkstreamTurnStreamSingleton({
-          workstream,
-          workstreamRef,
-          orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
-          userRef: ensureRecordId(userId, TABLES.USER),
-          userName,
-          inputMessage: routed.inputMessage,
-        })
+    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 socialChat = createSocialChatRuntime({
+      redisClient: redisManager.getConnection(),
+      socialChat: runtimeConfig.socialChat,
+    })
+
+    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),
       },
-      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.',
+      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 await createWorkstreamApprovalContinuationStreamSingleton({
-          workstream,
-          workstreamRef,
-          orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
-          userRef: ensureRecordId(userId, TABLES.USER),
-          userName,
-          approvalMessages: routed.approvalMessages,
-        })
+          return createWorkstreamApprovalContinuationStreamSingleton({
+            workstream,
+            workstreamRef,
+            orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
+            userRef: ensureRecordId(userId, TABLES.USER),
+            userName,
+            approvalMessages: routed.approvalMessages,
+          })
+        },
+        uploadAttachment: attachmentServiceSingleton.uploadWorkstreamAttachment.bind(attachmentServiceSingleton),
       },
-      uploadAttachment: attachmentServiceSingleton.uploadWorkstreamAttachment.bind(attachmentServiceSingleton),
-    },
-  } satisfies LotaRuntime['lota']
+    } satisfies LotaRuntime['lota']
 
-  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,
-    },
-    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: resolvedConfig,
-    plugins: pluginRuntime,
-    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.applySchemaAndMigrations(bunFiles)
-      const schemaFingerprint = await computeSchemaFingerprint(schemaFiles)
-      await publishDatabaseBootstrap({ databaseService: db, schemaFingerprint })
-    },
-    async disconnect() {
-      await db.disconnect()
-      await redisManager.closeConnection()
-    },
+    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,
+        socialChatHistoryService: socialChatHistoryServiceSingleton,
+        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,
+      socialChat,
+      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 socialChat.shutdown()
+          await closeSharedSubscriber()
+          await db.disconnect()
+          await redisManager.closeConnection()
+        } finally {
+          releaseRuntimeToken(runtimeToken)
+        }
+      },
+    }
+  } catch (error) {
+    releaseRuntimeToken(runtimeToken)
+    throw error
   }
 }
 

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) ?? Date.now())
+  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.helpers.ts

@@ -1,5 +1,3 @@
-import { createHash } from 'node:crypto'
-
 import type { BasicSearchRow, SurrealMemoryRow } from './memory-store.rows'
 import type { MemoryRecord, MemorySearchResult } from './memory-types'
 import { recordIdToString } from './record-id'
@@ -114,5 +112,5 @@ export function processGraphAwareRows<T extends BasicSearchRow>(
 }
 
 export function hashContent(content: string, scopeId: string, memoryType: string): string {
-  return createHash('sha256').update(`${scopeId}:${memoryType}:${content}`).digest('hex')
+  return new Bun.CryptoHasher('sha256').update(`${scopeId}:${memoryType}:${content}`).digest('hex')
 }

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
 }