@lota-sdk/core 0.1.14 → 0.1.16

package/src/runtime.ts

@@ -1,387 +0,0 @@
-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/tools/log-hello-world.tool.ts

@@ -1,17 +0,0 @@
-import { tool } from 'ai'
-import { z } from 'zod'
-
-export function createLogHelloWorldTool() {
-  return tool({
-    description: 'Logs "Hello World" to the server console. Requires user approval before running.',
-    inputSchema: z.object({
-      message: z.string().optional().describe('Optional custom message to log alongside Hello World'),
-    }),
-    needsApproval: true,
-    execute: async ({ message }: { message?: string }) => {
-      const output = message ? `Hello World: ${message}` : 'Hello World'
-      console.log('[logHelloWorld]', output)
-      return { logged: output, timestamp: new Date().toISOString() }
-    },
-  })
-}

package/src/utils/error.ts

@@ -1,10 +0,0 @@
-export function getErrorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message
-  if (typeof error === 'string') return error
-
-  try {
-    return JSON.stringify(error)
-  } catch {
-    return String(error)
-  }
-}