@lota-sdk/core 0.4.9 → 0.4.11

package/src/index.ts

@@ -15,41 +15,42 @@ export * from './utils'
 export * from './workers'
 export { Effect } from 'effect'
 export {
+  ActiveThreadRunConflictError,
   AgentConfigLive,
+  AgentConfigServiceTag,
   AgentFactoryLive,
-  AppLoggerTag,
+  AgentFactoryServiceTag,
+  AiGenerationError,
   AppLoggerLive,
-  EffectBadRequestError,
-  clearLotaSdkRuntime,
+  AppLoggerTag,
+  BaseServicePersistenceError,
   ConfigurationError,
   ConflictError,
   DatabaseError,
   DatabaseLive,
+  DatabaseServiceTag,
   DatabaseServiceTag as EffectDatabaseService,
-  EffectNotFoundError,
-  EffectThreadTurnError,
-  EffectValidationError,
-  getLotaSdkRuntime,
-  isEffectError,
+  ForbiddenError,
   LockAcquisitionError,
   LockLostError,
-  ActiveThreadRunConflictError,
   RedisError,
   RedisLive,
+  RedisServiceTag,
   RedisServiceTag as EffectRedisService,
   RuntimeAdaptersServiceTag,
   RuntimeConfigLive,
   RuntimeConfigServiceTag,
   RuntimeExtensionsLive,
   RuntimeWorkerExtensionsServiceTag,
-  setLotaSdkRuntime,
+  ServiceError,
   ThreadConfigLive,
   ThreadConfigServiceTag,
+  ThreadTurnError,
   TimeoutError,
   ToolProvidersServiceTag,
   TurnHooksServiceTag,
-  toAwaitableEffect,
-  toAwaitableService,
+  ValidationError,
+  isEffectError,
   summarizeZodIssues,
   toValidationError,
   toValidationIssues,

package/src/queues/autonomous-job.queue.ts

@@ -1,19 +1,35 @@
 import type { AutonomousJobSchedule } from '@lota-sdk/shared'
 import type { Job } from 'bullmq'
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
-import { AutonomousJobServiceTag } from '../services/autonomous-job.service'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { buildAutonomousAtJobId } from '../utils/autonomous-job-ids'
-import type { WorkerHandle } from '../workers/worker-utils'
-import { DEFAULT_JOB_RETENTION, getQueueJobService } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
+import { DEFAULT_JOB_RETENTION } from '../workers/worker-utils'
+import { createQueueFactoryWithDeps, recordEnqueuedJobMetadata } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
+// Minimal service shape used by the queue's worker processor. We declare it
+// structurally to avoid importing `AutonomousJobServiceTag` — that would form a
+// dependency cycle since `AutonomousJobServiceLive` now depends on
+// `LotaQueuesServiceTag` (defined in `queues.service.ts` which imports this
+// module).
+interface AutonomousJobWorkerServiceShape {
+  executeQueuedRun(
+    job: Job<AutonomousJobQueuePayload>,
+  ): Effect.Effect<{ status: string; summary?: string }, unknown, unknown>
+  recoverActiveJobs(): Effect.Effect<unknown, unknown, unknown>
+}
+
+class AutonomousJobQueueError extends Schema.TaggedErrorClass<AutonomousJobQueueError>()(
+  '@lota-sdk/core/AutonomousJobQueueError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
 export interface AutonomousJobQueuePayload {
   autonomousJobId: string
   autonomousJobRunId?: string
@@ -22,19 +38,9 @@ export interface AutonomousJobQueuePayload {
 
 export const AUTONOMOUS_JOB_QUEUE = 'autonomous-job'
 
-interface AutonomousJobQueueDeps {
+export interface AutonomousJobWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
-  autonomousJobService: Context.Service.Shape<typeof AutonomousJobServiceTag>
-}
-
-let _deps: AutonomousJobQueueDeps | null = null
-function getDeps(): AutonomousJobQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Autonomous job queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
+  autonomousJobService: AutonomousJobWorkerServiceShape
 }
 
 const DEFAULT_AUTONOMOUS_JOB_OPTIONS = {
@@ -43,148 +49,176 @@ const DEFAULT_AUTONOMOUS_JOB_OPTIONS = {
   backoff: { type: 'exponential', delay: 5_000 },
 } as const
 
-function processAutonomousJob(job: Job<AutonomousJobQueuePayload>): Promise<{ status: string; summary?: string }> {
-  return Effect.runPromise(getDeps().autonomousJobService.executeQueuedRun(job))
+function processAutonomousJob(
+  deps: AutonomousJobWorkerDeps,
+  job: Job<AutonomousJobQueuePayload>,
+): Promise<{ status: string; summary?: string }> {
+  // `executeQueuedRun` is typed with a wide residual context to account for
+  // the dynamic thread-turn import inside the service; the actual Effect
+  // resolves every tag via the managed runtime that produced this service.
+  return Effect.runPromise(
+    deps.autonomousJobService.executeQueuedRun(job) as Effect.Effect<
+      { status: string; summary?: string },
+      never,
+      never
+    >,
+  )
 }
 
-const autonomousJobQueue = createQueueFactory<AutonomousJobQueuePayload>({
-  name: AUTONOMOUS_JOB_QUEUE,
-  displayName: 'Autonomous job',
-  jobName: 'run-autonomous-job',
-  concurrency: 2,
-  defaultJobOptions: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
-  prepare: () => getDeps().databaseService.connect(),
-  processor: processAutonomousJob,
-})
-
 function buildAutonomousSchedulerId(autonomousJobId: string): string {
   return `autonomous:${autonomousJobId}`
 }
 
-export function enqueueAutonomousJobRun(params: {
-  payload: AutonomousJobQueuePayload
-  delayMs?: number
-  jobId?: string
-}): Promise<{ bullmqJobId: string; queueJobId?: string }> {
-  return Effect.runPromise(
-    Effect.gen(function* () {
-      const queuedJob = yield* Effect.tryPromise(() =>
-        autonomousJobQueue
-          .getQueue()
-          .add('run-autonomous-job', params.payload, {
-            ...(typeof params.delayMs === 'number' ? { delay: Math.max(0, params.delayMs) } : {}),
-            ...(params.jobId ? { jobId: params.jobId } : {}),
-          }),
-      )
+interface MakeAutonomousJobQueueRuntimeParams {
+  connectionProvider: () => IORedis
+  queueJobService: QueueJobService
+}
 
-      const bullmqJobId = String(queuedJob.id)
-      const queueJobId = yield* Effect.catch(
-        getQueueJobService().recordEnqueued({
-          queueName: AUTONOMOUS_JOB_QUEUE,
-          id: queuedJob.id,
-          name: queuedJob.name,
-          data: queuedJob.data,
-          opts: queuedJob.opts,
-          attemptsMade: queuedJob.attemptsMade,
-          timestamp: queuedJob.timestamp,
-        }),
-        (error) =>
-          Effect.sync(() => {
-            serverLogger.error`Failed to persist queued job metadata (queue=${AUTONOMOUS_JOB_QUEUE}, job=${queuedJob.id}): ${error}`
-            return undefined
-          }),
-      )
-      return { bullmqJobId, queueJobId }
-    }),
-  )
+export interface AutonomousJobQueueRuntime {
+  enqueueAutonomousJobRun(params: {
+    payload: AutonomousJobQueuePayload
+    delayMs?: number
+    jobId?: string
+  }): Promise<{ bullmqJobId: string; queueJobId?: string }>
+  upsertAutonomousJobScheduler(params: {
+    autonomousJobId: string
+    schedule: Extract<AutonomousJobSchedule, { kind: 'cron' | 'every' }>
+  }): Promise<void>
+  removeAutonomousJobScheduler(autonomousJobId: string): Promise<void>
+  removeAutonomousAtJob(autonomousJobId: string): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: AutonomousJobWorkerDeps }): WorkerHandle
 }
 
-export function upsertAutonomousJobScheduler(params: {
-  autonomousJobId: string
-  schedule: Extract<AutonomousJobSchedule, { kind: 'cron' | 'every' }>
-}): Promise<void> {
-  const repeatOpts =
-    params.schedule.kind === 'cron' ? { pattern: params.schedule.cron } : { every: params.schedule.intervalMs }
-  return Effect.runPromise(
-    Effect.gen(function* () {
-      const queuedJob = yield* Effect.tryPromise(() =>
-        autonomousJobQueue
-          .getQueue()
-          .upsertJobScheduler(buildAutonomousSchedulerId(params.autonomousJobId), repeatOpts, {
-            name: 'run-autonomous-job',
-            data: { autonomousJobId: params.autonomousJobId, trigger: 'scheduled' },
-            opts: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
-          }),
-      )
+export function makeAutonomousJobQueueRuntime(params: MakeAutonomousJobQueueRuntimeParams): AutonomousJobQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactoryWithDeps<AutonomousJobQueuePayload, AutonomousJobWorkerDeps>({
+    name: AUTONOMOUS_JOB_QUEUE,
+    displayName: 'Autonomous job',
+    jobName: 'run-autonomous-job',
+    concurrency: 2,
+    defaultJobOptions: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processAutonomousJob,
+  })
 
-      yield* Effect.catch(
-        getQueueJobService().recordEnqueued({
+  const enqueueAutonomousJobRun: AutonomousJobQueueRuntime['enqueueAutonomousJobRun'] = (request) =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        const queuedJob = yield* Effect.tryPromise({
+          try: () =>
+            queue
+              .getQueue()
+              .add('run-autonomous-job', request.payload, {
+                ...(typeof request.delayMs === 'number' ? { delay: Math.max(0, request.delayMs) } : {}),
+                ...(request.jobId ? { jobId: request.jobId } : {}),
+              }),
+          catch: (cause) => new AutonomousJobQueueError({ message: 'Failed to enqueue autonomous job run.', cause }),
+        })
+
+        const bullmqJobId = String(queuedJob.id)
+        const queueJobId = yield* recordEnqueuedJobMetadata({
           queueName: AUTONOMOUS_JOB_QUEUE,
-          id: queuedJob.id,
-          name: queuedJob.name,
-          data: queuedJob.data,
-          opts: queuedJob.opts,
-          attemptsMade: queuedJob.attemptsMade,
-          timestamp: queuedJob.timestamp,
-        }),
-        (error) =>
-          Effect.sync(() => {
-            serverLogger.error`Failed to persist queued job metadata (queue=${AUTONOMOUS_JOB_QUEUE}, job=${queuedJob.id}): ${error}`
-          }),
-      )
-    }),
-  )
-}
-
-export function removeAutonomousJobScheduler(autonomousJobId: string): Promise<void> {
-  return Effect.runPromise(
-    Effect.asVoid(
-      Effect.tryPromise(() =>
-        autonomousJobQueue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId)),
-      ),
-    ),
-  )
-}
+          job: queuedJob,
+          queueJobService,
+        })
+        return { bullmqJobId, queueJobId }
+      }),
+    )
+
+  const upsertAutonomousJobScheduler: AutonomousJobQueueRuntime['upsertAutonomousJobScheduler'] = (request) => {
+    const repeatOpts =
+      request.schedule.kind === 'cron' ? { pattern: request.schedule.cron } : { every: request.schedule.intervalMs }
+    return Effect.runPromise(
+      Effect.gen(function* () {
+        const queuedJob = yield* Effect.tryPromise({
+          try: () =>
+            queue
+              .getQueue()
+              .upsertJobScheduler(buildAutonomousSchedulerId(request.autonomousJobId), repeatOpts, {
+                name: 'run-autonomous-job',
+                data: { autonomousJobId: request.autonomousJobId, trigger: 'scheduled' },
+                opts: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
+              }),
+          catch: (cause) =>
+            new AutonomousJobQueueError({
+              message: `Failed to upsert autonomous job scheduler for ${request.autonomousJobId}.`,
+              cause,
+            }),
+        })
+
+        yield* recordEnqueuedJobMetadata({ queueName: AUTONOMOUS_JOB_QUEUE, job: queuedJob, queueJobService })
+      }),
+    )
+  }
 
-export function removeAutonomousAtJob(autonomousJobId: string): Promise<void> {
-  return Effect.runPromise(
-    Effect.catch(
+  const removeAutonomousJobScheduler: AutonomousJobQueueRuntime['removeAutonomousJobScheduler'] = (autonomousJobId) =>
+    Effect.runPromise(
       Effect.asVoid(
-        Effect.tryPromise(() => autonomousJobQueue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId))),
+        Effect.tryPromise({
+          try: () => queue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId)),
+          catch: (cause) =>
+            new AutonomousJobQueueError({
+              message: `Failed to remove autonomous job scheduler for ${autonomousJobId}.`,
+              cause,
+            }),
+        }),
       ),
-      () => Effect.void,
-    ),
-  )
-}
-
-interface AutonomousJobWorkerOptions {
-  registerSignals?: boolean
-  connectionProvider: () => IORedis
-  deps: AutonomousJobQueueDeps
-}
-
-export function startAutonomousJobWorker(options: AutonomousJobWorkerOptions): WorkerHandle {
-  _deps = options.deps
-  const handle = autonomousJobQueue.startWorker({
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
-  })
+    )
+
+  const removeAutonomousAtJob: AutonomousJobQueueRuntime['removeAutonomousAtJob'] = (autonomousJobId) =>
+    Effect.runPromise(
+      Effect.catch(
+        Effect.asVoid(
+          Effect.tryPromise({
+            try: () => queue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId)),
+            catch: (cause) =>
+              new AutonomousJobQueueError({
+                message: `Failed to remove autonomous-at job for ${autonomousJobId}.`,
+                cause,
+              }),
+          }),
+        ),
+        () => Effect.void,
+      ),
+    )
 
-  void Effect.runPromise(
-    Effect.catch(options.deps.autonomousJobService.recoverActiveJobs(), (error) =>
-      Effect.sync(() => {
-        serverLogger.error`Autonomous job startup recovery failed: ${error}`
-      }),
-    ),
-  )
+  const startWorker: AutonomousJobQueueRuntime['startWorker'] = (options) => {
+    const { deps } = options
+    const handle = queue.startWorker({ deps, registerSignals: options.registerSignals, connectionProvider })
 
-  return handle
+    void Effect.runPromise(
+      Effect.catch(deps.autonomousJobService.recoverActiveJobs(), (error) =>
+        Effect.sync(() => {
+          serverLogger.error`Autonomous job startup recovery failed: ${error}`
+        }),
+      ) as Effect.Effect<unknown, never, never>,
+    )
+
+    return handle
+  }
+
+  return {
+    enqueueAutonomousJobRun,
+    upsertAutonomousJobScheduler,
+    removeAutonomousJobScheduler,
+    removeAutonomousAtJob,
+    startWorker,
+  }
 }
 
 runStandaloneQueueWorker((runtime) => {
-  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
-  startAutonomousJobWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
-    deps: { databaseService: resolve(DatabaseServiceTag), autonomousJobService: resolve(AutonomousJobServiceTag) },
-  })
+  void (async () => {
+    const { AutonomousJobServiceTag } = await import('../services/autonomous-job.service')
+    const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+    const redis = resolve(RedisServiceTag)
+    const autonomousJobQueueRuntime = makeAutonomousJobQueueRuntime({
+      connectionProvider: () => redis.getConnectionForBullMQ(),
+      queueJobService: resolve(QueueJobServiceTag),
+    })
+    autonomousJobQueueRuntime.startWorker({
+      deps: { databaseService: resolve(DatabaseServiceTag), autonomousJobService: resolve(AutonomousJobServiceTag) },
+    })
+  })()
 })

package/src/queues/context-compaction.queue.ts

@@ -5,11 +5,12 @@ import type IORedis from 'ioredis'
 
 import { ensureRecordId } from '../db/record-id'
 import { TABLES } from '../db/tables'
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
 import { ContextCompactionServiceTag } from '../services/context-compaction.service'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { ThreadServiceTag } from '../services/thread/thread.service'
-import { createQueueFactory } from './queue-factory'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 interface ContextCompactionJob {
@@ -18,25 +19,14 @@ interface ContextCompactionJob {
   contextSize?: number
 }
 
-interface ContextCompactionQueueDeps {
+export interface ContextCompactionWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
   threadService: Context.Service.Shape<typeof ThreadServiceTag>
   contextCompactionService: Context.Service.Shape<typeof ContextCompactionServiceTag>
 }
 
-let _deps: ContextCompactionQueueDeps | null = null
-function getDeps(): ContextCompactionQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Context compaction queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
-}
-
-function processContextCompactionJob(job: Job<ContextCompactionJob>): Promise<void> {
-  const { threadService, contextCompactionService } = getDeps()
-
+function processContextCompactionJob(deps: ContextCompactionWorkerDeps, job: Job<ContextCompactionJob>): Promise<void> {
+  const { threadService, contextCompactionService } = deps
   const { entityId, contextSize } = job.data
   const threadRef = ensureRecordId(entityId, TABLES.THREAD)
   return Effect.runPromise(
@@ -52,37 +42,49 @@ function processContextCompactionJob(job: Job<ContextCompactionJob>): Promise<vo
   )
 }
 
-const contextCompaction = createQueueFactory<ContextCompactionJob>({
-  name: 'context-compaction',
-  displayName: 'Context compaction',
-  jobName: 'compact',
-  concurrency: 2,
-  lockDuration: 300_000,
-  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 3_000 } },
-  prepare: () => getDeps().databaseService.connect(),
-  processor: processContextCompactionJob,
-})
-
-export function enqueueContextCompaction(job: ContextCompactionJob) {
-  return contextCompaction.enqueue(job, { deduplication: { id: `compact:${job.domain}:${job.entityId}` } })
+export interface ContextCompactionQueueRuntime {
+  enqueueContextCompaction(job: ContextCompactionJob): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: ContextCompactionWorkerDeps }): WorkerHandle
 }
 
-export function startContextCompactionWorker(options: {
-  registerSignals?: boolean
+interface MakeContextCompactionQueueRuntimeParams {
   connectionProvider: () => IORedis
-  deps: ContextCompactionQueueDeps
-}): ReturnType<typeof contextCompaction.startWorker> {
-  _deps = options.deps
-  return contextCompaction.startWorker({
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
+  queueJobService: QueueJobService
+}
+
+export function makeContextCompactionQueueRuntime(
+  params: MakeContextCompactionQueueRuntimeParams,
+): ContextCompactionQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+  const queue = createQueueFactoryWithDeps<ContextCompactionJob, ContextCompactionWorkerDeps>({
+    name: 'context-compaction',
+    displayName: 'Context compaction',
+    jobName: 'compact',
+    concurrency: 2,
+    lockDuration: 300_000,
+    defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 3_000 } },
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processContextCompactionJob,
   })
+
+  return {
+    enqueueContextCompaction: (job) =>
+      queue.enqueue(job, { deduplication: { id: `compact:${job.domain}:${job.entityId}` } }),
+    startWorker: (options) =>
+      queue.startWorker({ deps: options.deps, registerSignals: options.registerSignals, connectionProvider }),
+  }
 }
 
 runStandaloneQueueWorker((runtime) => {
   const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
-  startContextCompactionWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+  const redis = resolve(RedisServiceTag)
+  const contextCompactionQueue = makeContextCompactionQueueRuntime({
+    connectionProvider: () => redis.getConnectionForBullMQ(),
+    queueJobService: resolve(QueueJobServiceTag),
+  })
+  contextCompactionQueue.startWorker({
     deps: {
       databaseService: resolve(DatabaseServiceTag),
       threadService: resolve(ThreadServiceTag),