@lota-sdk/core 0.1.9 → 0.1.12

package/src/index.ts

@@ -1,499 +1,15 @@
-import type { CoreWorkstreamProfile } from './config/agent-defaults'
-import type { LotaWorkstreamConfig } from './config/workstream-defaults'
-import { ensureRecordId } from './db/record-id'
-import type { SurrealDBService } from './db/service'
-import { TABLES } from './db/tables'
-import type { startContextCompactionWorker } from './queues/context-compaction.queue'
-import type {
-  scheduleRecurringConsolidation,
-  startMemoryConsolidationWorker,
-} from './queues/memory-consolidation.queue'
-import type { startPostChatMemoryWorker } from './queues/post-chat-memory.queue'
-import type { startRecentActivityTitleRefinementWorker } from './queues/recent-activity-title-refinement.queue'
-import type { startRegularChatMemoryDigestWorker } from './queues/regular-chat-memory-digest.queue'
-import type { startSkillExtractionWorker } from './queues/skill-extraction.queue'
-import type { startWorkstreamTitleGenerationWorker } from './queues/workstream-title-generation.queue'
-import type { RedisConnectionManager } from './redis/connection'
-import type { isApprovalContinuationRequest } from './runtime/approval-continuation'
-import type { routeWorkstreamChatMessages } from './runtime/chat-request-routing'
-import type { LotaPlugin } from './runtime/plugin-types'
-import type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from './runtime/runtime-extensions'
-import type { attachmentService } from './services/attachment.service'
-import type { documentChunkService } from './services/document-chunk.service'
-import type { executionPlanService } from './services/execution-plan.service'
-import type { memoryService } from './services/memory.service'
-import type { verifyMutatingApproval } from './services/mutating-approval.service'
-import type { organizationMemberService } from './services/organization-member.service'
-import type { organizationService } from './services/organization.service'
-import type { recentActivityTitleService } from './services/recent-activity-title.service'
-import type { recentActivityService } from './services/recent-activity.service'
-import type { userService } from './services/user.service'
-import type { workstreamMessageService } from './services/workstream-message.service'
-import type { workstreamTitleService } from './services/workstream-title.service'
-import type {
-  createWorkstreamApprovalContinuationStream,
-  createWorkstreamTurnStream,
-  runWorkstreamTurnInBackground,
-} from './services/workstream-turn'
-import type { workstreamService } from './services/workstream.service'
-import type { generatedDocumentStorageService } from './storage/generated-document-storage.service'
-
-export type LotaAgentFactoryRegistry = Record<string, (...args: unknown[]) => unknown>
-
-interface LotaRuntimeBuiltInWorkers {
-  startContextCompactionWorker: typeof startContextCompactionWorker
-  startMemoryConsolidationWorker: typeof startMemoryConsolidationWorker
-  startPostChatMemoryWorker: typeof startPostChatMemoryWorker
-  startRecentActivityTitleRefinementWorker: typeof startRecentActivityTitleRefinementWorker
-  startRegularChatMemoryDigestWorker: typeof startRegularChatMemoryDigestWorker
-  startSkillExtractionWorker: typeof startSkillExtractionWorker
-  startWorkstreamTitleGenerationWorker: typeof startWorkstreamTitleGenerationWorker
-  scheduleRecurringConsolidation: typeof scheduleRecurringConsolidation
-}
-
-type ArchiveSdkWorkstream = (
-  workstreamId: Parameters<typeof workstreamService.updateStatus>[0],
-  status?: 'archived',
-) => ReturnType<typeof workstreamService.updateStatus>
-
-type UnarchiveSdkWorkstream = (
-  workstreamId: Parameters<typeof workstreamService.updateStatus>[0],
-  status?: 'regular',
-) => ReturnType<typeof workstreamService.updateStatus>
-
-export interface LotaRuntimeConfig {
-  database: { url: string; namespace: string; username: string; password: string }
-  redis: { url: string }
-  aiGateway: { url: string; key: string; admin?: string; pass?: string; embeddingModel?: string }
-  s3: {
-    endpoint: string
-    bucket: string
-    region?: string
-    accessKeyId: string
-    secretAccessKey: string
-    attachmentUrlExpiresIn?: number
-  }
-  firecrawl: { apiKey: string; apiBaseUrl?: string }
-  logging?: { level?: 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal' }
-  memory?: { searchK?: number; embeddingCacheTtlSeconds?: number }
-  workstreams?: LotaWorkstreamConfig
-  backgroundProcessing?: {
-    memoryExtractionFrequency?: number
-    skillExtractionFrequency?: number
-    memoryDigestFrequency?: number
-    memoryConsolidationFrequency?: number
-  }
-
-  agents: {
-    roster: readonly string[]
-    displayNames: Record<string, string>
-    shortDisplayNames?: Record<string, string>
-    teamConsultParticipants: readonly string[]
-    getCoreWorkstreamProfile?: (coreType: string) => CoreWorkstreamProfile
-    createAgent?: LotaAgentFactoryRegistry
-    buildAgentTools?: (...args: unknown[]) => unknown
-    getAgentRuntimeConfig?: (...args: unknown[]) => unknown
-  }
-
-  toolProviders?: Record<string, unknown>
-  extraSchemaFiles?: Array<string | URL>
-  extraWorkers?: Record<string, unknown>
-  pluginRuntime?: Record<string, LotaPlugin>
-  runtimeAdapters?: LotaRuntimeAdapters
-  turnHooks?: LotaRuntimeTurnHooks
-}
-
-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
-    createWorkstreamTurnStream: typeof createWorkstreamTurnStream
-    isApprovalContinuationRequest: typeof isApprovalContinuationRequest
-    runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
-  }
-  lota: {
-    organizations: {
-      create: typeof organizationService.createOrganization
-      upsert: typeof organizationService.upsertOrganization
-      get: typeof organizationService.getOrganization
-      list: typeof organizationService.listOrganizations
-      update: typeof organizationService.updateOrganization
-      delete: typeof organizationService.deleteOrganization
-    }
-    users: {
-      upsert: typeof userService.upsertUser
-      get: typeof userService.getUser
-      list: typeof userService.listUsers
-      update: typeof userService.updateUser
-      delete: typeof userService.deleteUser
-    }
-    memberships: {
-      add: typeof organizationMemberService.addMembership
-      listForOrganization: typeof organizationMemberService.listMembershipsForOrganization
-      listForUser: typeof organizationMemberService.listMembershipsForUser
-      remove: typeof organizationMemberService.removeMembership
-      isMember: typeof organizationMemberService.isMember
-    }
-    workstreams: {
-      create: typeof workstreamService.createWorkstream
-      list: typeof workstreamService.listWorkstreams
-      get: typeof workstreamService.getWorkstream
-      update: typeof workstreamService.updateTitle
-      archive: ArchiveSdkWorkstream
-      unarchive: UnarchiveSdkWorkstream
-      delete: typeof workstreamService.deleteWorkstream
-      stop: typeof workstreamService.stopActiveRun
-      listMessages: typeof workstreamMessageService.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 attachmentService.uploadWorkstreamAttachment
-    }
-  }
-  redis: {
-    manager: RedisConnectionManager
-    getConnection: () => ReturnType<RedisConnectionManager['getConnection']>
-    getConnectionForBullMQ: () => ReturnType<RedisConnectionManager['getConnectionForBullMQ']>
-    closeConnection: () => Promise<void>
-  }
-  workers: LotaRuntimeBuiltInWorkers & Record<string, unknown>
-  schemaFiles: Array<string | URL>
-  contributions: { envKeys: readonly string[]; schemaFiles: Array<string | URL> }
-  config: LotaRuntimeConfig
-  plugins: Record<string, LotaPlugin>
-  connectPluginDatabases(): Promise<void>
-  connect(): Promise<void>
-  disconnect(): Promise<void>
-}
-
-export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
-  const { lotaSdkEnvKeys, setEnv } = await import('./config/env-shapes')
-  const { configureLogger } = await import('./config/logger')
-  const { publishDatabaseBootstrap } = await import('./db/startup')
-  const { computeSchemaFingerprint } = await import('./db/schema-fingerprint')
-  const { LOTA_SDK_DATABASE_NAME } = await import('./db/sdk-database')
-  const { SurrealDBService: SurrealDBServiceClass, setDatabaseService } = await import('./db/service')
-  const { createRedisConnectionManager } = await import('./redis/connection')
-  const { setRedisConnectionManager } = await import('./redis/index')
-  const { configureAgents, configureAgentFactory } = await import('./config/agent-defaults')
-  const { configureWorkstreams } = await import('./config/workstream-defaults')
-  const { configureRuntimeExtensions } = await import('./runtime/runtime-extensions')
-  const { routeWorkstreamChatMessages } = await import('./runtime/chat-request-routing')
-  const { configureBackgroundProcessing } = await import('./config/background-processing')
-  const { configureEmbeddingCache } = await import('./ai/embedding-cache')
-
-  // Resolve config defaults
-  const memory = {
-    searchK: config.memory?.searchK ?? 6,
-    embeddingCacheTtlSeconds: config.memory?.embeddingCacheTtlSeconds ?? 3600,
-  }
-  const backgroundProcessing = {
-    memoryExtractionFrequency: config.backgroundProcessing?.memoryExtractionFrequency ?? 3,
-    skillExtractionFrequency: config.backgroundProcessing?.skillExtractionFrequency ?? 5,
-    memoryDigestFrequency: config.backgroundProcessing?.memoryDigestFrequency ?? 1,
-    memoryConsolidationFrequency: config.backgroundProcessing?.memoryConsolidationFrequency ?? 10,
-  }
-
-  setEnv({
-    AI_GATEWAY_URL: config.aiGateway.url,
-    AI_GATEWAY_KEY: config.aiGateway.key,
-    AI_GATEWAY_ADMIN: config.aiGateway.admin,
-    AI_GATEWAY_PASS: config.aiGateway.pass,
-    AI_EMBEDDING_MODEL: config.aiGateway.embeddingModel ?? 'openai/text-embedding-3-small',
-    REDIS_URL: config.redis.url,
-    LOG_LEVEL: config.logging?.level ?? 'info',
-    S3_ENDPOINT: config.s3.endpoint,
-    S3_BUCKET: config.s3.bucket,
-    S3_REGION: config.s3.region ?? 'garage',
-    S3_ACCESS_KEY_ID: config.s3.accessKeyId,
-    S3_SECRET_ACCESS_KEY: config.s3.secretAccessKey,
-    ATTACHMENT_URL_EXPIRES_IN: config.s3.attachmentUrlExpiresIn ?? 1800,
-    FIRECRAWL_API_KEY: config.firecrawl.apiKey,
-    FIRECRAWL_API_BASE_URL: config.firecrawl.apiBaseUrl,
-    MEMORY_SEARCH_K: memory.searchK,
-  })
-
-  await configureLogger(config.logging?.level ?? 'info')
-
-  const db = new SurrealDBServiceClass({
-    url: config.database.url,
-    namespace: config.database.namespace,
-    database: LOTA_SDK_DATABASE_NAME,
-    username: config.database.username,
-    password: config.database.password,
-  })
-  setDatabaseService(db)
-
-  const redisManager = createRedisConnectionManager({ url: config.redis.url })
-  setRedisConnectionManager(redisManager)
-  configureEmbeddingCache(redisManager.getConnection(), memory.embeddingCacheTtlSeconds)
-  configureBackgroundProcessing(backgroundProcessing)
-
-  configureAgents({
-    roster: config.agents.roster,
-    displayNames: config.agents.displayNames,
-    shortDisplayNames: config.agents.shortDisplayNames,
-    teamConsultParticipants: config.agents.teamConsultParticipants,
-    getCoreWorkstreamProfile: config.agents.getCoreWorkstreamProfile,
-  })
-  configureWorkstreams({ agentRoster: config.agents.roster, config: config.workstreams })
-
-  if (config.agents.createAgent || config.agents.buildAgentTools || config.agents.getAgentRuntimeConfig) {
-    configureAgentFactory({
-      createAgent: config.agents.createAgent ?? {},
-      buildAgentTools: config.agents.buildAgentTools,
-      getAgentRuntimeConfig: config.agents.getAgentRuntimeConfig,
-      pluginRuntime: config.pluginRuntime,
-    })
-  }
-
-  const { attachmentService } = await import('./services/attachment.service')
-  const { documentChunkService } = await import('./services/document-chunk.service')
-  const { recentActivityService } = await import('./services/recent-activity.service')
-  const { recentActivityTitleService } = await import('./services/recent-activity-title.service')
-  const { executionPlanService } = await import('./services/execution-plan.service')
-  const { memoryService } = await import('./services/memory.service')
-  const { verifyMutatingApproval } = await import('./services/mutating-approval.service')
-  const { organizationMemberService } = await import('./services/organization-member.service')
-  const { organizationService } = await import('./services/organization.service')
-  const { userService } = await import('./services/user.service')
-  const { workstreamMessageService } = await import('./services/workstream-message.service')
-  const { workstreamService } = await import('./services/workstream.service')
-  const { workstreamTitleService } = await import('./services/workstream-title.service')
-  const {
-    createWorkstreamApprovalContinuationStream,
-    createWorkstreamTurnStream,
-    isApprovalContinuationRequest,
-    runWorkstreamTurnInBackground,
-  } = await import('./services/workstream-turn')
-  const { generatedDocumentStorageService } = await import('./storage/generated-document-storage.service')
-  const { startContextCompactionWorker } = await import('./queues/context-compaction.queue')
-  const { scheduleRecurringConsolidation, startMemoryConsolidationWorker } =
-    await import('./queues/memory-consolidation.queue')
-  const { startPostChatMemoryWorker } = await import('./queues/post-chat-memory.queue')
-  const { startRecentActivityTitleRefinementWorker } = await import('./queues/recent-activity-title-refinement.queue')
-  const { startRegularChatMemoryDigestWorker } = await import('./queues/regular-chat-memory-digest.queue')
-  const { startSkillExtractionWorker } = await import('./queues/skill-extraction.queue')
-  const { startWorkstreamTitleGenerationWorker } = await import('./queues/workstream-title-generation.queue')
-
-  configureRuntimeExtensions({
-    adapters: config.runtimeAdapters,
-    turnHooks: config.turnHooks,
-    toolProviders: (config.toolProviders ?? {}) as never,
-    extraWorkers: config.extraWorkers,
-  })
-
-  const pluginRuntime = config.pluginRuntime ?? {}
-  const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
-  const schemaFiles = [...getBuiltInSchemaFiles(), ...(config.extraSchemaFiles ?? [])]
-  const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
-  const contributionEnvKeys = [...lotaSdkEnvKeys, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
-  const connectPluginDatabases = createPluginDatabaseConnector(pluginRuntime)
-  const builtInWorkers = {
-    startContextCompactionWorker,
-    startMemoryConsolidationWorker,
-    startPostChatMemoryWorker,
-    startRecentActivityTitleRefinementWorker,
-    startRegularChatMemoryDigestWorker,
-    startSkillExtractionWorker,
-    startWorkstreamTitleGenerationWorker,
-    scheduleRecurringConsolidation,
-  } satisfies LotaRuntimeBuiltInWorkers
-
-  const lota = {
-    organizations: {
-      create: organizationService.createOrganization.bind(organizationService),
-      upsert: organizationService.upsertOrganization.bind(organizationService),
-      get: organizationService.getOrganization.bind(organizationService),
-      list: organizationService.listOrganizations.bind(organizationService),
-      update: organizationService.updateOrganization.bind(organizationService),
-      delete: organizationService.deleteOrganization.bind(organizationService),
-    },
-    users: {
-      upsert: userService.upsertUser.bind(userService),
-      get: userService.getUser.bind(userService),
-      list: userService.listUsers.bind(userService),
-      update: userService.updateUser.bind(userService),
-      delete: userService.deleteUser.bind(userService),
-    },
-    memberships: {
-      add: organizationMemberService.addMembership.bind(organizationMemberService),
-      listForOrganization: organizationMemberService.listMembershipsForOrganization.bind(organizationMemberService),
-      listForUser: organizationMemberService.listMembershipsForUser.bind(organizationMemberService),
-      remove: organizationMemberService.removeMembership.bind(organizationMemberService),
-      isMember: organizationMemberService.isMember.bind(organizationMemberService),
-    },
-    workstreams: {
-      create: workstreamService.createWorkstream.bind(workstreamService),
-      list: workstreamService.listWorkstreams.bind(workstreamService),
-      get: workstreamService.getWorkstream.bind(workstreamService),
-      update: workstreamService.updateTitle.bind(workstreamService),
-      archive: async (workstreamId, status = 'archived') => await workstreamService.updateStatus(workstreamId, status),
-      unarchive: async (workstreamId, status = 'regular') => await workstreamService.updateStatus(workstreamId, status),
-      delete: workstreamService.deleteWorkstream.bind(workstreamService),
-      stop: workstreamService.stopActiveRun.bind(workstreamService),
-      listMessages: workstreamMessageService.listMessageHistoryPage.bind(workstreamMessageService),
-      getMessage: async ({ workstreamId, messageId }) => {
-        const messages = await workstreamMessageService.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 workstreamService.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 createWorkstreamTurnStream({
-          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 workstreamService.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 createWorkstreamApprovalContinuationStream({
-          workstream,
-          workstreamRef,
-          orgRef: ensureRecordId(organizationId, TABLES.ORGANIZATION),
-          userRef: ensureRecordId(userId, TABLES.USER),
-          userName,
-          approvalMessages: routed.approvalMessages,
-        })
-      },
-      uploadAttachment: attachmentService.uploadWorkstreamAttachment.bind(attachmentService),
-    },
-  } satisfies LotaRuntime['lota']
-
-  return {
-    services: {
-      database: db,
-      databaseService: db,
-      redis: redisManager,
-      closeRedisConnection: async () => await redisManager.closeConnection(),
-      attachmentService,
-      documentChunkService,
-      generatedDocumentStorageService,
-      memoryService,
-      verifyMutatingApproval,
-      organizationService,
-      organizationMemberService,
-      userService,
-      recentActivityService,
-      recentActivityTitleService,
-      executionPlanService,
-      workstreamMessageService,
-      workstreamService,
-      workstreamTitleService,
-      createWorkstreamApprovalContinuationStream,
-      createWorkstreamTurnStream,
-      isApprovalContinuationRequest,
-      runWorkstreamTurnInBackground,
-    },
-    lota,
-    redis: {
-      manager: redisManager,
-      getConnection: () => redisManager.getConnection(),
-      getConnectionForBullMQ: () => redisManager.getConnectionForBullMQ(),
-      closeConnection: async () => await redisManager.closeConnection(),
-    },
-    workers: { ...builtInWorkers, ...config.extraWorkers },
-    schemaFiles,
-    contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
-    config,
-    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, [])
-    }
-  }
-}
-
-export type { CoreWorkstreamProfile } from './config/agent-defaults'
-export type { SurrealDBService } from './db/service'
-export type { RedisConnectionManager } from './redis/connection'
-export type { LotaPlugin, LotaPluginContributions } from './runtime/plugin-types'
-export type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from './runtime/runtime-extensions'
+export * from './runtime'
+export * from './ai'
+export * from './bifrost'
+export * from './config'
+export * from './db'
+export * from './document'
+export * from './queues'
+export * from './redis'
+export * from './runtime/index'
+export * from './services'
+export * from './storage'
+export * from './system-agents'
+export * from './tools'
+export * from './utils'
+export * from './workers'

package/src/queues/index.ts

@@ -0,0 +1,10 @@
+export * from './context-compaction.queue'
+export * from './document-processor.queue'
+export * from './memory-consolidation.queue'
+export * from './post-chat-memory.queue'
+export * from './recent-activity-title-refinement.queue'
+export * from './regular-chat-memory-digest.config'
+export * from './regular-chat-memory-digest.queue'
+export * from './skill-extraction.config'
+export * from './skill-extraction.queue'
+export * from './workstream-title-generation.queue'

package/src/redis/connection-accessor.ts

@@ -0,0 +1,26 @@
+import type IORedis from 'ioredis'
+
+export interface RedisConnectionAccessor {
+  getConnection(): IORedis
+  getConnectionForBullMQ(): IORedis
+}
+
+let redisManager: RedisConnectionAccessor | undefined
+
+export function setRedisConnectionManager(manager: RedisConnectionAccessor): void {
+  redisManager = manager
+}
+
+export function getRedisConnection(): IORedis {
+  if (!redisManager) {
+    throw new Error('Redis connection manager not configured. Call setRedisConnectionManager() first.')
+  }
+  return redisManager.getConnection()
+}
+
+export function getRedisConnectionForBullMQ(): IORedis {
+  if (!redisManager) {
+    throw new Error('Redis connection manager not configured. Call setRedisConnectionManager() first.')
+  }
+  return redisManager.getConnectionForBullMQ()
+}

package/src/redis/connection.ts

@@ -10,7 +10,7 @@ export interface RedisConnectionLogger {
   error?: (message: string) => void
 }
 
-export interface CreateRedisConnectionManagerOptions {
+interface CreateRedisConnectionManagerOptions {
   url: string
   redisOptions?: RedisOptions
   healthCheckIntervalMs?: number

package/src/redis/index.ts

@@ -1,30 +1,14 @@
-import type IORedis from 'ioredis'
-
 import { createRedisConnectionManager } from './connection'
 import type { RedisConnectionManager } from './connection'
+export { DEFAULT_REDIS_OPTIONS, type RedisConnectionLogger } from './connection'
+export {
+  getRedisConnection,
+  getRedisConnectionForBullMQ,
+  setRedisConnectionManager,
+  type RedisConnectionAccessor,
+} from './connection-accessor'
+export { withOrgMemoryLock } from './org-memory-lock'
+export { createWorkstreamResumableContext } from './stream-context'
 
 export { createRedisConnectionManager }
 export type { RedisConnectionManager }
-
-let _redisManager: { getConnection(): IORedis; getConnectionForBullMQ(): IORedis } | undefined
-
-export function setRedisConnectionManager(manager: {
-  getConnection(): IORedis
-  getConnectionForBullMQ(): IORedis
-}): void {
-  _redisManager = manager
-}
-
-export function getRedisConnection(): IORedis {
-  if (!_redisManager) {
-    throw new Error('Redis connection manager not configured. Call setRedisConnectionManager() first.')
-  }
-  return _redisManager.getConnection()
-}
-
-export function getRedisConnectionForBullMQ(): IORedis {
-  if (!_redisManager) {
-    throw new Error('Redis connection manager not configured. Call setRedisConnectionManager() first.')
-  }
-  return _redisManager.getConnectionForBullMQ()
-}

package/src/redis/org-memory-lock.ts

@@ -1,5 +1,5 @@
-import { getRedisConnection } from '.'
 import { serverLogger } from '../config/logger'
+import { getRedisConnection } from './connection-accessor'
 import { withRedisLeaseLock } from './redis-lease-lock'
 
 const ORG_MEMORY_LOCK_PREFIX = 'lock:org-memory:org:'

package/src/redis/redis-lease-lock.ts

@@ -11,7 +11,7 @@ interface RedisLeaseLockLogger {
   warn?: (message: string) => void
 }
 
-export interface RedisLeaseLockOptions {
+interface RedisLeaseLockOptions {
   redis: IORedis
   lockKey: string
   lockTtlMs: number

package/src/redis/stream-context.ts

@@ -0,0 +1,54 @@
+import type { Redis } from 'ioredis'
+import type { Publisher, Subscriber } from 'resumable-stream/ioredis'
+import { createResumableStreamContext } from 'resumable-stream/ioredis'
+
+import { getRedisConnection } from './connection-accessor'
+
+function toSubscriber(client: Redis): Subscriber {
+  const handlers = new Map<string, (message: string) => void>()
+  const messageListener = (channel: string, message: string) => {
+    handlers.get(channel)?.(message)
+  }
+  return {
+    connect: () => Promise.resolve(),
+    subscribe: async (channel, callback) => {
+      if (handlers.size === 0) client.on('message', messageListener)
+      handlers.set(channel, callback)
+      await client.subscribe(channel)
+    },
+    unsubscribe: async (channel) => {
+      handlers.delete(channel)
+      if (handlers.size === 0) client.removeListener('message', messageListener)
+      return client.unsubscribe(channel)
+    },
+  }
+}
+
+function toPublisher(client: Redis): Publisher {
+  return {
+    connect: () => Promise.resolve(),
+    publish: (channel, message) => client.publish(channel, message),
+    set: (key, value, options) => (options?.EX ? client.set(key, value, 'EX', options.EX) : client.set(key, value)),
+    get: (key) => client.get(key),
+    incr: (key) => client.incr(key),
+  }
+}
+
+let sharedSubscriber: { client: Redis; subscriber: Subscriber } | undefined
+
+function getSharedSubscriber(): Subscriber {
+  if (!sharedSubscriber) {
+    const client = getRedisConnection().duplicate()
+    sharedSubscriber = { client, subscriber: toSubscriber(client) }
+  }
+  return sharedSubscriber.subscriber
+}
+
+export function createWorkstreamResumableContext() {
+  const redis = getRedisConnection()
+  return createResumableStreamContext({
+    waitUntil: null,
+    subscriber: getSharedSubscriber(),
+    publisher: toPublisher(redis),
+  })
+}