@lota-sdk/core 0.4.9 → 0.4.10

package/src/embeddings/provider.ts

@@ -2,7 +2,7 @@ import { embed, embedMany } from 'ai'
 import { Schema, Effect } from 'effect'
 
 import { ConfigurationError } from '../effect/errors'
-import { getOptionalCurrentRuntime } from '../effect/runtime-ref'
+import { runPromiseWithOptionalLotaRuntime } from '../effect/runtime'
 import { getDirectOpenRouterProvider, normalizeDirectOpenRouterModelId } from '../openrouter/direct-provider'
 
 const SUPPORTED_EMBEDDING_PREFIXES = ['openai/', 'openrouter/'] as const
@@ -93,8 +93,7 @@ export class ProviderEmbeddings {
   }
 
   private runEffect<A>(effect: Effect.Effect<A, EmbeddingProviderError>): Promise<A> {
-    const runtime = getOptionalCurrentRuntime()
-    return runtime ? runtime.runPromise(effect) : Effect.runPromise(effect)
+    return runPromiseWithOptionalLotaRuntime(effect)
   }
 
   embedQuery(text: string): Promise<number[]> {
@@ -113,28 +112,28 @@ export class ProviderEmbeddings {
   }
 
   private executeEmbedQueryEffect(input: string): Effect.Effect<number[], EmbeddingProviderError> {
-    const self = this
-
-    return Effect.gen(function* () {
-      const cached = yield* tryEmbeddingPromise('Failed to load cached query embedding.', () =>
-        self.loadCachedEmbedding(input),
-      )
-      if (cached) {
-        return cached
-      }
-
-      const result = yield* tryEmbeddingPromise('Failed to generate query embedding.', () =>
-        self.embedFn({ model: self.getModel(), value: input, maxRetries: 2 }),
-      )
-      const embedding = normalizeEmbedding(result.embedding)
-
-      const redisCache = self.getCache()
-      if (redisCache) {
-        void redisCache.set(self.getModelId(), input, embedding)
-      }
-
-      return embedding
-    }).pipe(Effect.withSpan('ProviderEmbeddings.executeEmbedQuery'))
+    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
+      }.bind(this),
+    ).pipe(Effect.withSpan('ProviderEmbeddings.executeEmbedQuery'))
   }
 
   embedDocuments(values: string[]): Promise<number[][]> {
@@ -157,51 +156,51 @@ export class ProviderEmbeddings {
     normalized: string[],
     uniqueTexts: string[],
   ): Effect.Effect<number[][], EmbeddingProviderError> {
-    const self = this
-
-    return Effect.gen(function* () {
-      const embeddingsByText = new Map<string, number[]>()
-      let missingTexts = [...uniqueTexts]
-      const redisCache = self.getCache()
-      const redisResults =
-        redisCache && missingTexts.length > 0
-          ? yield* Effect.all(
-              missingTexts.map((text) =>
-                tryEmbeddingPromise('Failed to load cached document embedding.', () =>
-                  redisCache.get(self.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
+    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) {
-        return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
-      }
-
-      const result = yield* tryEmbeddingPromise('Failed to generate document embeddings.', () =>
-        self.embedManyFn({ model: self.getModel(), values: missingTexts, maxRetries: 2 }),
-      )
-      missingTexts.forEach((text, index) => {
-        const embedding = normalizeEmbedding(result.embeddings[index] ?? [])
-        embeddingsByText.set(text, embedding)
-        if (redisCache) {
-          void redisCache.set(self.getModelId(), text, embedding)
+        if (missingTexts.length === 0) {
+          return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
         }
-      })
 
-      return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
-    }).pipe(Effect.withSpan('ProviderEmbeddings.embedDocuments'))
+        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'))
   }
 }

package/src/index.ts

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

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

@@ -1,19 +1,23 @@
 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 { 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 { DEFAULT_JOB_RETENTION } from '../workers/worker-utils'
+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
   autonomousJobRunId?: string
@@ -27,33 +31,26 @@ interface AutonomousJobQueueDeps {
   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
-}
-
 const DEFAULT_AUTONOMOUS_JOB_OPTIONS = {
   ...DEFAULT_JOB_RETENTION,
   attempts: 3,
   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: AutonomousJobQueueDeps,
+  job: Job<AutonomousJobQueuePayload>,
+): Promise<{ status: string; summary?: string }> {
+  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: () => getDeps().databaseService.connect(),
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processAutonomousJob,
 })
 
@@ -68,32 +65,19 @@ export function enqueueAutonomousJobRun(params: {
 }): 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 } : {}),
-          }),
-      )
+      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* 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
-          }),
-      )
+      const queueJobId = yield* recordEnqueuedJobMetadata({ queueName: AUTONOMOUS_JOB_QUEUE, job: queuedJob })
       return { bullmqJobId, queueJobId }
     }),
   )
@@ -107,31 +91,23 @@ export function upsertAutonomousJobScheduler(params: {
     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,
+      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* 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}`
-          }),
-      )
+      })
+
+      yield* recordEnqueuedJobMetadata({ queueName: AUTONOMOUS_JOB_QUEUE, job: queuedJob })
     }),
   )
 }
@@ -139,9 +115,14 @@ export function upsertAutonomousJobScheduler(params: {
 export function removeAutonomousJobScheduler(autonomousJobId: string): Promise<void> {
   return Effect.runPromise(
     Effect.asVoid(
-      Effect.tryPromise(() =>
-        autonomousJobQueue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId)),
-      ),
+      Effect.tryPromise({
+        try: () => autonomousJobQueue.getQueue().removeJobScheduler(buildAutonomousSchedulerId(autonomousJobId)),
+        catch: (cause) =>
+          new AutonomousJobQueueError({
+            message: `Failed to remove autonomous job scheduler for ${autonomousJobId}.`,
+            cause,
+          }),
+      }),
     ),
   )
 }
@@ -150,7 +131,14 @@ export function removeAutonomousAtJob(autonomousJobId: string): Promise<void> {
   return Effect.runPromise(
     Effect.catch(
       Effect.asVoid(
-        Effect.tryPromise(() => autonomousJobQueue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId))),
+        Effect.tryPromise({
+          try: () => autonomousJobQueue.getQueue().remove(buildAutonomousAtJobId(autonomousJobId)),
+          catch: (cause) =>
+            new AutonomousJobQueueError({
+              message: `Failed to remove autonomous-at job for ${autonomousJobId}.`,
+              cause,
+            }),
+        }),
       ),
       () => Effect.void,
     ),
@@ -164,8 +152,8 @@ interface AutonomousJobWorkerOptions {
 }
 
 export function startAutonomousJobWorker(options: AutonomousJobWorkerOptions): WorkerHandle {
-  _deps = options.deps
   const handle = autonomousJobQueue.startWorker({
+    deps: options.deps,
     registerSignals: options.registerSignals,
     connectionProvider: options.connectionProvider,
   })

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

@@ -5,11 +5,10 @@ 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 { ThreadServiceTag } from '../services/thread/thread.service'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 interface ContextCompactionJob {
@@ -24,19 +23,8 @@ interface ContextCompactionQueueDeps {
   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: ContextCompactionQueueDeps, job: Job<ContextCompactionJob>): Promise<void> {
+  const { threadService, contextCompactionService } = deps
   const { entityId, contextSize } = job.data
   const threadRef = ensureRecordId(entityId, TABLES.THREAD)
   return Effect.runPromise(
@@ -52,14 +40,14 @@ function processContextCompactionJob(job: Job<ContextCompactionJob>): Promise<vo
   )
 }
 
-const contextCompaction = createQueueFactory<ContextCompactionJob>({
+const contextCompaction = createQueueFactoryWithDeps<ContextCompactionJob, ContextCompactionQueueDeps>({
   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(),
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processContextCompactionJob,
 })
 
@@ -72,8 +60,8 @@ export function startContextCompactionWorker(options: {
   connectionProvider: () => IORedis
   deps: ContextCompactionQueueDeps
 }): ReturnType<typeof contextCompaction.startWorker> {
-  _deps = options.deps
   return contextCompaction.startWorker({
+    deps: options.deps,
     registerSignals: options.registerSignals,
     connectionProvider: options.connectionProvider,
   })

package/src/queues/delayed-node-promotion.queue.ts

@@ -3,10 +3,9 @@ import { Effect } from 'effect'
 import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
 import { PlanExecutorServiceTag } from '../services/plan/plan-executor.service'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 export interface DelayedNodePromotionJob {
@@ -22,18 +21,11 @@ interface DelayedNodePromotionQueueDeps {
   planExecutorService: Context.Service.Shape<typeof PlanExecutorServiceTag>
 }
 
-let _deps: DelayedNodePromotionQueueDeps | null = null
-function getDeps(): DelayedNodePromotionQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Delayed node promotion queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
-}
-
-function processDelayedNodePromotionJob(job: Job<DelayedNodePromotionJob>): Promise<void> {
-  const { planExecutorService } = getDeps()
+function processDelayedNodePromotionJob(
+  deps: DelayedNodePromotionQueueDeps,
+  job: Job<DelayedNodePromotionJob>,
+): Promise<void> {
+  const { planExecutorService } = deps
   return Promise.resolve(
     planExecutorService.promoteDelayedNode({
       runId: job.data.runId,
@@ -43,13 +35,13 @@ function processDelayedNodePromotionJob(job: Job<DelayedNodePromotionJob>): Prom
   ).then(() => undefined)
 }
 
-const delayedNodePromotion = createQueueFactory<DelayedNodePromotionJob>({
+const delayedNodePromotion = createQueueFactoryWithDeps<DelayedNodePromotionJob, DelayedNodePromotionQueueDeps>({
   name: DELAYED_NODE_PROMOTION_QUEUE,
   displayName: 'Delayed node promotion',
   jobName: 'promote-node',
   concurrency: 1,
   defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 5000 } },
-  prepare: () => getDeps().databaseService.connect(),
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processDelayedNodePromotionJob,
 })
 
@@ -62,8 +54,8 @@ export function startDelayedNodePromotionWorker(options: {
   connectionProvider: () => IORedis
   deps: DelayedNodePromotionQueueDeps
 }): ReturnType<typeof delayedNodePromotion.startWorker> {
-  _deps = options.deps
   return delayedNodePromotion.startWorker({
+    deps: options.deps,
     registerSignals: options.registerSignals,
     connectionProvider: options.connectionProvider,
   })

package/src/queues/organization-learning.queue.ts

@@ -1,9 +1,14 @@
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 
 import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
+class OrganizationLearningQueueError extends Schema.TaggedErrorClass<OrganizationLearningQueueError>()(
+  '@lota-sdk/core/OrganizationLearningQueueError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
 export const ORGANIZATION_LEARNING_QUEUE = 'organization-learning'
 
 const ORGANIZATION_LEARNING_DELAY_MS = 15 * 60 * 1000
@@ -73,9 +78,17 @@ export function enqueueSkillExtraction(job: Omit<SkillExtractionJob, 'kind'>) {
 export function clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void> {
   return Effect.runPromise(
     Effect.asVoid(
-      Effect.tryPromise(() =>
-        organizationLearningQueue.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId)),
-      ),
+      Effect.tryPromise({
+        try: () =>
+          organizationLearningQueue
+            .getQueue()
+            .removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId)),
+        catch: (cause) =>
+          new OrganizationLearningQueueError({
+            message: `Failed to clear regular-chat memory digest deduplication key for ${orgId}.`,
+            cause,
+          }),
+      }),
     ),
   )
 }