@lota-sdk/core 0.4.10 → 0.4.11

package/src/runtime/post-turn-side-effects.ts

@@ -3,12 +3,8 @@ import { Schema, Effect } from 'effect'
 
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import type { RecordIdRef } from '../db/record-id'
-import { runPromise } from '../effect/runtime'
 import { AgentConfigServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
-import { enqueueMemoryConsolidation } from '../queues/memory-consolidation.queue'
-import { enqueueRegularChatMemoryDigest, enqueueSkillExtraction } from '../queues/organization-learning.queue'
-import { enqueuePostChatMemory } from '../queues/post-chat-memory.queue'
-import { enqueueRecentActivityTitleRefinement } from '../queues/title-generation.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import { RecentActivityServiceTag } from '../services/recent-activity.service'
 import { ThreadServiceTag } from '../services/thread/thread.service'
 import type { NormalizedThread, ThreadRecord } from '../services/thread/thread.types'
@@ -114,157 +110,159 @@ interface PostTurnSideEffectsParams {
   agentDisplayNamesById?: Partial<Record<string, string>>
 }
 
-const runPostTurnSideEffectsEffect = (params: PostTurnSideEffectsParams) =>
-  Effect.gen(function* () {
-    const recentActivityService = yield* RecentActivityServiceTag
-    const threadService = yield* ThreadServiceTag
-    const agentConfig: ResolvedAgentConfig = yield* AgentConfigServiceTag
-    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
-    const recentHistory = yield* tryPostTurnSideEffect('Failed to load recent thread history.', () =>
-      params.loadRecentHistory(),
+export const runPostTurnSideEffects = Effect.fn('PostTurnSideEffects.run')(function* (
+  params: PostTurnSideEffectsParams,
+) {
+  const recentActivityService = yield* RecentActivityServiceTag
+  const threadService = yield* ThreadServiceTag
+  const agentConfig: ResolvedAgentConfig = yield* AgentConfigServiceTag
+  const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+  const queues = yield* LotaQueuesServiceTag
+  const recentHistory = yield* tryPostTurnSideEffect('Failed to load recent thread history.', () =>
+    params.loadRecentHistory(),
+  )
+  const turnCount = yield* threadService.incrementTurnCount(params.threadRef)
+  const agentMessages = buildAgentHistoryMessages(agentConfig, params.allAssistantMessages)
+  const historyMessagesForMemory = appendPersistedThreadContextToHistoryMessages(
+    toHistoryMessages(agentConfig, recentHistory),
+    { compactionSummary: params.latestThreadRecord.compactionSummary },
+  )
+
+  const userMessageText = params.referenceUserMessage ? extractMessageText(params.referenceUserMessage).trim() : ''
+  const readableUploads = params.listReadableUploads()
+  const attachmentMetadataContext = buildReadableUploadMetadataContext(readableUploads)
+  const hasAttachmentContext = Boolean(attachmentMetadataContext)
+  const shouldExtractMemory = params.onboardingActive
+    ? shouldEnqueueOnboardingPostChatMemory({
+        onboardingActive: params.onboardingActive,
+        userMessageText,
+        hasAttachmentContext,
+        agentMessageCount: agentMessages.length,
+      })
+    : shouldEnqueueMemoryExtraction({ onboardingActive: params.onboardingActive, turnCount }) &&
+      userMessageText.length > 0
+
+  if (shouldExtractMemory) {
+    const memoryUserMessage = userMessageText || 'User uploaded attachment(s).'
+    yield* tryPostTurnSideEffect('Failed to enqueue post-chat memory extraction.', () =>
+      safeEnqueue(
+        () =>
+          queues.postChatMemory.enqueuePostChatMemory({
+            orgId: params.orgIdString,
+            threadId: params.threadIdString,
+            sourceId: params.referenceUserMessageId,
+            onboardStatus: readOptionalString((params.workspace as { onboardStatus?: unknown }).onboardStatus),
+            userMessage: memoryUserMessage,
+            historyMessages: historyMessagesForMemory,
+            agentMessages,
+            memoryBlock: params.memoryBlock.trim() ? params.memoryBlock : undefined,
+            attachmentContext: attachmentMetadataContext,
+          }),
+        { operationName: 'post-chat memory extraction enqueue' },
+      ),
     )
-    const turnCount = yield* threadService.incrementTurnCount(params.threadRef)
-    const agentMessages = buildAgentHistoryMessages(params.allAssistantMessages)
-    const historyMessagesForMemory = appendPersistedThreadContextToHistoryMessages(toHistoryMessages(recentHistory), {
-      compactionSummary: params.latestThreadRecord.compactionSummary,
-    })
+  }
 
-    const userMessageText = params.referenceUserMessage ? extractMessageText(params.referenceUserMessage).trim() : ''
-    const readableUploads = params.listReadableUploads()
-    const attachmentMetadataContext = buildReadableUploadMetadataContext(readableUploads)
-    const hasAttachmentContext = Boolean(attachmentMetadataContext)
-    const shouldExtractMemory = params.onboardingActive
-      ? shouldEnqueueOnboardingPostChatMemory({
-          onboardingActive: params.onboardingActive,
-          userMessageText,
-          hasAttachmentContext,
-          agentMessageCount: agentMessages.length,
-        })
-      : shouldEnqueueMemoryExtraction({ onboardingActive: params.onboardingActive, turnCount }) &&
-        userMessageText.length > 0
+  const referenceUserMessage = params.referenceUserMessage
+  if (params.isUserTurn && referenceUserMessage) {
+    const conversationSummary = buildConversationSummary({
+      agentConfig,
+      userMessageText,
+      assistantMessages: params.allAssistantMessages,
+    })
+    if (conversationSummary) {
+      const effectiveAgentId = params.visibleThreadAgentId ?? params.defaultLeadAgentId
+      const recentActivityResult = yield* recentActivityService.recordEvent({
+        orgId: params.orgRef,
+        userId: params.userRef,
+        source: 'system',
+        event: {
+          sourceEventId: `chat-turn:${params.referenceUserMessageId}`,
+          kind: 'chat.turn.completed',
+          targetKind: 'thread',
+          targetId: params.threadIdString,
+          mergeKey: `thread:${params.threadIdString}`,
+          title: buildRecentActivityChatSystemTitle({
+            agentConfig,
+            thread: params.thread,
+            visibleAgentId: effectiveAgentId,
+            agentDisplayNamesById: params.agentDisplayNamesById,
+          }),
+          sourceLabel: resolveDisplayName(agentConfig, effectiveAgentId, params.agentDisplayNamesById),
+          deepLink: buildRecentActivityChatDeepLink({
+            thread: params.thread,
+            threadId: params.threadIdString,
+            visibleAgentId: effectiveAgentId,
+          }),
+          metadata: {
+            agentId: effectiveAgentId,
+            agentName: resolveDisplayName(agentConfig, effectiveAgentId, params.agentDisplayNamesById),
+            threadId: params.threadIdString,
+            threadTitle: params.latestThreadRecord.title ?? params.thread.title,
+            threadType: params.thread.type,
+            ...(params.thread.threadType ? { coreType: params.thread.threadType } : {}),
+            userMessageText,
+            assistantSummary: conversationSummary,
+            messageId: params.referenceUserMessageId,
+          },
+          occurredAt: toIsoDateTimeString(referenceUserMessage.metadata?.createdAt ?? nowEpochMillis()),
+        },
+      })
 
-    if (shouldExtractMemory) {
-      const memoryUserMessage = userMessageText || 'User uploaded attachment(s).'
-      yield* tryPostTurnSideEffect('Failed to enqueue post-chat memory extraction.', () =>
+      yield* tryPostTurnSideEffect('Failed to enqueue post-chat org action.', () =>
         safeEnqueue(
-          () =>
-            enqueuePostChatMemory({
+          () => {
+            const enqueuePostChatOrgAction = runtimeAdapters.enqueuePostChatOrgAction
+            if (!enqueuePostChatOrgAction) {
+              return
+            }
+
+            const sourceCreatedAt = referenceUserMessage.metadata?.createdAt ?? nowEpochMillis()
+            return enqueuePostChatOrgAction({
               orgId: params.orgIdString,
               threadId: params.threadIdString,
               sourceId: params.referenceUserMessageId,
-              onboardStatus: readOptionalString((params.workspace as { onboardStatus?: unknown }).onboardStatus),
-              userMessage: memoryUserMessage,
-              historyMessages: historyMessagesForMemory,
-              agentMessages,
-              memoryBlock: params.memoryBlock.trim() ? params.memoryBlock : undefined,
-              attachmentContext: attachmentMetadataContext,
-            }),
-          { operationName: 'post-chat memory extraction enqueue' },
+              sourceCreatedAt,
+              conversationSummary,
+            })
+          },
+          { operationName: 'post-chat org action enqueue' },
         ),
       )
-    }
-
-    const referenceUserMessage = params.referenceUserMessage
-    if (params.isUserTurn && referenceUserMessage) {
-      const conversationSummary = buildConversationSummary({
-        userMessageText,
-        assistantMessages: params.allAssistantMessages,
-      })
-      if (conversationSummary) {
-        const effectiveAgentId = params.visibleThreadAgentId ?? params.defaultLeadAgentId
-        const recentActivityResult = yield* recentActivityService.recordEvent({
-          orgId: params.orgRef,
-          userId: params.userRef,
-          source: 'system',
-          event: {
-            sourceEventId: `chat-turn:${params.referenceUserMessageId}`,
-            kind: 'chat.turn.completed',
-            targetKind: 'thread',
-            targetId: params.threadIdString,
-            mergeKey: `thread:${params.threadIdString}`,
-            title: buildRecentActivityChatSystemTitle({
-              agentConfig,
-              thread: params.thread,
-              visibleAgentId: effectiveAgentId,
-              agentDisplayNamesById: params.agentDisplayNamesById,
-            }),
-            sourceLabel: resolveDisplayName(agentConfig, effectiveAgentId, params.agentDisplayNamesById),
-            deepLink: buildRecentActivityChatDeepLink({
-              thread: params.thread,
-              threadId: params.threadIdString,
-              visibleAgentId: effectiveAgentId,
-            }),
-            metadata: {
-              agentId: effectiveAgentId,
-              agentName: resolveDisplayName(agentConfig, effectiveAgentId, params.agentDisplayNamesById),
-              threadId: params.threadIdString,
-              threadTitle: params.latestThreadRecord.title ?? params.thread.title,
-              threadType: params.thread.type,
-              ...(params.thread.threadType ? { coreType: params.thread.threadType } : {}),
-              userMessageText,
-              assistantSummary: conversationSummary,
-              messageId: params.referenceUserMessageId,
-            },
-            occurredAt: toIsoDateTimeString(referenceUserMessage.metadata?.createdAt ?? nowEpochMillis()),
-          },
-        })
 
-        yield* tryPostTurnSideEffect('Failed to enqueue post-chat org action.', () =>
+      if (recentActivityService.isMeaningfulRefinementCandidate(recentActivityResult.item)) {
+        yield* tryPostTurnSideEffect('Failed to enqueue recent activity title refinement.', () =>
           safeEnqueue(
-            () => {
-              const enqueuePostChatOrgAction = runtimeAdapters.enqueuePostChatOrgAction
-              if (!enqueuePostChatOrgAction) {
-                return
-              }
-
-              const sourceCreatedAt = referenceUserMessage.metadata?.createdAt ?? nowEpochMillis()
-              return enqueuePostChatOrgAction({
-                orgId: params.orgIdString,
-                threadId: params.threadIdString,
-                sourceId: params.referenceUserMessageId,
-                sourceCreatedAt,
-                conversationSummary,
-              })
-            },
-            { operationName: 'post-chat org action enqueue' },
+            () =>
+              queues.titleGeneration.enqueueRecentActivityTitleRefinement({ activityId: recentActivityResult.item.id }),
+            { operationName: 'recent activity title refinement enqueue' },
           ),
         )
-
-        if (recentActivityService.isMeaningfulRefinementCandidate(recentActivityResult.item)) {
-          yield* tryPostTurnSideEffect('Failed to enqueue recent activity title refinement.', () =>
-            safeEnqueue(() => enqueueRecentActivityTitleRefinement({ activityId: recentActivityResult.item.id }), {
-              operationName: 'recent activity title refinement enqueue',
-            }),
-          )
-        }
       }
     }
+  }
 
-    if (shouldEnqueueRegularDigestForThread({ onboardingActive: params.onboardingActive, turnCount })) {
-      yield* tryPostTurnSideEffect('Failed to enqueue regular chat memory digest.', () =>
-        safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: params.orgIdString }), {
-          operationName: 'regular chat memory digest enqueue',
-        }),
-      )
-    }
-
-    if (shouldEnqueueSkillExtraction({ onboardingActive: params.onboardingActive, turnCount })) {
-      yield* tryPostTurnSideEffect('Failed to enqueue skill extraction.', () =>
-        safeEnqueue(() => enqueueSkillExtraction({ orgId: params.orgIdString }), {
-          operationName: 'skill extraction enqueue',
-        }),
-      )
-    }
+  if (shouldEnqueueRegularDigestForThread({ onboardingActive: params.onboardingActive, turnCount })) {
+    yield* tryPostTurnSideEffect('Failed to enqueue regular chat memory digest.', () =>
+      safeEnqueue(() => queues.organizationLearning.enqueueRegularChatMemoryDigest({ orgId: params.orgIdString }), {
+        operationName: 'regular chat memory digest enqueue',
+      }),
+    )
+  }
 
-    if (shouldEnqueueMemoryConsolidation({ onboardingActive: params.onboardingActive, turnCount })) {
-      yield* tryPostTurnSideEffect('Failed to enqueue memory consolidation.', () =>
-        safeEnqueue(() => enqueueMemoryConsolidation({ scopeId: params.orgIdString }), {
-          operationName: 'memory consolidation enqueue',
-        }),
-      )
-    }
-  })
+  if (shouldEnqueueSkillExtraction({ onboardingActive: params.onboardingActive, turnCount })) {
+    yield* tryPostTurnSideEffect('Failed to enqueue skill extraction.', () =>
+      safeEnqueue(() => queues.organizationLearning.enqueueSkillExtraction({ orgId: params.orgIdString }), {
+        operationName: 'skill extraction enqueue',
+      }),
+    )
+  }
 
-export function runPostTurnSideEffects(params: PostTurnSideEffectsParams): Promise<void> {
-  return runPromise(runPostTurnSideEffectsEffect(params))
-}
+  if (shouldEnqueueMemoryConsolidation({ onboardingActive: params.onboardingActive, turnCount })) {
+    yield* tryPostTurnSideEffect('Failed to enqueue memory consolidation.', () =>
+      safeEnqueue(() => queues.memoryConsolidation.enqueueMemoryConsolidation({ scopeId: params.orgIdString }), {
+        operationName: 'memory consolidation enqueue',
+      }),
+    )
+  }
+})

package/src/runtime/runtime-config.ts

@@ -8,8 +8,6 @@ import { DEFAULT_AI_GATEWAY_URL } from '../config/constants'
 import { OPENROUTER_FAST_RERANK_MODEL_ID } from '../config/model-constants'
 import type { LotaThreadConfig, ThreadBootstrapWelcomeConfig } from '../config/thread-defaults'
 import type { RecordIdRef } from '../db/record-id'
-import { getCurrentRuntime } from '../effect/runtime-ref'
-import { RuntimeConfigServiceTag } from '../effect/services'
 import type { NotificationService } from '../services/notification.service'
 import { isRecord } from '../utils/string'
 import type { GraphDesigner } from './graph-designer'
@@ -422,8 +420,4 @@ export function loadLotaRuntimeConfigFromEnv(
     )
 }
 
-export function getRuntimeConfig(): ResolvedLotaRuntimeConfig {
-  return getCurrentRuntime().runSync(Effect.service(RuntimeConfigServiceTag))
-}
-
 export type { LotaThreadConfig }

package/src/runtime/runtime-extensions.ts

@@ -8,15 +8,7 @@ import type {
 import type { ToolSet } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
-import { resolveLotaService } from '../effect/runtime'
-import {
-  RuntimeAdaptersServiceTag,
-  RuntimeWorkerExtensionsServiceTag,
-  ToolProvidersServiceTag,
-  TurnHooksServiceTag,
-} from '../effect/services'
 import type { ReadableUploadMetadata } from '../storage/attachment-types'
-import type { LotaRuntimeWorkerExtensions } from './runtime-worker-registry'
 
 export interface LotaRuntimeBackgroundCursor {
   createdAt: Date
@@ -199,49 +191,3 @@ export interface LotaRuntimeAdapters {
   connectPluginDatabases?: () => Promise<void>
   withWorkspaceMemoryLock?: <T>(workspaceId: string, fn: () => Promise<T>) => Promise<T>
 }
-
-interface RuntimeExtensionsAccessors {
-  adapters: LotaRuntimeAdapters
-  turnHooks: LotaRuntimeTurnHooks
-  toolProviders: ToolSet
-  extraWorkers: LotaRuntimeWorkerExtensions
-}
-
-let runtimeExtensionsAccessors: RuntimeExtensionsAccessors | null = null
-
-export function configureRuntimeExtensionsAccessors(accessors: RuntimeExtensionsAccessors): void {
-  runtimeExtensionsAccessors = accessors
-}
-
-export function clearRuntimeExtensionsAccessors(): void {
-  runtimeExtensionsAccessors = null
-}
-
-export function getRuntimeAdapters(): LotaRuntimeAdapters {
-  return runtimeExtensionsAccessors?.adapters ?? resolveLotaService(RuntimeAdaptersServiceTag)
-}
-
-export function getTurnHooks(): LotaRuntimeTurnHooks {
-  return runtimeExtensionsAccessors?.turnHooks ?? resolveLotaService(TurnHooksServiceTag)
-}
-
-export function getToolProviders(): ToolSet {
-  return runtimeExtensionsAccessors?.toolProviders ?? resolveLotaService(ToolProvidersServiceTag)
-}
-
-export function getConfiguredPluginDatabaseConnector(): (() => Promise<void>) | undefined {
-  return getRuntimeAdapters().connectPluginDatabases
-}
-
-export function getExtraWorkers(): LotaRuntimeWorkerExtensions {
-  return runtimeExtensionsAccessors?.extraWorkers ?? resolveLotaService(RuntimeWorkerExtensionsServiceTag)
-}
-
-export function withConfiguredWorkspaceMemoryLock<T>(workspaceId: string, fn: () => Promise<T>): Promise<T> {
-  const adapter = getRuntimeAdapters().withWorkspaceMemoryLock
-  if (!adapter) {
-    return fn()
-  }
-
-  return adapter(workspaceId, fn)
-}

package/src/runtime/runtime-lifecycle.ts

@@ -13,6 +13,7 @@
 import type { ManagedRuntime } from 'effect'
 import { Effect } from 'effect'
 
+import { clearAiGatewayRuntime } from '../ai-gateway/ai-gateway'
 import { effectTryPromise } from '../effect/helpers'
 import type { LotaPlugin } from './plugin-types'
 
@@ -93,7 +94,6 @@ interface CreateDisconnectInput {
   runPromiseWithCurrentContext: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>
   socialChatShutdown: () => Promise<void>
   disconnectPluginDatabases: () => Promise<void>
-  onFinalize: () => void
 }
 
 /**
@@ -102,8 +102,7 @@ interface CreateDisconnectInput {
  * return the same in-flight promise.
  */
 export function createRuntimeDisconnect(input: CreateDisconnectInput): () => Promise<void> {
-  const { managedRuntime, runPromiseWithCurrentContext, socialChatShutdown, disconnectPluginDatabases, onFinalize } =
-    input
+  const { managedRuntime, runPromiseWithCurrentContext, socialChatShutdown, disconnectPluginDatabases } = input
 
   let disconnectPromise: Promise<void> | null = null
 
@@ -117,7 +116,8 @@ export function createRuntimeDisconnect(input: CreateDisconnectInput): () => Pro
         yield* Effect.ignore(effectTryPromise(() => socialChatShutdown()))
         yield* Effect.ignore(effectTryPromise(() => disconnectPluginDatabases()))
         yield* effectTryPromise(() => managedRuntime.dispose())
-      }).pipe(Effect.ensuring(Effect.sync(onFinalize))),
+        yield* Effect.sync(() => clearAiGatewayRuntime())
+      }),
     )
     return disconnectPromise
   }