@lota-sdk/core 0.4.9 → 0.4.11

package/src/workers/regular-chat-memory-digest.helpers.ts

@@ -1,4 +1,3 @@
-import { isAgentName } from '../config/agent-defaults'
 import { compactWhitespace, readRecord, readString } from '../utils/string'
 import type { DigestMessage } from './utils/thread-message-query'
 
@@ -26,7 +25,7 @@ function normalizeFilePartMetadata(part: DigestMessagePart): string | null {
 
 function extractAssistantLabel(
   message: DigestMessageForTranscript,
-  isKnownAgentName: (value: string) => boolean = isAgentName,
+  isKnownAgentName: (value: string) => boolean,
 ): string {
   const metadataAgentId =
     typeof message.metadata?.agentId === 'string' ? message.metadata.agentId.trim().toLowerCase() : ''
@@ -44,11 +43,11 @@ function extractAssistantLabel(
 
 export function buildDigestTranscript(params: {
   messages: DigestMessageForTranscript[]
-  isKnownAgentName?: (value: string) => boolean
+  isKnownAgentName: (value: string) => boolean
 }): { transcript: string; involvedAgentNames: string[] } {
   const lines: string[] = []
   const involvedAgentNames = new Set<string>()
-  const isKnownAgentName = params.isKnownAgentName ?? isAgentName
+  const { isKnownAgentName } = params
 
   for (const message of params.messages) {
     if (message.role !== 'user' && message.role !== 'assistant') continue

package/src/workers/regular-chat-memory-digest.runner.ts

@@ -1,19 +1,20 @@
-import { Cause, Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { effectTryPromise } from '../effect/helpers'
-import {
-  clearRegularChatMemoryDigestDeduplicationKey,
-  enqueueRegularChatMemoryDigest,
+import type {
+  OrganizationLearningQueueRuntime,
+  RegularChatMemoryDigestJob,
 } from '../queues/organization-learning.queue'
-import type { RegularChatMemoryDigestJob } from '../queues/organization-learning.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import type { LotaRuntimeAdapters, LotaRuntimeBackgroundCursor } from '../runtime/runtime-extensions'
 import type { MemoryServiceTag } from '../services/memory/memory.service'
@@ -35,13 +36,20 @@ import type { DigestMessage } from './utils/thread-message-query'
 // can be digested into durable memory and profile projections in the background.
 const StructuredProfilePatchSchema = z.record(z.string(), z.unknown()).default({})
 
+class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()('MemoryDigestError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
 const REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS = 10 * 60 * 1000
 const WorkspaceMemoryRowSchema = z.object({ content: z.string() })
 export interface RegularChatDigestServices {
+  agentConfig: ResolvedAgentConfig
   databaseService: SurrealDBService
   memoryService: Context.Service.Shape<typeof MemoryServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
   runtimeAdapters: LotaRuntimeAdapters
+  organizationLearningQueue: OrganizationLearningQueueRuntime
 }
 
 const ExtractedFactSchema = z.object({
@@ -120,11 +128,9 @@ function hasNewEligibleThreadMessages(params: {
     Effect.gen(function* () {
       if (params.threadIds.length === 0) return false
 
-      let query: BoundQuery | null = null
-      if (params.cursor) {
-        const cursorRowId = ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE)
-        query = new BoundQuery(
-          `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+      const query: BoundQuery | null = params.cursor
+        ? new BoundQuery(
+            `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
            WHERE threadId IN $threadIds
              AND (
                createdAt > $cursorCreatedAt
@@ -132,18 +138,22 @@ function hasNewEligibleThreadMessages(params: {
              )
            ORDER BY createdAt ASC, id ASC
            LIMIT 1`,
-          { threadIds: params.threadIds, cursorCreatedAt: params.cursor.createdAt, cursorRowId },
-        )
-      } else if (params.onboardingCutoff) {
-        query = new BoundQuery(
-          `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+            {
+              threadIds: params.threadIds,
+              cursorCreatedAt: params.cursor.createdAt,
+              cursorRowId: ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE),
+            },
+          )
+        : params.onboardingCutoff
+          ? new BoundQuery(
+              `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
            WHERE threadId IN $threadIds
              AND createdAt > $onboardingCutoff
            ORDER BY createdAt ASC, id ASC
            LIMIT 1`,
-          { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
-        )
-      }
+              { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
+            )
+          : null
 
       if (!query) return false
       const rows = yield* effectTryPromise(() => params.db.query<unknown>(query))
@@ -233,7 +243,10 @@ function runRegularChatMemoryDigestEffect(
     }
 
     const combinedMessages = [...threadMessages, ...socialMessages].sort(compareDigestMessageOrder)
-    const { transcript, involvedAgentNames } = buildDigestTranscript({ messages: combinedMessages })
+    const { transcript, involvedAgentNames } = buildDigestTranscript({
+      messages: combinedMessages,
+      isKnownAgentName: (value: string) => isAgentName(services.agentConfig, value),
+    })
     const existingMemories = yield* effectTryPromise(() =>
       loadExistingOrganizationMemories(services.databaseService, orgId),
     )
@@ -261,7 +274,10 @@ function runRegularChatMemoryDigestEffect(
 
     const summaryBlock = normalizeBlock(synthesis.summaryBlock)
     if (!summaryBlock) {
-      return yield* new Cause.UnknownError(new Error('Regular chat memory digest returned an empty summaryBlock'))
+      return yield* new MemoryDigestError({
+        message: 'Regular chat memory digest returned an empty summaryBlock',
+        cause: new Error('Regular chat memory digest returned an empty summaryBlock'),
+      })
     }
 
     const processedThreadCursor = getLastCursor(threadMessages)
@@ -321,8 +337,10 @@ function runRegularChatMemoryDigestEffect(
 
     const followUpScheduled = hasMoreThreadMessages || hasMoreSocialMessages
     if (followUpScheduled) {
-      yield* effectTryPromise(() => clearRegularChatMemoryDigestDeduplicationKey(orgId))
-      yield* effectTryPromise(() => enqueueRegularChatMemoryDigest({ orgId }))
+      yield* effectTryPromise(() =>
+        services.organizationLearningQueue.clearRegularChatMemoryDigestDeduplicationKey(orgId),
+      )
+      yield* effectTryPromise(() => services.organizationLearningQueue.enqueueRegularChatMemoryDigest({ orgId }))
     }
 
     serverLogger.info`Regular chat memory digest completed for ${orgId}: threadMessages=${threadMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
@@ -340,7 +358,7 @@ export function runRegularChatMemoryDigest(
   data: RegularChatMemoryDigestJob,
   services: RegularChatDigestServices,
 ): Promise<RegularChatDigestRunResult> {
-  const { databaseService, memoryService, socialChatHistoryService, runtimeAdapters } = services
+  const { runtimeAdapters } = services
   const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
   const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
   const workspaceProvider = runtimeAdapters.workspaceProvider
@@ -357,12 +375,11 @@ export function runRegularChatMemoryDigest(
   const withMemoryLock = runtimeAdapters.withWorkspaceMemoryLock
   const runDigest = () =>
     Effect.runPromise(
-      runRegularChatMemoryDigestEffect(
-        { databaseService, memoryService, socialChatHistoryService, runtimeAdapters },
-        orgRef,
-        orgId,
-        workspaceProvider,
-      ),
+      runRegularChatMemoryDigestEffect(services, orgRef, orgId, workspaceProvider) as Effect.Effect<
+        RegularChatDigestRunResult,
+        never,
+        never
+      >,
     )
 
   return withMemoryLock ? withMemoryLock(orgId, runDigest) : runDigest()

package/src/workers/skill-extraction.runner.ts

@@ -1,6 +1,8 @@
 import type { Context, Cause } from 'effect'
 import { Effect } from 'effect'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
@@ -27,6 +29,7 @@ const SKILL_EXTRACTION_TIMEOUT_MS = 10 * 60 * 1000
 const MIN_MESSAGE_THRESHOLD = 10
 
 export interface SkillExtractionServices {
+  agentConfig: ResolvedAgentConfig
   databaseService: SurrealDBService
   learnedSkillService: Context.Service.Shape<typeof LearnedSkillServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
@@ -149,7 +152,10 @@ function runSkillExtractionEffect(
     }
 
     const sortedMessages = [...messages].sort(compareDigestMessageOrder)
-    const { transcript } = buildDigestTranscript({ messages: sortedMessages })
+    const { transcript } = buildDigestTranscript({
+      messages: sortedMessages,
+      isKnownAgentName: (value: string) => isAgentName(services.agentConfig, value),
+    })
 
     const existingSkills = yield* services.learnedSkillService.listForOrg(orgId)
     const existingSkillsSummary =
@@ -301,7 +307,7 @@ export function runSkillExtraction(
   data: SkillExtractionJob,
   services: SkillExtractionServices,
 ): Promise<SkillExtractionRunResult> {
-  const { databaseService, learnedSkillService, socialChatHistoryService, runtimeAdapters } = services
+  const { runtimeAdapters } = services
   const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
   const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
   const workspaceProvider = runtimeAdapters.workspaceProvider
@@ -317,19 +323,11 @@ export function runSkillExtraction(
   const withMemoryLock = runtimeAdapters.withWorkspaceMemoryLock
   const runExtraction = () =>
     Effect.runPromise(
-      runSkillExtractionEffect(
-        {
-          databaseService,
-          learnedSkillService,
-          socialChatHistoryService,
-          runtimeAdapters,
-          embeddingModel: services.embeddingModel,
-        },
-        orgRef,
-        orgId,
-        workspaceProvider,
-        embeddings,
-      ),
+      runSkillExtractionEffect(services, orgRef, orgId, workspaceProvider, embeddings) as Effect.Effect<
+        SkillExtractionRunResult,
+        never,
+        never
+      >,
     )
 
   return withMemoryLock ? withMemoryLock(orgId, runExtraction) : runExtraction()

package/src/workers/worker-utils.ts

@@ -5,12 +5,9 @@ import { Effect } from 'effect'
 import type { Context } from 'effect'
 
 import { chatLogger } from '../config/logger'
-import { getCurrentRuntime } from '../effect/runtime-ref'
-import { QueueJobServiceTag } from '../services/queue-job.service'
+import type { QueueJobServiceTag } from '../services/queue-job.service'
 
-export function getQueueJobService(): Context.Service.Shape<typeof QueueJobServiceTag> {
-  return getCurrentRuntime().runSync(Effect.service(QueueJobServiceTag))
-}
+export type QueueJobService = Context.Service.Shape<typeof QueueJobServiceTag>
 
 export const DEFAULT_JOB_RETENTION = { removeOnComplete: true, removeOnFail: { age: 24 * 60 * 60, count: 200 } }
 export const LOW_JOB_RETENTION = { removeOnComplete: true, removeOnFail: { age: 6 * 60 * 60, count: 50 } }
@@ -88,6 +85,7 @@ export const createWorkerShutdown = (worker: Worker, name: string, logger: typeo
 export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TResult = void>(
   queueName: string,
   processor: (job: TJob) => Promise<TResult>,
+  queueJobService: QueueJobService,
 ): (job: TJob) => Promise<TResult> {
   return (job: TJob) => {
     const trackedJob = {
@@ -107,7 +105,7 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
     return Effect.runPromise(
       Effect.catch(
         Effect.gen(function* () {
-          yield* Effect.catch(getQueueJobService().markAttemptStarted(trackedJob), (error) =>
+          yield* Effect.catch(queueJobService.markAttemptStarted(trackedJob), (error) =>
             Effect.sync(() => {
               logPersistenceError('start', error)
             }),
@@ -115,7 +113,7 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
 
           const result = yield* Effect.tryPromise(() => processor(job))
 
-          yield* Effect.catch(getQueueJobService().markAttemptCompleted(trackedJob, result), (error) =>
+          yield* Effect.catch(queueJobService.markAttemptCompleted(trackedJob, result), (error) =>
             Effect.sync(() => {
               logPersistenceError('completion', error)
             }),
@@ -125,13 +123,21 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
         }),
         (error) =>
           Effect.gen(function* () {
-            yield* Effect.catch(getQueueJobService().markAttemptFailed(trackedJob, error), (persistenceError) =>
+            yield* Effect.catch(queueJobService.markAttemptFailed(trackedJob, error), (persistenceError) =>
               Effect.sync(() => {
                 logPersistenceError('failure', persistenceError)
               }),
             )
             return yield* error
           }),
+      ).pipe(
+        Effect.withSpan(`worker.${queueName}.${job.name}`),
+        Effect.annotateSpans({
+          'job.id': trackedJob.id !== undefined ? String(trackedJob.id) : 'unknown',
+          'job.name': job.name,
+          'job.attemptsMade': typeof job.attemptsMade === 'number' ? job.attemptsMade : -1,
+          'queue.name': queueName,
+        }),
       ),
     )
   }

package/src/config/search.ts

@@ -1,3 +0,0 @@
-export { VECTOR_SEARCH_OVERFETCH_MULTIPLIER } from '@lota-sdk/shared'
-
-export const DEFAULT_MEMORY_SEARCH_LIMIT = 10

package/src/effect/awaitable-effect.ts

@@ -1,87 +0,0 @@
-import { Effect } from 'effect'
-
-const awaitableEffectMarker = Symbol('AwaitableEffect')
-
-type AwaitableEffectState<A> = { promise?: Promise<A> }
-
-export type AwaitableEffect<A, E> = Effect.Effect<A, E, never> & Promise<A>
-
-export type AwaitableValue<T> = T extends (...args: infer TArgs) => Effect.Effect<infer A, infer E, never>
-  ? (...args: TArgs) => AwaitableEffect<A, E>
-  : T extends (...args: infer TArgs) => infer TResult
-    ? (...args: TArgs) => TResult
-    : T
-
-type AwaitableServiceMethods<T> = {
-  [K in keyof T]: AwaitableValue<T[K]>
-}
-
-export type AwaitableService<T> = AwaitableServiceMethods<T>
-
-export type MaybeAwaitableService<T extends object> = T | AwaitableService<T>
-
-type AwaitableEffectOptions = { runPromise?: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A> }
-
-export function toAwaitableEffect<A, E>(
-  effect: Effect.Effect<A, E, never>,
-  options?: AwaitableEffectOptions,
-): AwaitableEffect<A, E> {
-  const existing = effect as AwaitableEffect<A, E> & { [awaitableEffectMarker]?: AwaitableEffectState<A> }
-
-  if (existing[awaitableEffectMarker]) {
-    return existing
-  }
-
-  const state: AwaitableEffectState<A> = {}
-  const runPromise = options?.runPromise ?? Effect.runPromise
-  const ensurePromise = () => (state.promise ??= runPromise(effect))
-  const candidate = Object.create(
-    Object.getPrototypeOf(effect),
-    Object.getOwnPropertyDescriptors(effect),
-  ) as AwaitableEffect<A, E> & { [awaitableEffectMarker]?: AwaitableEffectState<A> }
-
-  const then: Promise<A>['then'] = (onfulfilled, onrejected) => ensurePromise().then(onfulfilled, onrejected)
-  const catchMethod: Promise<A>['catch'] = (onrejected) => ensurePromise().catch(onrejected)
-  const finallyMethod: Promise<A>['finally'] = (onfinally) => ensurePromise().finally(onfinally)
-
-  void Object.defineProperties(candidate, {
-    then: { value: then, configurable: true },
-    catch: { value: catchMethod, configurable: true },
-    finally: { value: finallyMethod, configurable: true },
-    [Symbol.toStringTag]: { value: 'Promise', configurable: true },
-    [awaitableEffectMarker]: { value: state },
-  })
-
-  return candidate
-}
-
-export function toAwaitableService<T extends object>(
-  service: T,
-  options?: AwaitableEffectOptions,
-): AwaitableService<T> {
-  const wrappedMethods = new Map<PropertyKey, unknown>()
-
-  return new Proxy(service, {
-    get(target, property, receiver) {
-      const value = Reflect.get(target, property, receiver)
-      if (typeof value !== 'function') {
-        return value
-      }
-
-      const existing = wrappedMethods.get(property)
-      if (existing !== undefined) {
-        return existing
-      }
-
-      const wrapped = (...args: unknown[]) => {
-        const result = Reflect.apply(value, target, args)
-        return Effect.isEffect(result)
-          ? toAwaitableEffect(result as Effect.Effect<unknown, unknown, never>, options)
-          : result
-      }
-
-      wrappedMethods.set(property, wrapped)
-      return wrapped
-    },
-  }) as AwaitableService<T>
-}

package/src/effect/runtime-ref.ts

@@ -1,25 +0,0 @@
-import type { ManagedRuntime } from 'effect'
-
-// eslint-disable-next-line typescript-eslint/no-explicit-any -- ManagedRuntime is contravariant in R; `any` is the only valid wildcard
-type SdkManagedRuntime = ManagedRuntime.ManagedRuntime<any, any>
-
-let currentRuntime: SdkManagedRuntime | null = null
-
-export function setCurrentRuntime<R, E>(runtime: ManagedRuntime.ManagedRuntime<R, E>): void {
-  currentRuntime = runtime as SdkManagedRuntime
-}
-
-export function clearCurrentRuntime(): void {
-  currentRuntime = null
-}
-
-export function getCurrentRuntime(): SdkManagedRuntime {
-  if (!currentRuntime) {
-    throw new Error('Lota Effect runtime is not configured. Call createLotaRuntime() first.')
-  }
-  return currentRuntime
-}
-
-export function getOptionalCurrentRuntime(): SdkManagedRuntime | null {
-  return currentRuntime
-}

package/src/effect/runtime.ts

@@ -1,31 +0,0 @@
-import type { Effect, ManagedRuntime } from 'effect'
-
-import { clearCurrentRuntime, getCurrentRuntime, getOptionalCurrentRuntime, setCurrentRuntime } from './runtime-ref'
-
-export function setLotaSdkRuntime<R, E>(runtime: ManagedRuntime.ManagedRuntime<R, E>): void {
-  setCurrentRuntime(runtime)
-}
-
-export function clearLotaSdkRuntime(): void {
-  clearCurrentRuntime()
-}
-
-export function getOptionalLotaSdkRuntime() {
-  return getOptionalCurrentRuntime()
-}
-
-/** Returns the current managed runtime or throws. */
-export function getLotaSdkRuntime() {
-  return getCurrentRuntime()
-}
-
-/**
- * Run an effect as a Promise using the current managed runtime's context.
- * The runtime must be initialized via `createLotaRuntime()` before any call.
- */
-export function runPromise<A, E>(
-  effect: Effect.Effect<A, E, never>,
-  options?: { readonly signal?: AbortSignal },
-): Promise<A> {
-  return getCurrentRuntime().runPromise(effect, options)
-}

package/src/redis/runtime-connection.ts

@@ -1,10 +0,0 @@
-import { Effect } from 'effect'
-import type IORedis from 'ioredis'
-
-import { getCurrentRuntime } from '../effect/runtime-ref'
-import { RedisServiceTag } from '../effect/services'
-
-export function getRuntimeRedisConnection(): IORedis {
-  const redis = getCurrentRuntime().runSync(Effect.service(RedisServiceTag))
-  return redis.getConnection()
-}

package/src/runtime/agent-types.ts

@@ -1 +0,0 @@
-export type { ChatMode, CreateHelperToolLoopAgentOptions, CreateRoutedAgentOptions } from '@lota-sdk/shared'