@lota-sdk/core 0.4.9 → 0.4.11

package/src/services/autonomous-job.service.ts

@@ -22,7 +22,7 @@ import type {
   UpdateAutonomousJobInput,
 } from '@lota-sdk/shared'
 import type { Job } from 'bullmq'
-import { Context, Cron, Schema, Effect, Layer } from 'effect'
+import { Context, Cron, Schema, Effect, Layer, Ref } from 'effect'
 import { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
@@ -32,7 +32,8 @@ import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { DatabaseServiceTag, RuntimeConfigServiceTag } from '../effect/services'
-import type { AutonomousJobQueuePayload } from '../queues/autonomous-job.queue'
+import type { AutonomousJobQueuePayload, AutonomousJobQueueRuntime } from '../queues/autonomous-job.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import { extractMessageText } from '../runtime/thread-chat-helpers'
 import { buildAutonomousAtJobId, encodeBullmqId } from '../utils/autonomous-job-ids'
@@ -49,12 +50,8 @@ import { ExecutionPlanServiceTag } from './execution-plan/execution-plan.service
 import type { makeQueueJobService } from './queue-job.service'
 import { QueueJobServiceTag } from './queue-job.service'
 import type { PreparedThreadTurnResult } from './thread/thread-turn'
-import type { ThreadTurnParams } from './thread/thread-turn-preparation.service'
 import type { makeThreadService } from './thread/thread.service'
 import { ThreadServiceTag } from './thread/thread.service'
-// runThreadTurnInBackground is imported dynamically below
-
-type ThreadTurnModule = { runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> }
 
 const AUTONOMOUS_JOB_QUEUE_NAME = 'autonomous-job'
 
@@ -312,27 +309,22 @@ function getRunRowEffect(
   })
 }
 
-function unscheduleRowEffect(row: AutonomousJobRow): Effect.Effect<void, AutonomousJobServiceError> {
+function unscheduleRowEffect(
+  deps: AutonomousJobDeps,
+  row: AutonomousJobRow,
+): Effect.Effect<void, AutonomousJobServiceError> {
   if (row.schedule.kind === 'at') {
     return Effect.gen(function* () {
-      const { removeAutonomousAtJob } = yield* effectTryPromise(
-        () => import('../queues/autonomous-job.queue'),
-        'Failed to load autonomous job queue helpers.',
-      )
       yield* effectTryPromise(
-        () => removeAutonomousAtJob(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
+        () => deps.autonomousJobQueue.removeAutonomousAtJob(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
         'Failed to remove autonomous at-job.',
       )
     })
   }
 
   return Effect.gen(function* () {
-    const { removeAutonomousJobScheduler } = yield* effectTryPromise(
-      () => import('../queues/autonomous-job.queue'),
-      'Failed to load autonomous job queue helpers.',
-    )
     yield* effectTryPromise(
-      () => removeAutonomousJobScheduler(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
+      () => deps.autonomousJobQueue.removeAutonomousJobScheduler(recordIdToString(row.id, TABLES.AUTONOMOUS_JOB)),
       'Failed to remove autonomous job scheduler.',
     )
   })
@@ -386,14 +378,9 @@ function scheduleRowEffect(
           })
         : createRunRowEffect(deps, { autonomousJobId: row.id, threadId: row.threadId })
 
-      const { enqueueAutonomousJobRun } = yield* effectTryPromise(
-        () => import('../queues/autonomous-job.queue'),
-        'Failed to load autonomous job queue helpers.',
-      )
-
       const enqueueResult = yield* effectTryPromise(
         () =>
-          enqueueAutonomousJobRun({
+          deps.autonomousJobQueue.enqueueAutonomousJobRun({
             payload: {
               autonomousJobId: jobId,
               autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
@@ -428,13 +415,9 @@ function scheduleRowEffect(
   } else {
     const recurringSchedule = row.schedule
     return Effect.gen(function* () {
-      const { upsertAutonomousJobScheduler } = yield* effectTryPromise(
-        () => import('../queues/autonomous-job.queue'),
-        'Failed to load autonomous job queue helpers.',
-      )
-
       yield* effectTryPromise(
-        () => upsertAutonomousJobScheduler({ autonomousJobId: jobId, schedule: recurringSchedule }),
+        () =>
+          deps.autonomousJobQueue.upsertAutonomousJobScheduler({ autonomousJobId: jobId, schedule: recurringSchedule }),
         'Failed to upsert autonomous job scheduler.',
       )
 
@@ -564,7 +547,7 @@ function updateEffect(
   return Effect.gen(function* () {
     const parsed = UpdateAutonomousJobInputSchema.parse(input)
     const existing = yield* getRowEffect(deps, jobId)
-    yield* unscheduleRowEffect(existing)
+    yield* unscheduleRowEffect(deps, existing)
     const nextTitle = parsed.title
     if (typeof nextTitle === 'string' && compactWhitespace(nextTitle) !== compactWhitespace(existing.title)) {
       const title = nextTitle
@@ -616,7 +599,7 @@ function pauseEffect(
 ): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
-    yield* unscheduleRowEffect(row)
+    yield* unscheduleRowEffect(deps, row)
     yield* effectTryPromise(
       () =>
         deps.db.update(
@@ -667,14 +650,10 @@ function runNowEffect(
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
     const queuedRun = yield* createRunRowEffect(deps, { autonomousJobId: row.id, threadId: row.threadId })
-    const { enqueueAutonomousJobRun } = yield* effectTryPromise(
-      () => import('../queues/autonomous-job.queue'),
-      'Failed to load autonomous job queue helpers.',
-    )
 
     const enqueueResult = yield* effectTryPromise(
       () =>
-        enqueueAutonomousJobRun({
+        deps.autonomousJobQueue.enqueueAutonomousJobRun({
           payload: {
             autonomousJobId: recordIdToString(row.id, TABLES.AUTONOMOUS_JOB),
             autonomousJobRunId: recordIdToString(queuedRun.id, TABLES.AUTONOMOUS_JOB_RUN),
@@ -710,7 +689,7 @@ function cancelEffect(
 ): Effect.Effect<AutonomousJob, AutonomousJobServiceError> {
   return Effect.gen(function* () {
     const row = yield* getRowEffect(deps, jobId)
-    yield* unscheduleRowEffect(row)
+    yield* unscheduleRowEffect(deps, row)
     yield* effectTryPromise(
       () =>
         deps.db.update(
@@ -923,7 +902,7 @@ function failQueuedRunEffect(
     )
 
     if (autoPause || terminalOneShot) {
-      yield* unscheduleRowEffect(currentJobRow)
+      yield* unscheduleRowEffect(deps, currentJobRow)
     }
 
     yield* effectTryPromise(
@@ -967,39 +946,41 @@ function failQueuedRunEffect(
 function executeQueuedRunEffect(
   deps: AutonomousJobDeps,
   job: Job<AutonomousJobQueuePayload>,
-): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError> {
-  let autonomousJobRow: AutonomousJobRow | null = null
-  let runRow: AutonomousJobRunRow | null = null
-
+): Effect.Effect<{ status: string; summary?: string }, AutonomousJobServiceError, unknown> {
   return Effect.gen(function* () {
-    yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
-    autonomousJobRow = yield* getRowEffect(deps, job.data.autonomousJobId)
-    const currentJobRow = autonomousJobRow
-    const { queueJobId, runRow: initialRunRow } = yield* getOrCreateQueuedRunRowEffect(deps, job, currentJobRow)
-
-    runRow = initialRunRow
-    if (currentJobRow.status !== 'active' && job.data.trigger === 'scheduled') {
-      return { status: 'skipped' }
-    }
+    const autonomousJobRowRef = yield* Ref.make<AutonomousJobRow | null>(null)
+    const runRowRef = yield* Ref.make<AutonomousJobRunRow | null>(null)
+
+    return yield* Effect.gen(function* () {
+      yield* effectTryPromise(() => deps.db.connect(), 'Failed to connect to autonomous job database.')
+      const currentJobRow = yield* getRowEffect(deps, job.data.autonomousJobId)
+      yield* Ref.set(autonomousJobRowRef, currentJobRow)
+      const { queueJobId, runRow: initialRunRow } = yield* getOrCreateQueuedRunRowEffect(deps, job, currentJobRow)
+
+      yield* Ref.set(runRowRef, initialRunRow)
+      if (currentJobRow.status !== 'active' && job.data.trigger === 'scheduled') {
+        return { status: 'skipped' }
+      }
 
-    runRow = yield* markQueuedRunRunningEffect(deps, initialRunRow, queueJobId)
-    const currentRunRow = runRow
-    const inputMessage = buildSyntheticUserMessage(currentJobRow.prompt)
+      const currentRunRow = yield* markQueuedRunRunningEffect(deps, initialRunRow, queueJobId)
+      yield* Ref.set(runRowRef, currentRunRow)
+      const inputMessage = buildSyntheticUserMessage(currentJobRow.prompt)
 
-    const [thread, turnModule] = yield* Effect.all([
-      deps.thread
+      const thread = yield* deps.thread
         .getThread(currentJobRow.threadId)
         .pipe(
           Effect.mapError(
             (cause) => new AutonomousJobServiceError({ message: 'Failed to load autonomous job thread.', cause }),
           ),
-        ),
-      effectTryPromise<ThreadTurnModule>(() => import('./thread/thread-turn'), 'Failed to load thread turn runtime.'),
-    ])
+        )
 
-    const turnResult = yield* effectTryPromise(
-      () =>
-        turnModule.runThreadTurnInBackground({
+      const turnModule = yield* Effect.tryPromise({
+        try: () => import('./thread/thread-turn'),
+        catch: (cause) => new AutonomousJobServiceError({ message: 'Failed to load thread turn runtime.', cause }),
+      })
+
+      const turnResult = yield* turnModule
+        .runThreadTurnInBackground({
           thread,
           threadRef: ensureRecordId(currentJobRow.threadId, TABLES.THREAD),
           orgRef: ensureRecordId(currentJobRow.organizationId, TABLES.ORGANIZATION),
@@ -1007,31 +988,35 @@ function executeQueuedRunEffect(
           userName: currentJobRow.ownerUserName,
           agentIdOverride: currentJobRow.agentId,
           inputMessage,
-        }),
-      'Failed to run autonomous job thread turn.',
-    )
+        })
+        .pipe(
+          Effect.mapError(
+            (cause) => new AutonomousJobServiceError({ message: 'Failed to run autonomous job thread turn.', cause }),
+          ),
+        )
 
-    const activePlan = yield* deps.executionPlan
-      .getActivePlanForThread(currentJobRow.threadId)
-      .pipe(
-        Effect.mapError(
-          (cause) => new AutonomousJobServiceError({ message: 'Failed to load active execution plan.', cause }),
-        ),
-      )
+      const activePlan = yield* deps.executionPlan
+        .getActivePlanForThread(currentJobRow.threadId)
+        .pipe(
+          Effect.mapError(
+            (cause) => new AutonomousJobServiceError({ message: 'Failed to load active execution plan.', cause }),
+          ),
+        )
 
-    return yield* completeQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, turnResult, activePlan })
-  }).pipe(
-    Effect.catch((error: unknown) =>
-      Effect.gen(function* () {
-        const currentJobRow = autonomousJobRow
-        const currentRunRow = runRow
-        if (!currentJobRow || !currentRunRow) {
-          return yield* new AutonomousJobServiceError({ message: 'Failed to execute autonomous job.', cause: error })
-        }
-        return yield* failQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, error })
-      }),
-    ),
-  )
+      return yield* completeQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, turnResult, activePlan })
+    }).pipe(
+      Effect.catch((error: unknown) =>
+        Effect.gen(function* () {
+          const currentJobRow = yield* Ref.get(autonomousJobRowRef)
+          const currentRunRow = yield* Ref.get(runRowRef)
+          if (!currentJobRow || !currentRunRow) {
+            return yield* new AutonomousJobServiceError({ message: 'Failed to execute autonomous job.', cause: error })
+          }
+          return yield* failQueuedRunEffect(deps, { job, currentJobRow, currentRunRow, error })
+        }),
+      ),
+    )
+  })
 }
 
 function createAutonomousJobService(deps: AutonomousJobDeps) {
@@ -1059,6 +1044,7 @@ interface AutonomousJobDeps {
   executionPlan: ReturnType<typeof makeExecutionPlanService>
   queueJob: ReturnType<typeof makeQueueJobService>
   thread: ReturnType<typeof makeThreadService>
+  autonomousJobQueue: AutonomousJobQueueRuntime
 }
 
 export function makeAutonomousJobService(deps: AutonomousJobDeps) {
@@ -1068,7 +1054,7 @@ export function makeAutonomousJobService(deps: AutonomousJobDeps) {
 export class AutonomousJobServiceTag extends Context.Service<
   AutonomousJobServiceTag,
   ReturnType<typeof makeAutonomousJobService>
->()('AutonomousJobService') {}
+>()('@lota-sdk/core/AutonomousJobService') {}
 
 export const AutonomousJobServiceLive = Layer.effect(
   AutonomousJobServiceTag,
@@ -1078,6 +1064,14 @@ export const AutonomousJobServiceLive = Layer.effect(
     const executionPlan = yield* ExecutionPlanServiceTag
     const queueJob = yield* QueueJobServiceTag
     const thread = yield* ThreadServiceTag
-    return makeAutonomousJobService({ db, config, executionPlan, queueJob, thread })
+    const queues = yield* LotaQueuesServiceTag
+    return makeAutonomousJobService({
+      db,
+      config,
+      executionPlan,
+      queueJob,
+      thread,
+      autonomousJobQueue: queues.autonomousJob,
+    })
   }),
 )

package/src/services/background-work.service.ts

@@ -0,0 +1,54 @@
+import { Context, Effect, FiberSet, Layer, Schema } from 'effect'
+
+/**
+ * Tagged error for the BackgroundWorkService surface. The service itself
+ * never returns this — it's reserved for future API extensions.
+ */
+export class BackgroundWorkError extends Schema.TaggedErrorClass<BackgroundWorkError>()(
+  '@lota-sdk/core/BackgroundWorkError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
+/**
+ * Supervised fire-and-forget fork pool.
+ *
+ * `run` schedules an effect on a process-wide FiberSet that is interrupted
+ * when the runtime scope closes — replaces ad-hoc `Effect.runFork`,
+ * `Effect.runForkWith`, and `Effect.forkDetach` call sites that would
+ * otherwise leak fibers across shutdown.
+ *
+ * Both methods accept any `Effect.Effect<A, E>`; failures are logged via
+ * `Effect.logError` and never propagate to the caller. `runForget` ignores
+ * both the result and the cause — use it for best-effort metrics, cache
+ * touches, and other strictly cosmetic side effects.
+ */
+export class BackgroundWorkService extends Context.Service<
+  BackgroundWorkService,
+  {
+    readonly run: <A, E>(effect: Effect.Effect<A, E>, label?: string) => Effect.Effect<void>
+    readonly runForget: <A, E>(effect: Effect.Effect<A, E>, label?: string) => Effect.Effect<void>
+  }
+>()('@lota-sdk/core/BackgroundWorkService') {}
+
+export const BackgroundWorkServiceLive = Layer.effect(
+  BackgroundWorkService,
+  Effect.gen(function* () {
+    const set = yield* FiberSet.make<unknown, unknown>()
+
+    const run = <A, E>(effect: Effect.Effect<A, E>, label?: string): Effect.Effect<void> =>
+      Effect.asVoid(
+        FiberSet.run(
+          set,
+          effect.pipe(
+            Effect.withLogSpan(label ?? 'background'),
+            Effect.catchCause((cause) => Effect.logError(cause)),
+          ),
+        ),
+      )
+
+    const runForget = <A, E>(effect: Effect.Effect<A, E>, label?: string): Effect.Effect<void> =>
+      Effect.asVoid(FiberSet.run(set, effect.pipe(Effect.withLogSpan(label ?? 'background-forget'), Effect.ignore)))
+
+    return { run, runForget } as const
+  }),
+)

package/src/services/chat-run-registry.service.ts

@@ -2,7 +2,9 @@ import { Context, Effect, FiberMap, Layer } from 'effect'
 
 import { ChatRunRegistry } from '../runtime/chat-run-registry'
 
-export class ChatRunRegistryTag extends Context.Service<ChatRunRegistryTag, ChatRunRegistry>()('ChatRunRegistry') {}
+export class ChatRunRegistryTag extends Context.Service<ChatRunRegistryTag, ChatRunRegistry>()(
+  '@lota-sdk/core/ChatRunRegistry',
+) {}
 
 export const ChatRunRegistryLive = Layer.effect(
   ChatRunRegistryTag,

package/src/services/context-compaction.service.ts

@@ -77,14 +77,12 @@ export function makeContextCompactionService(deps: ContextCompactionDeps) {
               typeof thread.lastCompactedMessageId === 'string' ? thread.lastCompactedMessageId : undefined,
             )
 
-            const result = yield* Effect.tryPromise(() =>
-              contextCompactionRuntime.compactHistory({
-                summaryText: typeof thread.compactionSummary === 'string' ? thread.compactionSummary : '',
-                liveMessages,
-                tailMessageCount: THREAD_RAW_TAIL_MESSAGES,
-                contextSize: params.contextSize,
-              }),
-            )
+            const result = yield* contextCompactionRuntime.compactHistory({
+              summaryText: typeof thread.compactionSummary === 'string' ? thread.compactionSummary : '',
+              liveMessages,
+              tailMessageCount: THREAD_RAW_TAIL_MESSAGES,
+              contextSize: params.contextSize,
+            })
 
             if (!result.compacted || !result.lastCompactedMessageId) {
               return { compacted: false }
@@ -122,7 +120,7 @@ export function makeContextCompactionService(deps: ContextCompactionDeps) {
     })
 
   const compactMemoryBlockEffect = (params: { previousSummary: string; newEntriesText: string }) =>
-    Effect.tryPromise(() => contextCompactionRuntime.compactMemoryBlockSummary(params))
+    contextCompactionRuntime.compactMemoryBlockSummary(params)
 
   return {
     createSummaryMessage(summaryText: string) {
@@ -146,7 +144,7 @@ export function makeContextCompactionService(deps: ContextCompactionDeps) {
 export class ContextCompactionServiceTag extends Context.Service<
   ContextCompactionServiceTag,
   ReturnType<typeof makeContextCompactionService>
->()('ContextCompactionService') {}
+>()('@lota-sdk/core/ContextCompactionService') {}
 
 export const ContextCompactionServiceLive = Layer.effect(
   ContextCompactionServiceTag,

package/src/services/document-chunk.service.ts

@@ -2,6 +2,7 @@ import { Context, Schema, Effect, Layer } from 'effect'
 
 import { chunkMarkdownDocument, chunkPagedDocument, chunkPlainTextDocument } from '../document/org-document-chunking'
 import type { ParsedDocumentChunk } from '../document/org-document-chunking'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { RuntimeConfigServiceTag } from '../effect/services'
 import { ProviderEmbeddings } from '../embeddings/provider'
 import { sha256Hex } from '../utils/crypto'
@@ -71,25 +72,15 @@ class DocumentChunkServiceError extends Schema.TaggedErrorClass<DocumentChunkSer
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
+const effectTryDocumentChunkPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new DocumentChunkServiceError({ message, cause }),
+)
+
 function tryDocumentChunkPromise<A>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, DocumentChunkServiceError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new DocumentChunkServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new DocumentChunkServiceError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new DocumentChunkServiceError({ message, cause }))
-    }
-  })
+  return effectTryDocumentChunkPromise(evaluate, message)
 }
 
 export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): DocumentChunkService {
@@ -200,7 +191,7 @@ export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): D
 }
 
 export class DocumentChunkServiceTag extends Context.Service<DocumentChunkServiceTag, DocumentChunkService>()(
-  'DocumentChunkService',
+  '@lota-sdk/core/DocumentChunkService',
 ) {}
 
 export const DocumentChunkServiceLive = Layer.effect(