@lota-sdk/core 0.4.8 → 0.4.10

package/src/embeddings/provider.ts

@@ -1,12 +1,9 @@
 import { embed, embedMany } from 'ai'
+import { Schema, Effect } from 'effect'
 
-import { getEmbeddingCache } from '../ai/embedding-cache'
-import {
-  getDirectOpenRouterProvider,
-  normalizeDirectOpenRouterModelId,
-  resetDirectOpenRouterProviderForTests,
-} from '../openrouter/direct-provider'
-import { getRuntimeConfig } from '../runtime/runtime-config'
+import { ConfigurationError } from '../effect/errors'
+import { runPromiseWithOptionalLotaRuntime } from '../effect/runtime'
+import { getDirectOpenRouterProvider, normalizeDirectOpenRouterModelId } from '../openrouter/direct-provider'
 
 const SUPPORTED_EMBEDDING_PREFIXES = ['openai/', 'openrouter/'] as const
 
@@ -19,85 +16,128 @@ type ProviderEmbeddingsOptions = {
   embedFn?: typeof embed
   embedManyFn?: typeof embedMany
   getCache?: () => SharedEmbeddingCache | null
-  modelId?: string
+  modelId: string
+  openRouterApiKey?: string
 }
 
-function resolveEmbeddingModel(modelId: string) {
+function resolveEmbeddingModel(modelId: string, openRouterApiKey?: string) {
   const normalized = modelId.trim()
   if (!normalized) {
-    throw new Error('[embeddings-provider] Model id is required.')
+    throw new ConfigurationError({ message: '[embeddings-provider] Model id is required.', key: 'embeddingModelId' })
   }
 
   if (!SUPPORTED_EMBEDDING_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
-    throw new Error(
-      `[embeddings-provider] Unsupported model id "${modelId}". Use one of: ${SUPPORTED_EMBEDDING_PREFIXES.join(', ')}*.`,
-    )
+    throw new ConfigurationError({
+      message: `[embeddings-provider] Unsupported model id "${modelId}". Use one of: ${SUPPORTED_EMBEDDING_PREFIXES.join(', ')}*.`,
+      key: 'embeddingModelId',
+    })
   }
 
-  return getDirectOpenRouterProvider().embeddingModel(normalizeDirectOpenRouterModelId(normalized))
+  return getDirectOpenRouterProvider(openRouterApiKey).embeddingModel(normalizeDirectOpenRouterModelId(normalized))
 }
 
 function normalizeEmbedding(embedding: readonly number[]): number[] {
   return embedding.map((value) => Number(value))
 }
 
+class EmbeddingProviderError extends Schema.TaggedErrorClass<EmbeddingProviderError>()('EmbeddingProviderError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function tryEmbeddingPromise<A>(
+  message: string,
+  thunk: () => PromiseLike<A>,
+): Effect.Effect<A, EmbeddingProviderError> {
+  return Effect.tryPromise({
+    try: () => Promise.resolve(thunk()),
+    catch: (cause) => new EmbeddingProviderError({ message, cause }),
+  })
+}
+
 export class ProviderEmbeddings {
   private readonly embedFn: typeof embed
   private readonly embedManyFn: typeof embedMany
   private readonly getCache: () => SharedEmbeddingCache | null
-  private readonly configuredModelId?: string
-  private resolvedModelId: string | null = null
+  private readonly resolvedModelId: string
   private _model: ReturnType<typeof resolveEmbeddingModel> | null = null
+  /** In-flight dedup: concurrent embedQuery calls for the same text share one API round-trip. */
+  private readonly inflightEmbeddings = new Map<string, Promise<number[]>>()
 
-  constructor(options: ProviderEmbeddingsOptions = {}) {
+  private readonly openRouterApiKey: string | undefined
+
+  constructor(options: ProviderEmbeddingsOptions) {
     this.embedFn = options.embedFn ?? embed
     this.embedManyFn = options.embedManyFn ?? embedMany
-    this.getCache = options.getCache ?? getEmbeddingCache
-    this.configuredModelId = options.modelId
+    this.getCache = options.getCache ?? (() => null)
+    this.resolvedModelId = options.modelId
+    this.openRouterApiKey = options.openRouterApiKey
   }
 
   private getModelId(): string {
-    if (!this.resolvedModelId) {
-      this.resolvedModelId = this.configuredModelId ?? getRuntimeConfig().aiGateway.embeddingModel
-    }
-
     return this.resolvedModelId
   }
 
   private getModel() {
     if (!this._model) {
-      this._model = resolveEmbeddingModel(this.getModelId())
+      this._model = resolveEmbeddingModel(this.getModelId(), this.openRouterApiKey)
     }
     return this._model
   }
 
-  private async loadCachedEmbedding(text: string): Promise<number[] | null> {
+  private loadCachedEmbedding(text: string): Promise<number[] | null> {
     const redisCache = this.getCache()
-    if (!redisCache) return null
+    if (!redisCache) return Promise.resolve(null)
 
     return redisCache.get(this.getModelId(), text)
   }
 
-  async embedQuery(text: string): Promise<number[]> {
+  private runEffect<A>(effect: Effect.Effect<A, EmbeddingProviderError>): Promise<A> {
+    return runPromiseWithOptionalLotaRuntime(effect)
+  }
+
+  embedQuery(text: string): Promise<number[]> {
     const input = text.trim()
-    if (!input) return []
+    if (!input) return Promise.resolve([])
 
-    const cached = await this.loadCachedEmbedding(input)
-    if (cached) return cached
+    const dedupKey = `${this.getModelId()}:${input}`
+    const pending = this.inflightEmbeddings.get(dedupKey)
+    if (pending) return pending
 
-    const result = await this.embedFn({ model: this.getModel(), value: input, maxRetries: 2 })
-    const embedding = normalizeEmbedding(result.embedding)
+    const promise = this.runEffect(this.executeEmbedQueryEffect(input))
+    this.inflightEmbeddings.set(dedupKey, promise)
+    void promise.finally(() => this.inflightEmbeddings.delete(dedupKey))
 
-    const redisCache = this.getCache()
-    if (redisCache) {
-      void redisCache.set(this.getModelId(), input, embedding)
-    }
+    return promise
+  }
+
+  private executeEmbedQueryEffect(input: string): Effect.Effect<number[], EmbeddingProviderError> {
+    return Effect.gen(
+      function* (this: ProviderEmbeddings) {
+        const cached = yield* tryEmbeddingPromise('Failed to load cached query embedding.', () =>
+          this.loadCachedEmbedding(input),
+        )
+        if (cached) {
+          return cached
+        }
+
+        const result = yield* tryEmbeddingPromise('Failed to generate query embedding.', () =>
+          this.embedFn({ model: this.getModel(), value: input, maxRetries: 2 }),
+        )
+        const embedding = normalizeEmbedding(result.embedding)
+
+        const redisCache = this.getCache()
+        if (redisCache) {
+          void redisCache.set(this.getModelId(), input, embedding)
+        }
 
-    return embedding
+        return embedding
+      }.bind(this),
+    ).pipe(Effect.withSpan('ProviderEmbeddings.executeEmbedQuery'))
   }
 
-  async embedDocuments(values: string[]): Promise<number[][]> {
-    if (values.length === 0) return []
+  embedDocuments(values: string[]): Promise<number[][]> {
+    if (values.length === 0) return Promise.resolve([])
 
     const normalized = values.map((value) => value.trim())
     const nonEmptyEntries = normalized
@@ -105,57 +145,62 @@ export class ProviderEmbeddings {
       .filter((entry) => entry.value.length > 0)
 
     if (nonEmptyEntries.length === 0) {
-      return normalized.map(() => [])
+      return Promise.resolve(normalized.map(() => []))
     }
 
     const uniqueTexts = [...new Set(nonEmptyEntries.map((entry) => entry.value))]
-    const embeddingsByText = new Map<string, number[]>()
-    let missingTexts = [...uniqueTexts]
+    return this.runEffect(this.embedDocumentsEffect(normalized, uniqueTexts))
+  }
 
-    const redisCache = this.getCache()
-    if (redisCache && missingTexts.length > 0) {
-      const redisResults = await Promise.all(
-        missingTexts.map(async (text) => ({ text, embedding: await redisCache.get(this.getModelId(), text) })),
-      )
-
-      missingTexts = []
-      for (const result of redisResults) {
-        if (!result.embedding) {
-          missingTexts.push(result.text)
-          continue
+  private embedDocumentsEffect(
+    normalized: string[],
+    uniqueTexts: string[],
+  ): Effect.Effect<number[][], EmbeddingProviderError> {
+    return Effect.gen(
+      function* (this: ProviderEmbeddings) {
+        const embeddingsByText = new Map<string, number[]>()
+        let missingTexts = [...uniqueTexts]
+        const redisCache = this.getCache()
+        const redisResults =
+          redisCache && missingTexts.length > 0
+            ? yield* Effect.all(
+                missingTexts.map((text) =>
+                  tryEmbeddingPromise('Failed to load cached document embedding.', () =>
+                    redisCache.get(this.getModelId(), text),
+                  ).pipe(Effect.map((embedding) => ({ text, embedding }))),
+                ),
+              )
+            : ([] as Array<{ text: string; embedding: number[] | null }>)
+
+        if (redisCache && missingTexts.length > 0) {
+          missingTexts = []
+          for (const result of redisResults) {
+            if (!result.embedding) {
+              missingTexts.push(result.text)
+              continue
+            }
+
+            embeddingsByText.set(result.text, result.embedding)
+          }
         }
 
-        embeddingsByText.set(result.text, result.embedding)
-      }
-    }
-
-    if (missingTexts.length > 0) {
-      const result = await this.embedManyFn({ model: this.getModel(), values: missingTexts, maxRetries: 2 })
-
-      missingTexts.forEach((text, index) => {
-        const embedding = normalizeEmbedding(result.embeddings[index] ?? [])
-        embeddingsByText.set(text, embedding)
-        if (redisCache) {
-          void redisCache.set(this.getModelId(), text, embedding)
+        if (missingTexts.length === 0) {
+          return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
         }
-      })
-    }
 
-    return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
+        const result = yield* tryEmbeddingPromise('Failed to generate document embeddings.', () =>
+          this.embedManyFn({ model: this.getModel(), values: missingTexts, maxRetries: 2 }),
+        )
+        missingTexts.forEach((text, index) => {
+          const embedding = normalizeEmbedding(result.embeddings[index] ?? [])
+          embeddingsByText.set(text, embedding)
+          if (redisCache) {
+            void redisCache.set(this.getModelId(), text, embedding)
+          }
+        })
+
+        return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
+      }.bind(this),
+    ).pipe(Effect.withSpan('ProviderEmbeddings.embedDocuments'))
   }
 }
-
-let defaultEmbeddings: ProviderEmbeddings | null = null
-
-export function getDefaultEmbeddings(): ProviderEmbeddings {
-  if (!defaultEmbeddings) {
-    defaultEmbeddings = new ProviderEmbeddings()
-  }
-
-  return defaultEmbeddings
-}
-
-export function resetDefaultEmbeddingsForTests(): void {
-  defaultEmbeddings = null
-  resetDirectOpenRouterProviderForTests()
-}

package/src/index.ts

@@ -6,10 +6,57 @@ export * from './db'
 export * from './document'
 export * from './queues'
 export * from './redis'
-export * from './runtime/index'
+export * from './runtime'
 export * from './services'
 export * from './storage'
 export * from './system-agents'
 export * from './tools'
 export * from './utils'
 export * from './workers'
+export { Effect } from 'effect'
+export {
+  ActiveThreadRunConflictError,
+  AgentConfigLive,
+  AgentFactoryLive,
+  AiGenerationError,
+  AppLoggerLive,
+  AppLoggerTag,
+  BaseServicePersistenceError,
+  ConfigurationError,
+  ConflictError,
+  DatabaseError,
+  DatabaseLive,
+  DatabaseServiceTag as EffectDatabaseService,
+  ForbiddenError,
+  LockAcquisitionError,
+  LockLostError,
+  RedisError,
+  RedisLive,
+  RedisServiceTag as EffectRedisService,
+  RuntimeAdaptersServiceTag,
+  RuntimeConfigLive,
+  RuntimeConfigServiceTag,
+  RuntimeExtensionsLive,
+  RuntimeWorkerExtensionsServiceTag,
+  ServiceError,
+  ThreadConfigLive,
+  ThreadConfigServiceTag,
+  ThreadTurnError,
+  TimeoutError,
+  ToolProvidersServiceTag,
+  TurnHooksServiceTag,
+  ValidationError,
+  clearLotaSdkRuntime,
+  getLotaSdkRuntime,
+  isEffectError,
+  setLotaSdkRuntime,
+  summarizeZodIssues,
+  toAwaitableEffect,
+  toAwaitableService,
+  toValidationError,
+  toValidationIssues,
+  zodParse,
+} from './effect'
+export { AppError, BadRequestError, NotFoundError } from './utils'
+export type { AppErrorLike, AppErrorResponse } from './utils'
+export type { EffectError, ValidationIssue } from './effect'

package/src/openrouter/direct-provider.ts

@@ -1,53 +1,29 @@
 import { createOpenAI } from '@ai-sdk/openai'
 
-import { getRuntimeConfig } from '../runtime/runtime-config'
+import { ConfigurationError } from '../effect/errors'
 
 const DIRECT_OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1' as const
 const OPENROUTER_MODEL_PREFIX = 'openrouter/' as const
 
-let directOpenRouterProvider: ReturnType<typeof createOpenAI> | null = null
-let directOpenRouterProviderKey: string | null = null
+export function resolveOpenRouterApiKey(openRouterApiKey: string | undefined): string {
+  const key = openRouterApiKey?.trim()
+  if (key) return key
 
-function readConfiguredOpenRouterApiKey(): string | null {
-  try {
-    return getRuntimeConfig().aiGateway.openRouterApiKey?.trim() || null
-  } catch {
-    return null
-  }
-}
-
-export function resolveOpenRouterApiKey(): string {
-  const configured = readConfiguredOpenRouterApiKey()
-  if (configured) return configured
-
-  const envKey = process.env.OPENROUTER_API_KEY?.trim()
-  if (envKey) return envKey
-
-  throw new Error('Missing OpenRouter API key. Set aiGateway.openRouterApiKey or OPENROUTER_API_KEY.')
+  throw new ConfigurationError({
+    message: 'Missing OpenRouter API key. Configure createLotaRuntime({ aiGateway: { openRouterApiKey } }).',
+    key: 'aiGateway.openRouterApiKey',
+  })
 }
 
 export function normalizeDirectOpenRouterModelId(modelId: string): string {
   const normalized = modelId.trim()
   if (!normalized) {
-    throw new Error('OpenRouter model id is required.')
+    throw new ConfigurationError({ message: 'OpenRouter model id is required.', key: 'openRouterModelId' })
   }
 
   return normalized.startsWith(OPENROUTER_MODEL_PREFIX) ? normalized.slice(OPENROUTER_MODEL_PREFIX.length) : normalized
 }
 
-export function getDirectOpenRouterProvider() {
-  const apiKey = resolveOpenRouterApiKey()
-  if (directOpenRouterProvider && directOpenRouterProviderKey === apiKey) {
-    return directOpenRouterProvider
-  }
-
-  directOpenRouterProvider = createOpenAI({ baseURL: DIRECT_OPENROUTER_BASE_URL, apiKey })
-  directOpenRouterProviderKey = apiKey
-
-  return directOpenRouterProvider
-}
-
-export function resetDirectOpenRouterProviderForTests(): void {
-  directOpenRouterProvider = null
-  directOpenRouterProviderKey = null
+export function getDirectOpenRouterProvider(openRouterApiKey?: string) {
+  return createOpenAI({ baseURL: DIRECT_OPENROUTER_BASE_URL, apiKey: resolveOpenRouterApiKey(openRouterApiKey) })
 }

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

@@ -1,14 +1,22 @@
 import type { AutonomousJobSchedule } from '@lota-sdk/shared'
 import type { Job } from 'bullmq'
+import { Effect, Schema } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-import { databaseService } from '../db/service'
-import { autonomousJobService } from '../services/autonomous-job.service'
-import { queueJobService } from '../services/queue-job.service'
+import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import { AutonomousJobServiceTag } from '../services/autonomous-job.service'
 import { buildAutonomousAtJobId } from '../utils/autonomous-job-ids'
 import type { WorkerHandle } from '../workers/worker-utils'
 import { DEFAULT_JOB_RETENTION } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps, recordEnqueuedJobMetadata } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
+
+class AutonomousJobQueueError extends Schema.TaggedErrorClass<AutonomousJobQueueError>()(
+  '@lota-sdk/core/AutonomousJobQueueError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 export interface AutonomousJobQueuePayload {
   autonomousJobId: string
@@ -18,25 +26,31 @@ export interface AutonomousJobQueuePayload {
 
 export const AUTONOMOUS_JOB_QUEUE = 'autonomous-job'
 
+interface AutonomousJobQueueDeps {
+  databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  autonomousJobService: Context.Service.Shape<typeof AutonomousJobServiceTag>
+}
+
 const DEFAULT_AUTONOMOUS_JOB_OPTIONS = {
   ...DEFAULT_JOB_RETENTION,
   attempts: 3,
   backoff: { type: 'exponential', delay: 5_000 },
 } as const
 
-async function processAutonomousJob(
+function processAutonomousJob(
+  deps: AutonomousJobQueueDeps,
   job: Job<AutonomousJobQueuePayload>,
 ): Promise<{ status: string; summary?: string }> {
-  await databaseService.connect()
-  return autonomousJobService.executeQueuedRun(job)
+  return Effect.runPromise(deps.autonomousJobService.executeQueuedRun(job))
 }
 
-const autonomousJobQueue = createQueueFactory<AutonomousJobQueuePayload>({
+const autonomousJobQueue = createQueueFactoryWithDeps<AutonomousJobQueuePayload, AutonomousJobQueueDeps>({
   name: AUTONOMOUS_JOB_QUEUE,
   displayName: 'Autonomous job',
   jobName: 'run-autonomous-job',
   concurrency: 2,
   defaultJobOptions: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processAutonomousJob,
 })
 
@@ -44,91 +58,121 @@ function buildAutonomousSchedulerId(autonomousJobId: string): string {
   return `autonomous:${autonomousJobId}`
 }
 
-export async function enqueueAutonomousJobRun(params: {
+export function enqueueAutonomousJobRun(params: {
   payload: AutonomousJobQueuePayload
   delayMs?: number
   jobId?: string
 }): Promise<{ bullmqJobId: string; queueJobId?: string }> {
-  const queuedJob = await autonomousJobQueue
-    .getQueue()
-    .add('run-autonomous-job', params.payload, {
-      ...(typeof params.delayMs === 'number' ? { delay: Math.max(0, params.delayMs) } : {}),
-      ...(params.jobId ? { jobId: params.jobId } : {}),
-    })
-
-  const bullmqJobId = String(queuedJob.id)
-  let queueJobId: string | undefined
-
-  try {
-    queueJobId = await queueJobService.recordEnqueued({
-      queueName: AUTONOMOUS_JOB_QUEUE,
-      id: queuedJob.id,
-      name: queuedJob.name,
-      data: queuedJob.data,
-      opts: queuedJob.opts,
-      attemptsMade: queuedJob.attemptsMade,
-      timestamp: queuedJob.timestamp,
-    })
-  } catch (error) {
-    serverLogger.error`Failed to persist queued job metadata (queue=${AUTONOMOUS_JOB_QUEUE}, job=${queuedJob.id}): ${error}`
-  }
-
-  return { bullmqJobId, queueJobId }
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const queuedJob = yield* Effect.tryPromise({
+        try: () =>
+          autonomousJobQueue
+            .getQueue()
+            .add('run-autonomous-job', params.payload, {
+              ...(typeof params.delayMs === 'number' ? { delay: Math.max(0, params.delayMs) } : {}),
+              ...(params.jobId ? { jobId: params.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, job: queuedJob })
+      return { bullmqJobId, queueJobId }
+    }),
+  )
 }
 
-export async function upsertAutonomousJobScheduler(params: {
+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 }
-  const queuedJob = await autonomousJobQueue
-    .getQueue()
-    .upsertJobScheduler(buildAutonomousSchedulerId(params.autonomousJobId), repeatOpts, {
-      name: 'run-autonomous-job',
-      data: { autonomousJobId: params.autonomousJobId, trigger: 'scheduled' },
-      opts: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
-    })
-
-  try {
-    await queueJobService.recordEnqueued({
-      queueName: AUTONOMOUS_JOB_QUEUE,
-      id: queuedJob.id,
-      name: queuedJob.name,
-      data: queuedJob.data,
-      opts: queuedJob.opts,
-      attemptsMade: queuedJob.attemptsMade,
-      timestamp: queuedJob.timestamp,
-    })
-  } catch (error) {
-    serverLogger.error`Failed to persist queued job metadata (queue=${AUTONOMOUS_JOB_QUEUE}, job=${queuedJob.id}): ${error}`
-  }
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const queuedJob = yield* Effect.tryPromise({
+        try: () =>
+          autonomousJobQueue
+            .getQueue()
+            .upsertJobScheduler(buildAutonomousSchedulerId(params.autonomousJobId), repeatOpts, {
+              name: 'run-autonomous-job',
+              data: { autonomousJobId: params.autonomousJobId, trigger: 'scheduled' },
+              opts: DEFAULT_AUTONOMOUS_JOB_OPTIONS,
+            }),
+        catch: (cause) =>
+          new AutonomousJobQueueError({
+            message: `Failed to upsert autonomous job scheduler for ${params.autonomousJobId}.`,
+            cause,
+          }),
+      })
+
+      yield* recordEnqueuedJobMetadata({ queueName: AUTONOMOUS_JOB_QUEUE, job: queuedJob })
+    }),
+  )
 }
 
-export async function removeAutonomousJobScheduler(autonomousJobId: string): Promise<void> {
-  await autonomousJobQueue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId))
+export function removeAutonomousJobScheduler(autonomousJobId: string): Promise<void> {
+  return Effect.runPromise(
+    Effect.asVoid(
+      Effect.tryPromise({
+        try: () => autonomousJobQueue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId)),
+        catch: (cause) =>
+          new AutonomousJobQueueError({
+            message: `Failed to remove autonomous job scheduler for ${autonomousJobId}.`,
+            cause,
+          }),
+      }),
+    ),
+  )
 }
 
-export async function removeAutonomousAtJob(autonomousJobId: string): Promise<void> {
-  try {
-    await autonomousJobQueue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId))
-  } catch {
-    // The delayed job may have already fired or never existed.
-  }
+export function removeAutonomousAtJob(autonomousJobId: string): Promise<void> {
+  return Effect.runPromise(
+    Effect.catch(
+      Effect.asVoid(
+        Effect.tryPromise({
+          try: () => autonomousJobQueue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId)),
+          catch: (cause) =>
+            new AutonomousJobQueueError({
+              message: `Failed to remove autonomous-at job for ${autonomousJobId}.`,
+              cause,
+            }),
+        }),
+      ),
+      () => Effect.void,
+    ),
+  )
 }
 
-type AutonomousJobWorkerOptions = Parameters<typeof autonomousJobQueue.startWorker>[0]
-
-export function startAutonomousJobWorker(options: AutonomousJobWorkerOptions = {}): WorkerHandle {
-  const handle = autonomousJobQueue.startWorker(options)
+interface AutonomousJobWorkerOptions {
+  registerSignals?: boolean
+  connectionProvider: () => IORedis
+  deps: AutonomousJobQueueDeps
+}
 
-  autonomousJobService.recoverActiveJobs().catch((error: unknown) => {
-    serverLogger.error`Autonomous job startup recovery failed: ${error}`
+export function startAutonomousJobWorker(options: AutonomousJobWorkerOptions): WorkerHandle {
+  const handle = autonomousJobQueue.startWorker({
+    deps: options.deps,
+    registerSignals: options.registerSignals,
+    connectionProvider: options.connectionProvider,
   })
 
+  void Effect.runPromise(
+    Effect.catch(options.deps.autonomousJobService.recoverActiveJobs(), (error) =>
+      Effect.sync(() => {
+        serverLogger.error`Autonomous job startup recovery failed: ${error}`
+      }),
+    ),
+  )
+
   return handle
 }
 
-if (import.meta.main) {
-  startAutonomousJobWorker()
-}
+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) },
+  })
+})