@lota-sdk/core 0.4.12 → 0.4.14

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

@@ -22,8 +22,8 @@ export class BackgroundWorkError extends Schema.TaggedErrorClass<BackgroundWorkE
  * 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,
+export class BackgroundWorkServiceTag extends Context.Service<
+  BackgroundWorkServiceTag,
   {
     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>
@@ -31,7 +31,7 @@ export class BackgroundWorkService extends Context.Service<
 >()('@lota-sdk/core/BackgroundWorkService') {}
 
 export const BackgroundWorkServiceLive = Layer.effect(
-  BackgroundWorkService,
+  BackgroundWorkServiceTag,
   Effect.gen(function* () {
     const set = yield* FiberSet.make<unknown, unknown>()
 

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

@@ -1,6 +1,8 @@
 import type { ChatMessage } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
+import { AiGatewayModelsTag } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { chatLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
@@ -43,12 +45,14 @@ interface ContextCompactionDeps {
   redis: RedisConnectionManager
   threadMessageService: ReturnType<typeof makeThreadMessageService>
   helperModelRuntime: HelperModelRuntime
+  aiGatewayModels: AiGatewayModels
 }
 
 export function makeContextCompactionService(deps: ContextCompactionDeps) {
-  const { db, redis, threadMessageService, helperModelRuntime } = deps
+  const { db, redis, threadMessageService, helperModelRuntime, aiGatewayModels } = deps
   const contextCompactionRuntime = createWiredContextCompactionRuntime({
     helperModelRuntime,
+    aiGatewayModels,
     now: nowEpochMillis,
     randomId: () => Bun.randomUUIDv7(),
   })
@@ -153,6 +157,7 @@ export const ContextCompactionServiceLive = Layer.effect(
     const redis = yield* RedisServiceTag
     const threadMessageService = yield* ThreadMessageServiceTag
     const helperModelRuntime = yield* HelperModelTag
-    return makeContextCompactionService({ db, redis, threadMessageService, helperModelRuntime })
+    const aiGatewayModels = yield* AiGatewayModelsTag
+    return makeContextCompactionService({ db, redis, threadMessageService, helperModelRuntime, aiGatewayModels })
   }),
 )

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

@@ -1,8 +1,9 @@
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import { RuntimeBridgeTag } from '../ai-gateway/ai-gateway'
+import type { RuntimeBridge } from '../ai-gateway/ai-gateway'
 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'
@@ -13,8 +14,12 @@ type DocumentChunkEmbeddings = {
   embedQuery(query: string): Promise<number[]>
 }
 
-function createDocumentChunkEmbeddings(embeddingModel: string, openRouterApiKey?: string): DocumentChunkEmbeddings {
-  const embeddings = new ProviderEmbeddings({ modelId: embeddingModel, openRouterApiKey })
+function createDocumentChunkEmbeddings(
+  embeddingModel: string,
+  runPromise: RuntimeBridge['runPromise'],
+  openRouterApiKey?: string,
+): DocumentChunkEmbeddings {
+  const embeddings = new ProviderEmbeddings({ modelId: embeddingModel, openRouterApiKey, runPromise })
 
   return {
     embedDocuments: (documents) => embeddings.embedDocuments(documents),
@@ -68,21 +73,10 @@ export interface DocumentChunkService {
 }
 
 class DocumentChunkServiceError extends Schema.TaggedErrorClass<DocumentChunkServiceError>()(
-  'DocumentChunkServiceError',
+  '@lota-sdk/core/DocumentChunkServiceError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
-const effectTryDocumentChunkPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new DocumentChunkServiceError({ message, cause }),
-)
-
-function tryDocumentChunkPromise<A>(
-  message: string,
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, DocumentChunkServiceError> {
-  return effectTryDocumentChunkPromise(evaluate, message)
-}
-
 export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): DocumentChunkService {
   return {
     buildChunks(params) {
@@ -116,10 +110,15 @@ export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): D
     syncVersionedChunks(params) {
       return Effect.gen(function* () {
         const [existingRows, embeddedChunks] = yield* Effect.all([
-          tryDocumentChunkPromise('Failed to load existing document chunks.', () => params.loadExisting()),
-          tryDocumentChunkPromise('Failed to embed document chunks.', () =>
-            embeddings.embedDocuments(params.chunks.map((chunk) => chunk.content)),
-          ),
+          Effect.tryPromise({
+            try: () => params.loadExisting(),
+            catch: (cause) =>
+              new DocumentChunkServiceError({ message: 'Failed to load existing document chunks.', cause }),
+          }),
+          Effect.tryPromise({
+            try: () => embeddings.embedDocuments(params.chunks.map((chunk) => chunk.content)),
+            catch: (cause) => new DocumentChunkServiceError({ message: 'Failed to embed document chunks.', cause }),
+          }),
         ])
 
         const existingByChunkKey = new Map(
@@ -132,9 +131,11 @@ export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): D
           (row) => params.selectShape(row).sourceVersionKey !== params.sourceVersionKey,
         )
 
-        yield* tryDocumentChunkPromise('Failed to archive stale document chunks.', () =>
-          params.archive(staleVersionRows),
-        )
+        yield* Effect.tryPromise({
+          try: () => params.archive(staleVersionRows),
+          catch: (cause) =>
+            new DocumentChunkServiceError({ message: 'Failed to archive stale document chunks.', cause }),
+        })
 
         yield* Effect.forEach(
           params.chunks,
@@ -152,9 +153,14 @@ export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): D
               seenChunkKeys.add(chunk.chunkKey)
 
               if (!existingRow) {
-                yield* tryDocumentChunkPromise(`Failed to create document chunk ${chunk.chunkKey}.`, () =>
-                  params.create(payload),
-                )
+                yield* Effect.tryPromise({
+                  try: () => params.create(payload),
+                  catch: (cause) =>
+                    new DocumentChunkServiceError({
+                      message: `Failed to create document chunk ${chunk.chunkKey}.`,
+                      cause,
+                    }),
+                })
                 return
               }
 
@@ -170,9 +176,14 @@ export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): D
                 return
               }
 
-              yield* tryDocumentChunkPromise(`Failed to update document chunk ${chunk.chunkKey}.`, () =>
-                params.update(existingRow, payload),
-              )
+              yield* Effect.tryPromise({
+                try: () => params.update(existingRow, payload),
+                catch: (cause) =>
+                  new DocumentChunkServiceError({
+                    message: `Failed to update document chunk ${chunk.chunkKey}.`,
+                    cause,
+                  }),
+              })
             }),
           { concurrency: 'unbounded', discard: true },
         )
@@ -182,9 +193,11 @@ export function makeDocumentChunkService(embeddings: DocumentChunkEmbeddings): D
           return current.sourceVersionKey === params.sourceVersionKey && !seenChunkKeys.has(current.chunkKey)
         })
 
-        yield* tryDocumentChunkPromise('Failed to archive removed current-version chunks.', () =>
-          params.archive(removedCurrentVersionRows),
-        )
+        yield* Effect.tryPromise({
+          try: () => params.archive(removedCurrentVersionRows),
+          catch: (cause) =>
+            new DocumentChunkServiceError({ message: 'Failed to archive removed current-version chunks.', cause }),
+        })
       })
     },
   }
@@ -198,8 +211,13 @@ export const DocumentChunkServiceLive = Layer.effect(
   DocumentChunkServiceTag,
   Effect.gen(function* () {
     const runtimeConfig = yield* RuntimeConfigServiceTag
+    const bridge = yield* RuntimeBridgeTag
     return makeDocumentChunkService(
-      createDocumentChunkEmbeddings(runtimeConfig.aiGateway.embeddingModel, runtimeConfig.aiGateway.openRouterApiKey),
+      createDocumentChunkEmbeddings(
+        runtimeConfig.aiGateway.embeddingModel,
+        bridge.runPromise,
+        runtimeConfig.aiGateway.openRouterApiKey,
+      ),
     )
   }),
 )

package/src/services/execution-plan/execution-plan-schedule.ts

@@ -5,14 +5,16 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import { ERROR_TAGS } from '../../effect/errors'
 import { toDatabaseDateTime } from '../../utils/date-time'
 import { toRunData } from '../plan/plan-run-data'
 import type { makePlanRunService } from '../plan/plan-run.service'
 import type { makePlanSchedulerService } from '../plan/plan-scheduler.service'
 
-class PlanScheduleAttachError extends Schema.TaggedErrorClass<PlanScheduleAttachError>()('PlanScheduleAttachError', {
-  cause: Schema.String,
-}) {}
+class PlanScheduleAttachError extends Schema.TaggedErrorClass<PlanScheduleAttachError>()(
+  ERROR_TAGS.PlanScheduleAttachError,
+  { cause: Schema.String },
+) {}
 
 function toPlanScheduleAttachError(operation: string, cause: unknown) {
   const detail = cause instanceof Error ? cause.message : String(cause)

package/src/services/execution-plan/execution-plan.service.ts

@@ -17,7 +17,6 @@ import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { BadRequestError } from '../../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { DatabaseServiceTag } from '../../effect/services'
 import { extractMessageText } from '../../runtime/thread-chat-helpers'
 import { nowDate } from '../../utils/date-time'
@@ -77,13 +76,13 @@ function saveCheckpointWithService(
 }
 
 class ExecutionPlanServiceError extends Schema.TaggedErrorClass<ExecutionPlanServiceError>()(
-  'ExecutionPlanServiceError',
+  '@lota-sdk/core/ExecutionPlanServiceError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 
-const effectTryPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ExecutionPlanServiceError({ message, cause }),
-)
+function toExecutionPlanServiceError(message: string, cause: unknown): ExecutionPlanServiceError {
+  return new ExecutionPlanServiceError({ message, cause })
+}
 
 function parseRowEffect<TSchema extends z.ZodTypeAny>(
   schema: TSchema,
@@ -316,62 +315,59 @@ function createPlanEffect(
       planEventDeliveryService: deps.planEventDelivery,
       run: (tx, emittedEvents) =>
         Effect.gen(function* () {
-          const createdSpec = yield* effectTryPromise(
-            () =>
-              tx
-                .create(specId)
-                .content(
-                  buildCompiledSpecCreateData({
-                    organizationId: params.organizationId,
-                    threadId: params.threadId,
-                    leadAgentId: params.leadAgentId,
-                    compiled,
-                    version: 1,
-                  }),
-                )
-                .output('after'),
-            'Failed to create execution plan spec.',
-          )
-          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'created plan spec')
-
-          yield* effectTryPromise(
-            () =>
-              createInitializedRunGraph({
-                tx,
-                runId,
-                spec,
+          const createdSpec = yield* tx
+            .create(specId)
+            .content(
+              buildCompiledSpecCreateData({
                 organizationId: params.organizationId,
                 threadId: params.threadId,
-                sourceThreadId: params.sourceThreadId,
                 leadAgentId: params.leadAgentId,
-                createdByAgentId: params.createdByAgentId,
-                requireApproval,
-                nodes: compiled.nodes,
-                emittedEvents,
-                createdEventType: 'plan-created',
-                createdEventMessage: `Created execution plan "${spec.title}".`,
-                createdEventDetail: { title: spec.title, objective: spec.objective },
-                checkpointReason: 'plan-created',
-                planExecutor: deps.planExecutor,
+                compiled,
+                version: 1,
               }),
-            'Failed to initialize execution plan graph.',
+            )
+            .output('after')
+            .pipe(
+              Effect.mapError((cause) => toExecutionPlanServiceError('Failed to create execution plan spec.', cause)),
+            )
+          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'created plan spec')
+
+          yield* createInitializedRunGraph({
+            tx,
+            runId,
+            spec,
+            organizationId: params.organizationId,
+            threadId: params.threadId,
+            sourceThreadId: params.sourceThreadId,
+            leadAgentId: params.leadAgentId,
+            createdByAgentId: params.createdByAgentId,
+            requireApproval,
+            nodes: compiled.nodes,
+            emittedEvents,
+            createdEventType: 'plan-created',
+            createdEventMessage: `Created execution plan "${spec.title}".`,
+            createdEventDetail: { title: spec.title, objective: spec.objective },
+            checkpointReason: 'plan-created',
+            planExecutor: deps.planExecutor,
+          }).pipe(
+            Effect.mapError((cause) =>
+              toExecutionPlanServiceError('Failed to initialize execution plan graph.', cause),
+            ),
           )
         }),
     })
 
     if (!requireApproval) {
-      yield* effectTryPromise(
-        () =>
-          attachPlanScheduleIfNeeded({
-            db: databaseService,
-            planRunService: deps.planRun,
-            planSchedulerService: deps.planScheduler,
-            organizationId: params.organizationId,
-            threadId: params.threadId,
-            runId,
-            planSpecId: specId,
-          }),
-        'Failed to attach execution plan schedule.',
+      yield* attachPlanScheduleIfNeeded({
+        db: databaseService,
+        planRunService: deps.planRun,
+        planSchedulerService: deps.planScheduler,
+        organizationId: params.organizationId,
+        threadId: params.threadId,
+        runId,
+        planSpecId: specId,
+      }).pipe(
+        Effect.mapError((cause) => toExecutionPlanServiceError('Failed to attach execution plan schedule.', cause)),
       )
     }
 
@@ -425,95 +421,94 @@ function replacePlanEffect(
       planEventDeliveryService: deps.planEventDelivery,
       run: (tx, emittedEvents) =>
         Effect.gen(function* () {
-          const updatedSpec = yield* effectTryPromise(
-            () =>
-              tx
-                .update(ensureRecordId(activeSpec.id, TABLES.PLAN_SPEC))
-                .content(toSpecData(activeSpec, { status: 'superseded' }))
-                .output('after'),
-            'Failed to update superseded execution plan spec.',
-          )
+          const updatedSpec = yield* tx
+            .update(ensureRecordId(activeSpec.id, TABLES.PLAN_SPEC))
+            .content(toSpecData(activeSpec, { status: 'superseded' }))
+            .output('after')
+            .pipe(
+              Effect.mapError((cause) =>
+                toExecutionPlanServiceError('Failed to update superseded execution plan spec.', cause),
+              ),
+            )
           const supersededSpec = yield* parseRowEffect(PlanSpecSchema, updatedSpec, 'superseded plan spec')
 
-          const updatedRun = yield* effectTryPromise(
-            () =>
-              tx
-                .update(ensureRecordId(activeRun.id, TABLES.PLAN_RUN))
-                .content(
-                  toRunData(activeRun, {
-                    status: 'aborted',
-                    currentNodeId: null,
-                    waitingNodeId: null,
-                    readyNodeIds: [],
-                    completedAt: nowDate(),
-                  }),
-                )
-                .output('after'),
-            'Failed to abort previous execution run.',
-          )
+          const updatedRun = yield* tx
+            .update(ensureRecordId(activeRun.id, TABLES.PLAN_RUN))
+            .content(
+              toRunData(activeRun, {
+                status: 'aborted',
+                currentNodeId: null,
+                waitingNodeId: null,
+                readyNodeIds: [],
+                completedAt: nowDate(),
+              }),
+            )
+            .output('after')
+            .pipe(
+              Effect.mapError((cause) => toExecutionPlanServiceError('Failed to abort previous execution run.', cause)),
+            )
           const abortedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'aborted plan run')
 
-          const createdSpec = yield* effectTryPromise(
-            () =>
-              tx
-                .create(specId)
-                .content(
-                  buildCompiledSpecCreateData({
-                    organizationId: params.organizationId,
-                    threadId: resolvedThreadId,
-                    leadAgentId: params.leadAgentId,
-                    compiled,
-                    version: supersededSpec.version + 1,
-                    replacedSpecId: supersededSpec.id,
-                  }),
-                )
-                .output('after'),
-            'Failed to create replacement execution plan spec.',
-          )
-          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'replacement plan spec')
-
-          yield* effectTryPromise(
-            () =>
-              createInitializedRunGraph({
-                tx,
-                runId,
-                spec,
+          const createdSpec = yield* tx
+            .create(specId)
+            .content(
+              buildCompiledSpecCreateData({
                 organizationId: params.organizationId,
                 threadId: resolvedThreadId,
-                sourceThreadId: activeRun.sourceThreadId,
                 leadAgentId: params.leadAgentId,
-                createdByAgentId: params.createdByAgentId ?? params.leadAgentId,
-                requireApproval,
-                nodes: compiled.nodes,
-                emittedEvents,
-                runPatch: { replacedRunId: abortedRun.id },
-                createdEventType: 'plan-replaced',
-                createdEventMessage: `Replaced execution plan "${activeSpec.title}" with "${spec.title}".`,
-                createdEventDetail: {
-                  reason: params.input.reason,
-                  replacedRunId: recordIdToString(abortedRun.id, TABLES.PLAN_RUN),
-                },
-                checkpointReason: 'plan-replaced',
-                planExecutor: deps.planExecutor,
+                compiled,
+                version: supersededSpec.version + 1,
+                replacedSpecId: supersededSpec.id,
               }),
-            'Failed to initialize replacement execution plan graph.',
+            )
+            .output('after')
+            .pipe(
+              Effect.mapError((cause) =>
+                toExecutionPlanServiceError('Failed to create replacement execution plan spec.', cause),
+              ),
+            )
+          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'replacement plan spec')
+
+          yield* createInitializedRunGraph({
+            tx,
+            runId,
+            spec,
+            organizationId: params.organizationId,
+            threadId: resolvedThreadId,
+            sourceThreadId: activeRun.sourceThreadId,
+            leadAgentId: params.leadAgentId,
+            createdByAgentId: params.createdByAgentId ?? params.leadAgentId,
+            requireApproval,
+            nodes: compiled.nodes,
+            emittedEvents,
+            runPatch: { replacedRunId: abortedRun.id },
+            createdEventType: 'plan-replaced',
+            createdEventMessage: `Replaced execution plan "${activeSpec.title}" with "${spec.title}".`,
+            createdEventDetail: {
+              reason: params.input.reason,
+              replacedRunId: recordIdToString(abortedRun.id, TABLES.PLAN_RUN),
+            },
+            checkpointReason: 'plan-replaced',
+            planExecutor: deps.planExecutor,
+          }).pipe(
+            Effect.mapError((cause) =>
+              toExecutionPlanServiceError('Failed to initialize replacement execution plan graph.', cause),
+            ),
           )
         }),
     })
 
     if (!requireApproval) {
-      yield* effectTryPromise(
-        () =>
-          attachPlanScheduleIfNeeded({
-            db: databaseService,
-            planRunService: deps.planRun,
-            planSchedulerService: deps.planScheduler,
-            organizationId: params.organizationId,
-            threadId: resolvedThreadId,
-            runId,
-            planSpecId: specId,
-          }),
-        'Failed to attach execution plan schedule.',
+      yield* attachPlanScheduleIfNeeded({
+        db: databaseService,
+        planRunService: deps.planRun,
+        planSchedulerService: deps.planScheduler,
+        organizationId: params.organizationId,
+        threadId: resolvedThreadId,
+        runId,
+        planSpecId: specId,
+      }).pipe(
+        Effect.mapError((cause) => toExecutionPlanServiceError('Failed to attach execution plan schedule.', cause)),
       )
     }
 
@@ -614,30 +609,25 @@ function approvePlanEffect(
       planEventDeliveryService: deps.planEventDelivery,
       run: (tx, emittedEvents) =>
         Effect.gen(function* () {
-          const updatedRun = yield* effectTryPromise(
-            () =>
-              tx
-                .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
-                .content(toRunData(run, { status: 'running', startedAt: run.startedAt ?? nowDate() }))
-                .output('after'),
-            'Failed to activate execution run.',
-          )
+          const updatedRun = yield* tx
+            .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
+            .content(toRunData(run, { status: 'running', startedAt: run.startedAt ?? nowDate() }))
+            .output('after')
+            .pipe(Effect.mapError((cause) => toExecutionPlanServiceError('Failed to activate execution run.', cause)))
           const activatedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'activated plan run')
 
-          const synced = yield* effectTryPromise(
-            () =>
-              deps.planExecutor.syncRunGraph({
-                tx,
-                run: activatedRun,
-                spec,
-                nodeSpecs,
-                nodeRuns,
-                artifacts: [],
-                emittedBy: params.emittedBy,
-                capturedEvents: emittedEvents,
-              }),
-            'Failed to sync execution run graph.',
-          )
+          const synced = yield* deps.planExecutor
+            .syncRunGraph({
+              tx,
+              run: activatedRun,
+              spec,
+              nodeSpecs,
+              nodeRuns,
+              artifacts: [],
+              emittedBy: params.emittedBy,
+              capturedEvents: emittedEvents,
+            })
+            .pipe(Effect.mapError((cause) => toExecutionPlanServiceError('Failed to sync execution run graph.', cause)))
 
           yield* emitEvent({
             tx,
@@ -666,19 +656,15 @@ function approvePlanEffect(
         }),
     })
 
-    yield* effectTryPromise(
-      () =>
-        attachPlanScheduleIfNeeded({
-          db: databaseService,
-          planRunService: deps.planRun,
-          planSchedulerService: deps.planScheduler,
-          organizationId: run.organizationId,
-          threadId: run.threadId,
-          runId: run.id,
-          planSpecId: run.planSpecId,
-        }),
-      'Failed to attach execution plan schedule.',
-    )
+    yield* attachPlanScheduleIfNeeded({
+      db: databaseService,
+      planRunService: deps.planRun,
+      planSchedulerService: deps.planScheduler,
+      organizationId: run.organizationId,
+      threadId: run.threadId,
+      runId: run.id,
+      planSpecId: run.planSpecId,
+    }).pipe(Effect.mapError((cause) => toExecutionPlanServiceError('Failed to attach execution plan schedule.', cause)))
 
     return yield* finalizePlanSnapshotEffect(deps, { runId: run.id, emittedBy: params.emittedBy })
   })
@@ -726,22 +712,19 @@ function rejectPlanEffect(
       planEventDeliveryService: deps.planEventDelivery,
       run: (tx, emittedEvents) =>
         Effect.gen(function* () {
-          const updatedRun = yield* effectTryPromise(
-            () =>
-              tx
-                .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
-                .content(
-                  toRunData(run, {
-                    status: 'aborted',
-                    currentNodeId: null,
-                    waitingNodeId: null,
-                    readyNodeIds: [],
-                    completedAt: nowDate(),
-                  }),
-                )
-                .output('after'),
-            'Failed to abort execution run.',
-          )
+          const updatedRun = yield* tx
+            .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
+            .content(
+              toRunData(run, {
+                status: 'aborted',
+                currentNodeId: null,
+                waitingNodeId: null,
+                readyNodeIds: [],
+                completedAt: nowDate(),
+              }),
+            )
+            .output('after')
+            .pipe(Effect.mapError((cause) => toExecutionPlanServiceError('Failed to abort execution run.', cause)))
           const rejectedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'rejected plan run')
 
           yield* emitEvent({

package/src/services/feedback-loop.service.ts

@@ -3,14 +3,15 @@ import { Context, Schema, Effect, Layer } from 'effect'
 
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
+import { ERROR_TAGS } from '../effect/errors'
 import { toIsoDateTimeString, unsafeDateFrom } from '../utils/date-time'
 import type { makePlanRunService } from './plan/plan-run.service'
 import { PlanRunServiceTag } from './plan/plan-run.service'
 
-class FeedbackLoopServiceError extends Schema.TaggedErrorClass<FeedbackLoopServiceError>()('FeedbackLoopServiceError', {
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class FeedbackLoopServiceError extends Schema.TaggedErrorClass<FeedbackLoopServiceError>()(
+  ERROR_TAGS.FeedbackLoopServiceError,
+  { message: Schema.String, cause: Schema.Defect },
+) {}
 
 export function makeFeedbackLoopService(planRunService: ReturnType<typeof makePlanRunService>) {
   return {