@lota-sdk/core 0.1.9 → 0.1.12

package/src/runtime/team-consultation-orchestrator.ts

@@ -1,7 +1,5 @@
-import { withMessageCreatedAt } from '@lota-sdk/shared/runtime/chat-message-metadata'
-import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
-import { ConsultTeamArgsSchema } from '@lota-sdk/shared/schemas/tools'
-import type { ConsultTeamResultData } from '@lota-sdk/shared/schemas/tools'
+import { ConsultTeamArgsSchema, withMessageCreatedAt } from '@lota-sdk/shared'
+import type { ChatMessage, ConsultTeamResultData } from '@lota-sdk/shared'
 import { convertToModelMessages, readUIMessageStream, tool as createTool } from 'ai'
 
 import { agentDisplayNames, teamConsultParticipants } from '../config/agent-defaults'
@@ -79,9 +77,14 @@ export interface CreateConsultTeamToolParams {
 }
 
 export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
+  const participantNames = teamConsultParticipants
+    .map((agentId) => agentDisplayNames[agentId] ?? agentId)
+    .filter((value) => value.trim().length > 0)
+  const participantSummary =
+    participantNames.length > 0 ? participantNames.join(', ') : 'the configured specialist participants'
+
   return createTool({
-    description:
-      'Consult the specialist team in parallel before replying. Use this when the answer benefits from structured executive input across product, engineering, finance, marketing, strategy, and mentorship.',
+    description: `Consult the specialist team in parallel before replying. Use this when the answer benefits from structured input across ${participantSummary}.`,
     inputSchema: ConsultTeamArgsSchema,
     execute: async function* ({ task }) {
       const uploadMetadataText = buildReadableUploadMetadataText(params.availableUploads)

package/src/runtime/team-consultation-prompts.ts

@@ -1,10 +1,11 @@
-import { agentDisplayNames } from '../config/agent-defaults'
+import { agentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
 
 export function buildTeamConsultationResponseGuard(params: { agentId: string; task: string }) {
   const agentName = agentDisplayNames[params.agentId] ?? params.agentId
+  const leadAgentDisplayName = getLeadAgentDisplayName()
   return [
     '<team-consultation-agent-protocol>',
-    '- You are participating in a structured internal team consultation led by Chief of Staff.',
+    `- You are participating in a structured internal team consultation led by ${leadAgentDisplayName}.`,
     `- Your role for this response is ${agentName}.`,
     '- Use markdown when it helps clarity.',
     '- Make the recommendation, explain key tradeoffs, and note the next decision.',

package/src/runtime/turn-lifecycle.ts

@@ -1,4 +1,4 @@
-import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+import type { ChatMessage } from '@lota-sdk/shared'
 
 export async function finalizeTurnRun(params: {
   serverRunId: string
@@ -9,7 +9,17 @@ export async function finalizeTurnRun(params: {
   unregisterRun: (runId: string) => void
   clearActiveRunId: (runId: string) => Promise<void>
   disposeAbort: () => void
+  activeStreamId?: string
+  clearActiveStreamId?: (streamId: string) => Promise<void>
 }): Promise<void> {
+  // Clear the active run immediately so new messages are not blocked
+  params.unregisterRun(params.serverRunId)
+  await params.clearActiveRunId(params.serverRunId)
+  if (params.activeStreamId && params.clearActiveStreamId) {
+    await params.clearActiveStreamId(params.activeStreamId)
+  }
+  params.disposeAbort()
+
   try {
     const entity = await params.getEntity()
     const cursor = typeof entity.lastCompactedMessageId === 'string' ? entity.lastCompactedMessageId : undefined
@@ -20,9 +30,7 @@ export async function finalizeTurnRun(params: {
     if (shouldCompact) {
       await params.enqueueCompaction()
     }
-  } finally {
-    params.unregisterRun(params.serverRunId)
-    await params.clearActiveRunId(params.serverRunId)
-    params.disposeAbort()
+  } catch {
+    // compaction assessment errors should not surface to callers
   }
 }

package/src/runtime/workstream-chat-helpers.ts

@@ -16,49 +16,6 @@ function getAgentName(message: ChatMessageLike): string | undefined {
   return resolvedAgentName ? (agentDisplayNames[resolvedAgentName] ?? value.trim()) : value.trim()
 }
 
-function truncateTrackerText(value: string, maxChars: number): string {
-  return value.length <= maxChars ? value : `${value.slice(0, maxChars).trimEnd()}...`
-}
-
-function toTrackerToolLine(part: ChatMessageLike['parts'][number]): string | null {
-  if (typeof part !== 'object') return null
-  const record = part as Record<string, unknown>
-  const type = typeof record.type === 'string' ? record.type : null
-  if (!type?.startsWith('tool-')) return null
-
-  const toolName = type.slice('tool-'.length) || 'unknown'
-  const state = typeof record.state === 'string' ? record.state : null
-  const input = record.input
-  const output = record.output
-
-  const inputTask =
-    input && typeof input === 'object' && typeof (input as Record<string, unknown>).task === 'string'
-      ? truncateTrackerText(((input as Record<string, unknown>).task as string).trim(), 220)
-      : null
-  const outputSummary =
-    output && typeof output === 'object' && typeof (output as Record<string, unknown>).summary === 'string'
-      ? truncateTrackerText(((output as Record<string, unknown>).summary as string).trim(), 220)
-      : null
-  const outputResult =
-    output && typeof output === 'object' && typeof (output as Record<string, unknown>).result === 'string'
-      ? truncateTrackerText(((output as Record<string, unknown>).result as string).trim(), 220)
-      : null
-  const errorText = typeof record.errorText === 'string' ? truncateTrackerText(record.errorText.trim(), 220) : null
-
-  if (state === 'output-error') {
-    return errorText ? `Tool ${toolName} failed: ${errorText}` : `Tool ${toolName} failed.`
-  }
-
-  if (state !== 'output-available') {
-    return inputTask ? `Tool ${toolName} ran for: ${inputTask}` : `Tool ${toolName} ran.`
-  }
-
-  if (outputSummary) return `Tool ${toolName} completed: ${outputSummary}`
-  if (inputTask) return `Tool ${toolName} completed for: ${inputTask}`
-  if (outputResult) return `Tool ${toolName} completed: ${outputResult}`
-  return `Tool ${toolName} completed.`
-}
-
 export function extractMessageText(message: ChatMessageLike): string {
   return message.parts
     .flatMap((part) => (part.type === 'text' && typeof part.text === 'string' ? [part.text] : []))
@@ -66,17 +23,6 @@ export function extractMessageText(message: ChatMessageLike): string {
     .trim()
 }
 
-export function extractTrackerMessageText(message: ChatMessageLike): string {
-  const textParts = message.parts.flatMap((part) =>
-    part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],
-  )
-  const toolParts = message.parts
-    .map((part) => toTrackerToolLine(part))
-    .filter((value): value is string => Boolean(value))
-
-  return [...textParts, ...toolParts].join('\n').trim()
-}
-
 export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): WorkstreamHistoryMessage[] {
   return messages
     .map((message): WorkstreamHistoryMessage | null => {

package/src/runtime/workstream-routing-policy.ts

@@ -1,4 +1,4 @@
-import { extractAgentMentions } from '../config/agent-defaults'
+import { extractAgentMentions, getLeadAgentId } from '../config/agent-defaults'
 
 export type MessageRoute =
   | { type: 'direct'; agents: [string] }
@@ -285,7 +285,7 @@ export function resolveMessageRoute(params: {
   message: string
 }): MessageRoute {
   if (params.workstreamMode === 'direct') {
-    return { type: 'direct', agents: [params.workstreamAgentId ?? 'chief'] }
+    return { type: 'direct', agents: [params.workstreamAgentId ?? getLeadAgentId()] }
   }
 
   const mentions = uniqueMentionOrder(params.message)
@@ -293,9 +293,5 @@ export function resolveMessageRoute(params: {
     return { type: 'mentions', agents: mentions }
   }
 
-  if (isGtmIntentMessage(params.message)) {
-    return { type: 'group-default', agents: ['cmo'] }
-  }
-
-  return { type: 'group-default', agents: ['chief'] }
+  return { type: 'group-default', agents: [getLeadAgentId()] }
 }

package/src/runtime.ts

@@ -0,0 +1,387 @@
+import { configureEmbeddingCache } from './ai/embedding-cache'
+import { configureAgentFactory, configureAgents } from './config/agent-defaults'
+import { configureBackgroundProcessing } from './config/background-processing'
+import { configureLogger } 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 type { isApprovalContinuationRequest } from './runtime/approval-continuation'
+import { routeWorkstreamChatMessages } from './runtime/chat-request-routing'
+import type { LotaPlugin } 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 type { documentChunkService } from './services/document-chunk.service'
+import { documentChunkService as documentChunkServiceSingleton } from './services/document-chunk.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 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 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 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>
+
+export interface LotaRuntime {
+  services: {
+    database: SurrealDBService
+    databaseService: 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
+  }
+  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<unknown>
+      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>
+  connectPluginDatabases(): Promise<void>
+  connect(): Promise<void>
+  disconnect(): Promise<void>
+}
+
+export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
+  const resolvedConfig = parseLotaRuntimeConfig(config)
+  configureRuntimeConfig(resolvedConfig)
+
+  await configureLogger(resolvedConfig.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 redisManager = createRedisConnectionManager({ url: resolvedConfig.redis.url })
+  setRedisConnectionManager(redisManager)
+  configureEmbeddingCache(redisManager.getConnection(), resolvedConfig.memory.embeddingCacheTtlSeconds)
+  configureBackgroundProcessing(resolvedConfig.backgroundProcessing)
+
+  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 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)
+
+  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 await 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,
+        })
+      },
+      uploadAttachment: attachmentServiceSingleton.uploadWorkstreamAttachment.bind(attachmentServiceSingleton),
+    },
+  } satisfies LotaRuntime['lota']
+
+  return {
+    services: {
+      database: db,
+      databaseService: 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()
+    },
+  }
+}
+
+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 as Record<string, unknown>
+      const connectDatabase = services.connectDatabase
+      if (typeof connectDatabase !== 'function') {
+        continue
+      }
+
+      await Reflect.apply(connectDatabase, services, [])
+    }
+  }
+}

package/src/services/chat-attachments.service.ts

@@ -1,4 +1,4 @@
-import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+import type { ChatMessage } from '@lota-sdk/shared'
 
 import type { RecordIdRef } from '../db/record-id'
 import { attachmentService } from './attachment.service'

package/src/services/context-compaction.service.ts

@@ -1,4 +1,4 @@
-import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
+import type { ChatMessage } from '@lota-sdk/shared'
 
 import { chatLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'

package/src/services/document-chunk.service.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto'
 
 import { chunkMarkdownDocument, chunkPagedDocument, chunkPlainTextDocument } from '../document/org-document-chunking'
 import type { ParsedDocumentChunk } from '../document/org-document-chunking'
-import { createDefaultEmbeddings } from '../embeddings/provider'
+import { getDefaultEmbeddings } from '../embeddings/provider'
 
 type DocumentChunkEmbeddings = {
   embedDocuments(documents: string[]): Promise<number[][]>
@@ -10,7 +10,7 @@ type DocumentChunkEmbeddings = {
 }
 
 function createDocumentChunkEmbeddings(): DocumentChunkEmbeddings {
-  const embeddings = createDefaultEmbeddings()
+  const embeddings = getDefaultEmbeddings()
 
   return {
     embedDocuments: async (documents) => await embeddings.embedDocuments(documents),