@lota-sdk/core 0.4.13 → 0.4.14

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

@@ -14,6 +14,7 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import { ERROR_TAGS } from '../../effect/errors'
 import { DatabaseServiceTag } from '../../effect/services'
 import { nowDate, nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 import type { makePlanSchedulerService } from './plan-scheduler.service'
@@ -23,13 +24,13 @@ import { PlanTemplateServiceTag } from './plan-template.service'
 
 const TERMINAL_RUN_STATUSES: ReadonlySet<PlanRunStatus> = new Set(['completed', 'failed', 'aborted'])
 
-class PlanCycleNotFoundError extends Schema.TaggedErrorClass<PlanCycleNotFoundError>()('PlanCycleNotFoundError', {
-  cycleId: Schema.String,
-  message: Schema.String,
-}) {}
+class PlanCycleNotFoundError extends Schema.TaggedErrorClass<PlanCycleNotFoundError>()(
+  ERROR_TAGS.PlanCycleNotFoundError,
+  { cycleId: Schema.String, message: Schema.String },
+) {}
 
 class PlanTemplateNotFoundForCycleError extends Schema.TaggedErrorClass<PlanTemplateNotFoundForCycleError>()(
-  'PlanTemplateNotFoundForCycleError',
+  '@lota-sdk/core/PlanTemplateNotFoundForCycleError',
   { templateId: Schema.String, message: Schema.String },
 ) {}
 

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

@@ -15,7 +15,7 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import { DatabaseServiceTag } from '../../effect/services'
 import type { PlanSchedulerQueueRuntime } from '../../queues/plan-scheduler.queue'
 import { LotaQueuesServiceTag } from '../../queues/queues.service'
@@ -91,16 +91,17 @@ interface PlanDeadlineDeps {
   planSchedulerQueue: PlanSchedulerQueueRuntime
 }
 
-class PlanDeadlineError extends Schema.TaggedErrorClass<PlanDeadlineError>()('PlanDeadlineError', {
+class PlanDeadlineError extends Schema.TaggedErrorClass<PlanDeadlineError>()(ERROR_TAGS.PlanDeadlineError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
 
+function toPlanDeadlineError(message: string, cause: unknown): PlanDeadlineError {
+  return new PlanDeadlineError({ message, cause })
+}
+
 export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
   const { db, planEventDeliveryService, planExecutorService, planRunService, planSchedulerQueue } = deps
-  const effectTryPromise = makeEffectTryPromiseWithMessage(
-    (message, cause) => new PlanDeadlineError({ message, cause }),
-  )
   const loadPlanSchedulerQueue = (): Effect.Effect<PlanSchedulerQueueRuntime, PlanDeadlineError> =>
     Effect.succeed(planSchedulerQueue)
 
@@ -115,16 +116,19 @@ export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
   }
 
   const collectDeadlineSweepEffect = Effect.fn('PlanDeadline.collectDeadlineSweep')(function* (now: Date) {
-    const activeNodeRuns = yield* effectTryPromise(
-      () =>
-        db.queryMany(
-          new BoundQuery(`SELECT * FROM ${TABLES.PLAN_NODE_RUN} WHERE status IN $statuses`, {
-            statuses: ['running', 'awaiting-human'],
-          }),
-          PlanNodeRunSchema,
+    const activeNodeRuns = yield* db
+      .queryMany(
+        new BoundQuery(`SELECT * FROM ${TABLES.PLAN_NODE_RUN} WHERE status IN $statuses`, {
+          statuses: ['running', 'awaiting-human'],
+        }),
+        PlanNodeRunSchema,
+      )
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanDeadlineError('Failed to load active plan node runs for deadline sweep.', cause),
         ),
-      'Failed to load active plan node runs for deadline sweep.',
-    ).pipe(Effect.withSpan('PlanDeadline.loadActiveNodeRuns'))
+        Effect.withSpan('PlanDeadline.loadActiveNodeRuns'),
+      )
     const results = yield* Effect.forEach(
       activeNodeRuns,
       (nodeRun) =>
@@ -171,27 +175,25 @@ export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
     const existing =
       dedupeKey === null
         ? []
-        : yield* effectTryPromise(
-            () =>
-              db.queryMany(
-                new BoundQuery(
-                  `SELECT * FROM ${TABLES.PLAN_EVENT}
+        : yield* db
+            .queryMany(
+              new BoundQuery(
+                `SELECT * FROM ${TABLES.PLAN_EVENT}
                     WHERE runId = $runId
                       AND nodeId = $nodeId
                       AND eventType = $eventType
                       AND detail.dedupeKey = $dedupeKey
                     LIMIT 1`,
-                  {
-                    runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
-                    nodeId: params.nodeRun.nodeId,
-                    eventType: params.eventType,
-                    dedupeKey,
-                  },
-                ),
-                PlanEventSchema,
+                {
+                  runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
+                  nodeId: params.nodeRun.nodeId,
+                  eventType: params.eventType,
+                  dedupeKey,
+                },
               ),
-            'Failed to load existing deadline event.',
-          )
+              PlanEventSchema,
+            )
+            .pipe(Effect.mapError((cause) => toPlanDeadlineError('Failed to load existing deadline event.', cause)))
     if (existing.length > 0) {
       return
     }
@@ -203,24 +205,22 @@ export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
           (cause) => new PlanDeadlineError({ message: 'Failed to load plan spec for deadline event.', cause }),
         ),
       )
-    const event = yield* effectTryPromise(
-      () =>
-        db.create(
-          TABLES.PLAN_EVENT,
-          {
-            id: new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()),
-            planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
-            runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
-            nodeId: params.nodeRun.nodeId,
-            eventType: params.eventType,
-            message: params.message,
-            emittedBy: params.emittedBy,
-            detail: params.detail,
-          },
-          PlanEventSchema,
-        ),
-      'Failed to create deadline event.',
-    )
+    const event = yield* db
+      .create(
+        TABLES.PLAN_EVENT,
+        {
+          id: new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()),
+          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
+          runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
+          nodeId: params.nodeRun.nodeId,
+          eventType: params.eventType,
+          message: params.message,
+          emittedBy: params.emittedBy,
+          detail: params.detail,
+        },
+        PlanEventSchema,
+      )
+      .pipe(Effect.mapError((cause) => toPlanDeadlineError('Failed to create deadline event.', cause)))
     yield* planEventDeliveryService
       .dispatchEvent(PlanEventSchema.parse(event))
       .pipe(
@@ -378,8 +378,11 @@ export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
   )
 
   const enqueueDeadlineCheckEffect = Effect.fn('PlanDeadline.enqueueDeadlineCheck')(function* (scheduledFor: Date) {
-    const { enqueueDeadlineCheck } = yield* loadPlanSchedulerQueue()
-    yield* effectTryPromise(() => enqueueDeadlineCheck(scheduledFor), 'Failed to enqueue deadline check.')
+    const queue = yield* loadPlanSchedulerQueue()
+    yield* Effect.tryPromise({
+      try: () => queue.enqueueDeadlineCheck(scheduledFor),
+      catch: (cause) => toPlanDeadlineError('Failed to enqueue deadline check.', cause),
+    })
   })
 
   const checkDeadlinesEffect = Effect.fn('PlanDeadline.checkDeadlines')(function* (now?: Date) {
@@ -403,11 +406,11 @@ export function makePlanDeadlineService(deps: PlanDeadlineDeps) {
         const cachedRun = runCache.get(runIdStr)
         const run =
           cachedRun ??
-          (yield* effectTryPromise(
-            () =>
-              db.findOne(TABLES.PLAN_RUN, { id: ensureRecordId(entry.nodeRun.runId, TABLES.PLAN_RUN) }, PlanRunSchema),
-            'Failed to load plan run during deadline check.',
-          ))
+          (yield* db
+            .findOne(TABLES.PLAN_RUN, { id: ensureRecordId(entry.nodeRun.runId, TABLES.PLAN_RUN) }, PlanRunSchema)
+            .pipe(
+              Effect.mapError((cause) => toPlanDeadlineError('Failed to load plan run during deadline check.', cause)),
+            ))
         if (!run) {
           return
         }

package/src/services/plan/plan-event-delivery.service.ts

@@ -5,6 +5,7 @@ import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import { ERROR_TAGS } from '../../effect/errors'
 import {
   AgentConfigServiceTag,
   DatabaseServiceTag,
@@ -25,10 +26,10 @@ import { PlanRunServiceTag } from './plan-run.service'
 
 const PLAN_EVENT_DELIVERED_TTL_MS = 7 * 24 * 60 * 60 * 1000
 
-class PlanEventDeliveryError extends Schema.TaggedErrorClass<PlanEventDeliveryError>()('PlanEventDeliveryError', {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
+class PlanEventDeliveryError extends Schema.TaggedErrorClass<PlanEventDeliveryError>()(
+  ERROR_TAGS.PlanEventDeliveryError,
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 function buildDeliveredKey(eventId: string): string {
   return `plan-event:delivered:${eventId}`

package/src/services/plan/plan-executor-graph.ts

@@ -13,7 +13,7 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { DatabaseTransaction } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { NotFoundError } from '../../effect/errors'
+import { ERROR_TAGS, NotFoundError } from '../../effect/errors'
 import { nowDate } from '../../utils/date-time'
 import type { PlanExecutorContext } from './plan-executor-context'
 import {
@@ -27,10 +27,10 @@ import {
 } from './plan-executor-helpers'
 import { emitEvent, replaceRun } from './plan-executor-persistence'
 
-class PlanExecutorGraphError extends Schema.TaggedErrorClass<PlanExecutorGraphError>()('PlanExecutorGraphError', {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
+class PlanExecutorGraphError extends Schema.TaggedErrorClass<PlanExecutorGraphError>()(
+  ERROR_TAGS.PlanExecutorGraphError,
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 function parseRowOrFail<T>(
   schema: z.ZodType<T>,
@@ -220,16 +220,19 @@ export function syncRunGraph(
           })
           const scheduledNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, scheduledNodeRunRow, 'plan node run')
           replaceNodeRun(scheduledNodeRun)
-          yield* Effect.tryPromise(() =>
-            delayedNodePromotionQueue.enqueueDelayedNodePromotion(
-              {
-                runId: recordIdToString(currentRun.id, TABLES.PLAN_RUN),
-                nodeId: nodeSpec.nodeId,
-                emittedBy: params.emittedBy,
-              },
-              delayAfterPredecessorMs,
-            ),
-          )
+          yield* Effect.tryPromise({
+            try: () =>
+              delayedNodePromotionQueue.enqueueDelayedNodePromotion(
+                {
+                  runId: recordIdToString(currentRun.id, TABLES.PLAN_RUN),
+                  nodeId: nodeSpec.nodeId,
+                  emittedBy: params.emittedBy,
+                },
+                delayAfterPredecessorMs,
+              ),
+            catch: (cause) =>
+              new PlanExecutorGraphError({ message: 'Failed to enqueue delayed node promotion.', cause }),
+          })
           yield* emitEvent({
             tx: params.tx,
             run: currentRun,