@lota-sdk/core 0.1.15 → 0.1.17

package/src/runtime/runtime-config.ts

@@ -1,17 +1,19 @@
+import type { ToolSet } from 'ai'
 import { z } from 'zod'
 
 import type { CoreWorkstreamProfile } from '../config/agent-defaults'
+import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from '../config/agent-types'
 import type { LotaWorkstreamConfig, WorkstreamBootstrapWelcomeConfig } from '../config/workstream-defaults'
-import type { LotaPlugin } from './plugin-types'
+import type { RecordIdRef } from '../db/record-id'
+import type { NotificationService } from '../services/notification.service'
+import { isRecord } from '../utils/string'
+import type { GraphDesigner } from './graph-designer'
+import type { LotaPlugin, SystemNodeExecutor } from './plugin-types'
 import type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from './runtime-extensions'
 import type { LotaRuntimeWorkerExtensions } from './runtime-worker-registry'
 
 const logLevelValues = ['trace', 'debug', 'info', 'warning', 'error', 'fatal'] as const
 
-type LotaAgentFactoryRegistry = Record<string, (...args: unknown[]) => unknown>
-
-const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null
-
 function isStringOrUrl(value: unknown): value is string | URL {
   return typeof value === 'string' || value instanceof URL
 }
@@ -24,7 +26,7 @@ function isStringRecord(value: unknown): value is Record<string, string> {
   return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'string')
 }
 
-function isAgentFactoryRegistry(value: unknown): value is LotaAgentFactoryRegistry {
+function isAgentFactoryRegistry(value: unknown): value is AgentFactory {
   return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'function')
 }
 
@@ -32,10 +34,22 @@ function isPluginRuntimeRecord(value: unknown): value is Record<string, LotaPlug
   return isRecord(value)
 }
 
+function isSystemExecutorRecord(value: unknown): value is Record<string, SystemNodeExecutor> {
+  return isRecord(value)
+}
+
 function isToolProviderRecord(value: unknown): value is Record<string, unknown> {
   return isRecord(value)
 }
 
+function isNotificationService(value: unknown): value is NotificationService {
+  return isRecord(value) && isFunction(value.notify) && isFunction(value.remind) && isFunction(value.escalate)
+}
+
+function isGraphDesigner(value: unknown): value is GraphDesigner {
+  return isRecord(value) && isFunction(value.designGraph)
+}
+
 function isWorkerExtensionRecord(value: unknown): value is LotaRuntimeWorkerExtensions {
   if (!isRecord(value)) return false
 
@@ -49,6 +63,87 @@ function isWorkerExtensionRecord(value: unknown): value is LotaRuntimeWorkerExte
   return true
 }
 
+export interface LotaSocialChatSlackConfig {
+  botToken?: string
+  signingSecret?: string
+  userName?: string
+  dedupeTtlMs?: number
+}
+
+export interface LotaSocialChatResolveContextParams {
+  platform: 'slack'
+  channelId: string
+  threadId: string
+  messageId: string
+  text: string
+  authorId?: string
+  authorName?: string
+}
+
+export interface LotaSocialChatResolvedContext {
+  workspaceId: RecordIdRef
+  userId: RecordIdRef
+  userName?: string | null
+}
+
+export interface BuildSocialChatAgentToolsParams {
+  agentId: string
+  workspaceId: RecordIdRef
+  workspaceIdString: string
+  userId: RecordIdRef
+  userIdString: string
+  userName?: string | null
+  platform: 'slack'
+  channelId: string
+  threadId: string
+  incomingMessageId: string
+  incomingText: string
+  memoryBlock: string
+  onAppendMemoryBlock: (value: string) => void
+  context?: Record<string, unknown> | null
+}
+
+export interface LotaRuntimeSocialChatConfig {
+  agentId?: string
+  agentDisplayName?: string
+  slack?: LotaSocialChatSlackConfig
+  historyRedisKeyPrefix?: string
+  stateRedisKeyPrefix?: string
+  resolveContext: (
+    params: LotaSocialChatResolveContextParams,
+  ) => LotaSocialChatResolvedContext | Promise<LotaSocialChatResolvedContext>
+  buildAgentTools: (params: BuildSocialChatAgentToolsParams) => ToolSet | Promise<ToolSet>
+  getConsultParticipants?:
+    | ((params: {
+        workspaceId: RecordIdRef
+        workspaceIdString: string
+        platform: 'slack'
+      }) => string[] | Promise<string[]>)
+    | undefined
+}
+
+function isSlackSocialChatConfig(value: unknown): value is LotaSocialChatSlackConfig {
+  if (!isRecord(value)) return false
+  if (value.botToken !== undefined && typeof value.botToken !== 'string') return false
+  if (value.signingSecret !== undefined && typeof value.signingSecret !== 'string') return false
+  if (value.userName !== undefined && typeof value.userName !== 'string') return false
+  if (value.dedupeTtlMs !== undefined && typeof value.dedupeTtlMs !== 'number') return false
+  return true
+}
+
+function isSocialChatConfig(value: unknown): value is LotaRuntimeSocialChatConfig {
+  if (!isRecord(value)) return false
+  if (value.agentId !== undefined && typeof value.agentId !== 'string') return false
+  if (value.agentDisplayName !== undefined && typeof value.agentDisplayName !== 'string') return false
+  if (value.historyRedisKeyPrefix !== undefined && typeof value.historyRedisKeyPrefix !== 'string') return false
+  if (value.stateRedisKeyPrefix !== undefined && typeof value.stateRedisKeyPrefix !== 'string') return false
+  if (value.slack !== undefined && !isSlackSocialChatConfig(value.slack)) return false
+  if (!isFunction(value.resolveContext)) return false
+  if (!isFunction(value.buildAgentTools)) return false
+  if (value.getConsultParticipants !== undefined && !isFunction(value.getConsultParticipants)) return false
+  return true
+}
+
 const workstreamBootstrapWelcomeConfigSchema = z.object({
   directAgentId: z.string().trim().min(1),
   buildMessageText: z.custom<WorkstreamBootstrapWelcomeConfig['buildMessageText']>(isFunction, {
@@ -85,15 +180,13 @@ const agentsConfigSchema = z
       })
       .optional(),
     createAgent: z
-      .custom<LotaAgentFactoryRegistry>(isAgentFactoryRegistry, {
-        error: 'agents.createAgent must be a function registry',
-      })
+      .custom<AgentFactory>(isAgentFactoryRegistry, { error: 'agents.createAgent must be a function registry' })
       .optional(),
     buildAgentTools: z
-      .custom<(...args: unknown[]) => unknown>(isFunction, { error: 'agents.buildAgentTools must be a function' })
+      .custom<AgentToolBuilder>(isFunction, { error: 'agents.buildAgentTools must be a function' })
       .optional(),
     getAgentRuntimeConfig: z
-      .custom<(...args: unknown[]) => unknown>(isFunction, { error: 'agents.getAgentRuntimeConfig must be a function' })
+      .custom<AgentRuntimeConfigProvider>(isFunction, { error: 'agents.getAgentRuntimeConfig must be a function' })
       .optional(),
   })
   .superRefine((value, ctx) => {
@@ -151,9 +244,9 @@ export const LotaRuntimeConfigSchema = z.object({
   memory: z
     .object({
       searchK: z.coerce.number().int().positive().default(6),
-      embeddingCacheTtlSeconds: z.coerce.number().int().positive().default(3600),
+      embeddingCacheTtlSeconds: z.coerce.number().int().positive().default(7200),
     })
-    .default({ searchK: 6, embeddingCacheTtlSeconds: 3600 }),
+    .default({ searchK: 6, embeddingCacheTtlSeconds: 7200 }),
   workstreams: workstreamConfigSchema.default({}),
   backgroundProcessing: z
     .object({
@@ -173,8 +266,12 @@ export const LotaRuntimeConfigSchema = z.object({
   extraSchemaFiles: z.array(z.custom<string | URL>(isStringOrUrl)).optional(),
   extraWorkers: z.custom<LotaRuntimeWorkerExtensions>(isWorkerExtensionRecord).optional(),
   pluginRuntime: z.custom<Record<string, LotaPlugin>>(isPluginRuntimeRecord).optional(),
+  systemExecutors: z.custom<Record<string, SystemNodeExecutor>>(isSystemExecutorRecord).optional(),
+  notificationService: z.custom<NotificationService>(isNotificationService).optional(),
   runtimeAdapters: z.custom<LotaRuntimeAdapters>(isRecord).optional(),
   turnHooks: z.custom<LotaRuntimeTurnHooks>(isRecord).optional(),
+  graphDesigner: z.custom<GraphDesigner>(isGraphDesigner).optional(),
+  socialChat: z.custom<LotaRuntimeSocialChatConfig>(isSocialChatConfig).optional(),
 })
 
 export type LotaRuntimeConfig = z.input<typeof LotaRuntimeConfigSchema>
@@ -235,4 +332,4 @@ export function parseWorkerBootstrapEnv(env: Record<string, string | undefined>)
   return WORKER_BOOTSTRAP_ENV_SCHEMA.parse(env)
 }
 
-export type { LotaAgentFactoryRegistry, LotaWorkstreamConfig }
+export type { LotaWorkstreamConfig }

package/src/runtime/runtime-extensions.ts

@@ -123,7 +123,6 @@ export interface ResolveAgentParams {
   onboardingActive: boolean
   linearInstalled: boolean
   githubInstalled: boolean
-  reasoningProfile: string
   skills?: string[]
   additionalInstructionSections?: string[]
   context: Record<string, unknown> | null
@@ -224,8 +223,8 @@ export function getConfiguredPluginDatabaseConnector(): (() => Promise<void>) |
 export async function withConfiguredWorkspaceMemoryLock<T>(workspaceId: string, fn: () => Promise<T>): Promise<T> {
   const adapter = runtimeExtensionsState.adapters.workers?.withWorkspaceMemoryLock
   if (!adapter) {
-    return await fn()
+    return fn()
   }
 
-  return await adapter(workspaceId, fn)
+  return adapter(workspaceId, fn)
 }

package/src/runtime/runtime-worker-registry.ts

@@ -1,5 +1,7 @@
 import { startContextCompactionWorker } from '../queues/context-compaction.queue'
+import { startDelayedNodePromotionWorker } from '../queues/delayed-node-promotion.queue'
 import { scheduleRecurringConsolidation, startMemoryConsolidationWorker } from '../queues/memory-consolidation.queue'
+import { startPlanSchedulerWorker } from '../queues/plan-scheduler.queue'
 import { startPostChatMemoryWorker } from '../queues/post-chat-memory.queue'
 import { startRecentActivityTitleRefinementWorker } from '../queues/recent-activity-title-refinement.queue'
 import { startRegularChatMemoryDigestWorker } from '../queues/regular-chat-memory-digest.queue'
@@ -8,7 +10,9 @@ import { startWorkstreamTitleGenerationWorker } from '../queues/workstream-title
 
 export interface LotaRuntimeWorkerStartRegistry {
   contextCompaction: typeof startContextCompactionWorker
+  delayedNodePromotion: typeof startDelayedNodePromotionWorker
   memoryConsolidation: typeof startMemoryConsolidationWorker
+  planScheduler: typeof startPlanSchedulerWorker
   postChatMemory: typeof startPostChatMemoryWorker
   regularChatMemoryDigest: typeof startRegularChatMemoryDigestWorker
   skillExtraction: typeof startSkillExtractionWorker
@@ -34,7 +38,9 @@ export function buildRuntimeWorkerRegistry(extraWorkers?: LotaRuntimeWorkerExten
   return {
     start: {
       contextCompaction: startContextCompactionWorker,
+      delayedNodePromotion: startDelayedNodePromotionWorker,
       memoryConsolidation: startMemoryConsolidationWorker,
+      planScheduler: startPlanSchedulerWorker,
       postChatMemory: startPostChatMemoryWorker,
       regularChatMemoryDigest: startRegularChatMemoryDigestWorker,
       skillExtraction: startSkillExtractionWorker,