@lota-sdk/core 0.4.9 → 0.4.10

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

@@ -110,11 +110,15 @@ interface PlanCycleDeps {
 export function makePlanCycleService(deps: PlanCycleDeps) {
   const { db, planSchedulerService, planTemplateService } = deps
 
-  function getCycleEffect(cycleId: RecordIdInput) {
-    return db.findOne(TABLES.PLAN_CYCLE, { id: ensureRecordId(cycleId, TABLES.PLAN_CYCLE) }, PlanCycleRecordSchema)
-  }
+  const getCycleEffect = Effect.fn('PlanCycle.getCycle')(function* (cycleId: RecordIdInput) {
+    return yield* db.findOne(
+      TABLES.PLAN_CYCLE,
+      { id: ensureRecordId(cycleId, TABLES.PLAN_CYCLE) },
+      PlanCycleRecordSchema,
+    )
+  })
 
-  function createCycleEffect(params: {
+  const createCycleEffect = Effect.fn('PlanCycle.createCycle')(function* (params: {
     organizationId: RecordIdInput
     threadId: RecordIdInput
     templateId: RecordIdInput
@@ -123,10 +127,10 @@ export function makePlanCycleService(deps: PlanCycleDeps) {
     carryForwardPolicy?: CarryForwardPolicy
     leadAgentId: string
   }) {
-    return Effect.gen(function* () {
-      const now = nowDate()
+    const now = nowDate()
 
-      const cycle = yield* db.create(
+    const cycle = yield* db
+      .create(
         TABLES.PLAN_CYCLE,
         {
           organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
@@ -141,198 +145,194 @@ export function makePlanCycleService(deps: PlanCycleDeps) {
         },
         PlanCycleRecordSchema,
       )
+      .pipe(Effect.withSpan('PlanCycle.persistCycle'))
 
-      const createResult = yield* planTemplateService.instantiate({
+    const createResult = yield* planTemplateService
+      .instantiate({
         templateId: params.templateId,
         organizationId: params.organizationId,
         threadId: params.threadId,
         leadAgentId: params.leadAgentId,
       })
+      .pipe(Effect.withSpan('PlanCycle.instantiateTemplate'))
 
-      const createdRunId = createResult.plan?.runId
-      const scheduleSpec = cycleScheduleToSpec(params.schedule)
-      const scheduleParams: {
-        organizationId: RecordIdInput
-        threadId: RecordIdInput
-        scheduleSpec: PlanScheduleSpec
-        runId?: RecordIdInput
-      } = { organizationId: params.organizationId, threadId: params.threadId, scheduleSpec }
-      if (createdRunId !== undefined) {
-        scheduleParams.runId = ensureRecordId(createdRunId, TABLES.PLAN_RUN)
-      }
-
-      const scheduleRecord = yield* planSchedulerService.createSchedule(scheduleParams)
+    const createdRunId = createResult.plan?.runId
+    const scheduleSpec = cycleScheduleToSpec(params.schedule)
+    const scheduleParams: {
+      organizationId: RecordIdInput
+      threadId: RecordIdInput
+      scheduleSpec: PlanScheduleSpec
+      runId?: RecordIdInput
+    } = { organizationId: params.organizationId, threadId: params.threadId, scheduleSpec }
+    if (createdRunId !== undefined) {
+      scheduleParams.runId = ensureRecordId(createdRunId, TABLES.PLAN_RUN)
+    }
+
+    const scheduleRecord = yield* planSchedulerService.createSchedule(scheduleParams)
+
+    const updatedPayload: { scheduleId: RecordIdInput; currentRunId?: RecordIdInput; currentIteration: number } = {
+      scheduleId: ensureRecordId(scheduleRecord.id, TABLES.PLAN_SCHEDULE),
+      currentIteration: 1,
+    }
+    if (createdRunId !== undefined) {
+      updatedPayload.currentRunId = ensureRecordId(createdRunId, TABLES.PLAN_RUN)
+    }
+
+    const updated = yield* db.update(
+      TABLES.PLAN_CYCLE,
+      ensureRecordId(cycle.id, TABLES.PLAN_CYCLE),
+      updatedPayload,
+      PlanCycleRecordSchema,
+    )
 
-      const updatedPayload: { scheduleId: RecordIdInput; currentRunId?: RecordIdInput; currentIteration: number } = {
-        scheduleId: ensureRecordId(scheduleRecord.id, TABLES.PLAN_SCHEDULE),
-        currentIteration: 1,
-      }
-      if (createdRunId !== undefined) {
-        updatedPayload.currentRunId = ensureRecordId(createdRunId, TABLES.PLAN_RUN)
-      }
+    return updated ?? cycle
+  })
 
-      const updated = yield* db.update(
-        TABLES.PLAN_CYCLE,
-        ensureRecordId(cycle.id, TABLES.PLAN_CYCLE),
-        updatedPayload,
-        PlanCycleRecordSchema,
+  const advanceCycleEffect = Effect.fn('PlanCycle.advanceCycle')(function* (cycleId: RecordIdInput) {
+    const cycle = yield* getCycleEffect(cycleId)
+    if (!cycle) {
+      return yield* new PlanCycleNotFoundError({
+        cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+        message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+      })
+    }
+
+    if (cycle.status !== 'active') {
+      return
+    }
+
+    const currentRunId = cycle.currentRunId
+    if (currentRunId !== undefined) {
+      const runRecord = yield* db.findOne(
+        TABLES.PLAN_RUN,
+        { id: ensureRecordId(currentRunId, TABLES.PLAN_RUN) },
+        PlanRunSchema,
       )
-
-      return updated ?? cycle
-    })
-  }
-
-  function advanceCycleEffect(cycleId: RecordIdInput) {
-    return Effect.gen(function* () {
-      const cycle = yield* getCycleEffect(cycleId)
-      if (!cycle) {
-        return yield* new PlanCycleNotFoundError({
-          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
-          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
-        })
-      }
-
-      if (cycle.status !== 'active') {
+      if (runRecord && !TERMINAL_RUN_STATUSES.has(runRecord.status)) {
         return
       }
+    }
 
-      const currentRunId = cycle.currentRunId
-      if (currentRunId !== undefined) {
-        const runRecord = yield* db.findOne(
-          TABLES.PLAN_RUN,
-          { id: ensureRecordId(currentRunId, TABLES.PLAN_RUN) },
-          PlanRunSchema,
-        )
-        if (runRecord && !TERMINAL_RUN_STATUSES.has(runRecord.status)) {
-          return
-        }
-      }
-
-      const template = yield* planTemplateService.getTemplate(cycle.templateId)
-      if (!template) {
-        return yield* new PlanTemplateNotFoundForCycleError({
-          templateId: recordIdToString(cycle.templateId, TABLES.PLAN_TEMPLATE),
-          message: `Template not found for cycle: ${recordIdToString(cycle.templateId, TABLES.PLAN_TEMPLATE)}`,
+    const template = yield* planTemplateService.getTemplate(cycle.templateId)
+    if (!template) {
+      return yield* new PlanTemplateNotFoundForCycleError({
+        templateId: recordIdToString(cycle.templateId, TABLES.PLAN_TEMPLATE),
+        message: `Template not found for cycle: ${recordIdToString(cycle.templateId, TABLES.PLAN_TEMPLATE)}`,
+      })
+    }
+
+    let previousRunArtifacts: PlanArtifactRecord[] = []
+    if (currentRunId !== undefined) {
+      previousRunArtifacts = yield* db
+        .findMany(TABLES.PLAN_ARTIFACT, { runId: ensureRecordId(currentRunId, TABLES.PLAN_RUN) }, PlanArtifactSchema, {
+          orderBy: 'createdAt',
+          orderDir: 'ASC',
         })
-      }
-
-      let previousRunArtifacts: PlanArtifactRecord[] = []
-      if (currentRunId !== undefined) {
-        previousRunArtifacts = yield* db.findMany(
-          TABLES.PLAN_ARTIFACT,
-          { runId: ensureRecordId(currentRunId, TABLES.PLAN_RUN) },
-          PlanArtifactSchema,
-          { orderBy: 'createdAt', orderDir: 'ASC' },
-        )
-      }
+        .pipe(Effect.withSpan('PlanCycle.loadPreviousRunArtifacts'))
+    }
 
-      const draft = buildCarryForwardDraft({ template, previousRunArtifacts, policy: cycle.carryForwardPolicy })
+    const draft = buildCarryForwardDraft({ template, previousRunArtifacts, policy: cycle.carryForwardPolicy })
 
-      const result = yield* planTemplateService.instantiate({
+    const result = yield* planTemplateService
+      .instantiate({
         templateId: cycle.templateId,
         organizationId: cycle.organizationId,
         threadId: cycle.threadId,
         leadAgentId: 'system',
         overrides: draft,
       })
+      .pipe(Effect.withSpan('PlanCycle.instantiateTemplate'))
 
-      const newRunId = result.plan?.runId
-      const updatePayload: { currentRunId?: RecordIdInput; currentIteration: number } = {
-        currentIteration: cycle.currentIteration + 1,
-      }
-      if (newRunId !== undefined) {
-        updatePayload.currentRunId = ensureRecordId(newRunId, TABLES.PLAN_RUN)
-      }
-
-      yield* db.update(
-        TABLES.PLAN_CYCLE,
-        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-        updatePayload,
-        PlanCycleRecordSchema,
-      )
-    })
-  }
-
-  function cancelCycleEffect(cycleId: RecordIdInput) {
-    return Effect.gen(function* () {
-      const cycle = yield* getCycleEffect(cycleId)
-      if (!cycle) {
-        return yield* new PlanCycleNotFoundError({
-          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
-          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
-        })
-      }
-
-      const scheduleId = cycle.scheduleId
-      if (scheduleId !== undefined) {
-        yield* planSchedulerService.cancelSchedule(scheduleId)
-      }
+    const newRunId = result.plan?.runId
+    const updatePayload: { currentRunId?: RecordIdInput; currentIteration: number } = {
+      currentIteration: cycle.currentIteration + 1,
+    }
+    if (newRunId !== undefined) {
+      updatePayload.currentRunId = ensureRecordId(newRunId, TABLES.PLAN_RUN)
+    }
 
-      yield* db.update(
-        TABLES.PLAN_CYCLE,
-        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-        { status: 'cancelled' },
-        PlanCycleRecordSchema,
-      )
-    })
-  }
+    yield* db.update(
+      TABLES.PLAN_CYCLE,
+      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+      updatePayload,
+      PlanCycleRecordSchema,
+    )
+  })
+
+  const cancelCycleEffect = Effect.fn('PlanCycle.cancelCycle')(function* (cycleId: RecordIdInput) {
+    const cycle = yield* getCycleEffect(cycleId)
+    if (!cycle) {
+      return yield* new PlanCycleNotFoundError({
+        cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+        message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+      })
+    }
 
-  function pauseCycleEffect(cycleId: RecordIdInput) {
-    return Effect.gen(function* () {
-      const cycle = yield* getCycleEffect(cycleId)
-      if (!cycle) {
-        return yield* new PlanCycleNotFoundError({
-          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
-          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
-        })
-      }
+    const scheduleId = cycle.scheduleId
+    if (scheduleId !== undefined) {
+      yield* planSchedulerService.cancelSchedule(scheduleId)
+    }
 
-      const scheduleId = cycle.scheduleId
-      if (scheduleId !== undefined) {
-        yield* planSchedulerService.pauseSchedule(scheduleId)
-      }
+    yield* db.update(
+      TABLES.PLAN_CYCLE,
+      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+      { status: 'cancelled' },
+      PlanCycleRecordSchema,
+    )
+  })
+
+  const pauseCycleEffect = Effect.fn('PlanCycle.pauseCycle')(function* (cycleId: RecordIdInput) {
+    const cycle = yield* getCycleEffect(cycleId)
+    if (!cycle) {
+      return yield* new PlanCycleNotFoundError({
+        cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+        message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+      })
+    }
 
-      yield* db.update(
-        TABLES.PLAN_CYCLE,
-        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-        { status: 'paused' },
-        PlanCycleRecordSchema,
-      )
-    })
-  }
+    const scheduleId = cycle.scheduleId
+    if (scheduleId !== undefined) {
+      yield* planSchedulerService.pauseSchedule(scheduleId)
+    }
 
-  function resumeCycleEffect(cycleId: RecordIdInput) {
-    return Effect.gen(function* () {
-      const cycle = yield* getCycleEffect(cycleId)
-      if (!cycle) {
-        return yield* new PlanCycleNotFoundError({
-          cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
-          message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
-        })
-      }
+    yield* db.update(
+      TABLES.PLAN_CYCLE,
+      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+      { status: 'paused' },
+      PlanCycleRecordSchema,
+    )
+  })
+
+  const resumeCycleEffect = Effect.fn('PlanCycle.resumeCycle')(function* (cycleId: RecordIdInput) {
+    const cycle = yield* getCycleEffect(cycleId)
+    if (!cycle) {
+      return yield* new PlanCycleNotFoundError({
+        cycleId: recordIdToString(cycleId, TABLES.PLAN_CYCLE),
+        message: `Cycle not found: ${recordIdToString(cycleId, TABLES.PLAN_CYCLE)}`,
+      })
+    }
 
-      const scheduleId = cycle.scheduleId
-      if (scheduleId !== undefined) {
-        yield* planSchedulerService.resumeSchedule(scheduleId)
-      }
+    const scheduleId = cycle.scheduleId
+    if (scheduleId !== undefined) {
+      yield* planSchedulerService.resumeSchedule(scheduleId)
+    }
 
-      yield* db.update(
-        TABLES.PLAN_CYCLE,
-        ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
-        { status: 'active' },
-        PlanCycleRecordSchema,
-      )
-    })
-  }
+    yield* db.update(
+      TABLES.PLAN_CYCLE,
+      ensureRecordId(cycleId, TABLES.PLAN_CYCLE),
+      { status: 'active' },
+      PlanCycleRecordSchema,
+    )
+  })
 
-  function listCyclesEffect(threadId: RecordIdInput) {
-    return db.findMany(
+  const listCyclesEffect = Effect.fn('PlanCycle.listCycles')(function* (threadId: RecordIdInput) {
+    return yield* db.findMany(
       TABLES.PLAN_CYCLE,
       { threadId: ensureRecordId(threadId, TABLES.THREAD) },
       PlanCycleRecordSchema,
       { orderBy: 'createdAt', orderDir: 'ASC' },
     )
-  }
+  })
 
   return {
     cycleScheduleToSpec,
@@ -347,10 +347,12 @@ export function makePlanCycleService(deps: PlanCycleDeps) {
     }): Promise<PlanCycleRecord> {
       return runPromise(createCycleEffect(params))
     },
+    createCycleEffect,
 
     advanceCycle(cycleId: RecordIdInput): Promise<void> {
       return runPromise(advanceCycleEffect(cycleId))
     },
+    advanceCycleEffect,
 
     buildCarryForwardDraft(params: {
       template: PlanTemplateRecord
@@ -363,29 +365,34 @@ export function makePlanCycleService(deps: PlanCycleDeps) {
     cancelCycle(cycleId: RecordIdInput): Promise<void> {
       return runPromise(cancelCycleEffect(cycleId))
     },
+    cancelCycleEffect,
 
     pauseCycle(cycleId: RecordIdInput): Promise<void> {
       return runPromise(pauseCycleEffect(cycleId))
     },
+    pauseCycleEffect,
 
     resumeCycle(cycleId: RecordIdInput): Promise<void> {
       return runPromise(resumeCycleEffect(cycleId))
     },
+    resumeCycleEffect,
 
     listCycles(threadId: RecordIdInput): Promise<PlanCycleRecord[]> {
       return runPromise(listCyclesEffect(threadId))
     },
+    listCyclesEffect,
 
     getCycle(cycleId: RecordIdInput): Promise<PlanCycleRecord | null> {
       return runPromise(getCycleEffect(cycleId))
     },
+    getCycleEffect,
   }
 }
 
 export class PlanCycleServiceTag extends Context.Service<
   PlanCycleServiceTag,
   ReturnType<typeof makePlanCycleService>
->()('PlanCycleService') {}
+>()('@lota-sdk/core/PlanCycleService') {}
 
 export const PlanCycleServiceLive = Layer.effect(
   PlanCycleServiceTag,