@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -8,22 +8,34 @@ import {
 } from '@lota-sdk/shared'
 import { Effect } from 'effect'
 import { RecordId } from 'surrealdb'
+import type { z } from 'zod'
 
 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 { runPromise } from '../../effect/runtime'
+import { ServiceError } from '../../effect/errors'
 import { nowDate } from '../../utils/date-time'
 import type { CompiledPlanNode } from '../plan/plan-compiler.service'
 import type { syncRunGraph } from '../plan/plan-executor-graph'
 import { toRunData } from '../plan/plan-run-data'
 
+function parseRowOrFail<TSchema extends z.ZodTypeAny>(
+  schema: TSchema,
+  value: unknown,
+  operation: string,
+): Effect.Effect<z.infer<TSchema>, ServiceError> {
+  return Effect.try({
+    try: () => schema.parse(value) as z.infer<TSchema>,
+    catch: (cause) => new ServiceError({ message: `Failed to parse row for ${operation}.`, cause }),
+  })
+}
+
 type SyncRunGraphParams = Parameters<typeof syncRunGraph>[1]
-type SyncRunGraphResult = Awaited<ReturnType<typeof syncRunGraph>>
+type SyncRunGraphResult = ReturnType<typeof syncRunGraph>
 
 interface ExecutionPlanGraphExecutor {
-  syncRunGraph(params: SyncRunGraphParams): Promise<SyncRunGraphResult>
+  syncRunGraph(params: SyncRunGraphParams): SyncRunGraphResult
 }
 
 function buildNodeSpecCreateContent(compiledNode: CompiledPlanNode, planSpecId: RecordIdInput) {
@@ -86,7 +98,7 @@ function createNodeSpecs(tx: DatabaseTransaction, planSpecId: RecordIdInput, nod
         .create(nodeSpecId)
         .content(buildNodeSpecCreateContent(compiledNode, planSpecId))
         .output('after')
-      createdRecords.push(PlanNodeSpecRecordSchema.parse(created))
+      createdRecords.push(yield* parseRowOrFail(PlanNodeSpecRecordSchema, created, 'createNodeSpecs'))
     }
 
     return createdRecords
@@ -109,7 +121,7 @@ function createNodeRuns(
         .create(nodeRunId)
         .content(buildNodeRunCreateContent(runId, planSpecId, nodeSpec))
         .output('after')
-      createdNodeRuns.push(PlanNodeRunSchema.parse(created))
+      createdNodeRuns.push(yield* parseRowOrFail(PlanNodeRunSchema, created, 'createNodeRuns'))
     }
 
     return createdNodeRuns
@@ -135,122 +147,123 @@ export function createInitializedRunGraph(params: {
   runPatch?: { replacedRunId?: RecordIdInput }
   planExecutor: ExecutionPlanGraphExecutor
 }) {
-  return runPromise(
-    Effect.gen(function* () {
-      const nodeSpecs = yield* createNodeSpecs(params.tx, params.spec.id, params.nodes)
-      const run = PlanRunSchema.parse(
-        yield* params.tx
-          .create(ensureRecordId(params.runId, TABLES.PLAN_RUN))
-          .content({
-            planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-            threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-            ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
-            leadAgentId: params.leadAgentId,
-            ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
-            status: params.requireApproval ? 'pending-approval' : 'running',
-            readyNodeIds: [],
-            failureCount: 0,
-            ...(params.runPatch?.replacedRunId
-              ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
-              : {}),
-            ...(params.requireApproval ? {} : { startedAt: nowDate() }),
-          })
-          .output('after'),
-      )
+  return Effect.gen(function* () {
+    const nodeSpecs = yield* createNodeSpecs(params.tx, params.spec.id, params.nodes)
+    const runRaw = yield* params.tx
+      .create(ensureRecordId(params.runId, TABLES.PLAN_RUN))
+      .content({
+        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+        organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+        threadId: ensureRecordId(params.threadId, TABLES.THREAD),
+        ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
+        leadAgentId: params.leadAgentId,
+        ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
+        status: params.requireApproval ? 'pending-approval' : 'running',
+        readyNodeIds: [],
+        failureCount: 0,
+        ...(params.runPatch?.replacedRunId
+          ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
+          : {}),
+        ...(params.requireApproval ? {} : { startedAt: nowDate() }),
+      })
+      .output('after')
+    const run = yield* parseRowOrFail(PlanRunSchema, runRaw, 'createInitializedRunGraph:run')
 
-      const nodeRuns = yield* createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
-      const synced = params.requireApproval
-        ? { run, nodeRuns }
-        : yield* Effect.tryPromise(() =>
-            params.planExecutor.syncRunGraph({
-              tx: params.tx,
-              run,
-              spec: params.spec,
-              nodeSpecs,
-              nodeRuns,
-              artifacts: [],
-              emittedBy: params.leadAgentId,
-              capturedEvents: params.emittedEvents,
-            }),
-          )
+    const nodeRuns = yield* createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
+    const synced = params.requireApproval
+      ? { run, nodeRuns }
+      : yield* params.planExecutor.syncRunGraph({
+          tx: params.tx,
+          run,
+          spec: params.spec,
+          nodeSpecs,
+          nodeRuns,
+          artifacts: [],
+          emittedBy: params.leadAgentId,
+          capturedEvents: params.emittedEvents,
+        })
+
+    const event = yield* params.tx
+      .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+      .content({
+        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+        runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
+        eventType: params.createdEventType,
+        message: params.createdEventMessage,
+        emittedBy: params.leadAgentId,
+        detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
+      })
+      .output('after')
+    params.emittedEvents.push(yield* parseRowOrFail(PlanEventSchema, event, 'createInitializedRunGraph:createdEvent'))
 
-      const event = yield* params.tx
+    if (params.requireApproval) {
+      const pendingApprovalEvent = yield* params.tx
         .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
         .content({
           planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
           runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-          eventType: params.createdEventType,
-          message: params.createdEventMessage,
+          eventType: 'plan-pending-approval',
+          toStatus: synced.run.status,
+          message: `Execution plan "${params.spec.title}" is pending approval.`,
           emittedBy: params.leadAgentId,
           detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
         })
         .output('after')
-      params.emittedEvents.push(PlanEventSchema.parse(event))
-
-      if (params.requireApproval) {
-        const pendingApprovalEvent = yield* params.tx
-          .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-          .content({
-            planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-            runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-            eventType: 'plan-pending-approval',
-            toStatus: synced.run.status,
-            message: `Execution plan "${params.spec.title}" is pending approval.`,
-            emittedBy: params.leadAgentId,
-            detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
-          })
-          .output('after')
-        params.emittedEvents.push(PlanEventSchema.parse(pendingApprovalEvent))
-      }
-
-      const checkpoint = PlanCheckpointSchema.parse(
-        yield* params.tx
-          .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
-          .content({
-            runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
-            sequence: 1,
-            runStatus: synced.run.status,
-            readyNodeIds: [...synced.run.readyNodeIds],
-            activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
-            artifactIds: [],
-            lastCompletedNodeIds: synced.nodeRuns
-              .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
-              .map((nodeRun) => nodeRun.nodeId),
-            snapshot: {
-              reason: params.checkpointReason,
-              currentNodeId: synced.run.currentNodeId,
-              waitingNodeId: synced.run.waitingNodeId,
-              readyNodeIds: synced.run.readyNodeIds,
-            },
-          })
-          .output('after'),
+      params.emittedEvents.push(
+        yield* parseRowOrFail(PlanEventSchema, pendingApprovalEvent, 'createInitializedRunGraph:pendingApprovalEvent'),
       )
+    }
 
-      const updatedRun = PlanRunSchema.parse(
-        yield* params.tx
-          .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
-          .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
-          .output('after'),
-      )
+    const checkpointRaw = yield* params.tx
+      .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
+      .content({
+        runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
+        sequence: 1,
+        runStatus: synced.run.status,
+        readyNodeIds: [...synced.run.readyNodeIds],
+        activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
+        artifactIds: [],
+        lastCompletedNodeIds: synced.nodeRuns
+          .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
+          .map((nodeRun) => nodeRun.nodeId),
+        snapshot: {
+          reason: params.checkpointReason,
+          currentNodeId: synced.run.currentNodeId,
+          waitingNodeId: synced.run.waitingNodeId,
+          readyNodeIds: synced.run.readyNodeIds,
+        },
+      })
+      .output('after')
+    const checkpoint = yield* parseRowOrFail(
+      PlanCheckpointSchema,
+      checkpointRaw,
+      'createInitializedRunGraph:checkpoint',
+    )
 
-      const checkpointEvent = yield* params.tx
-        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
-        .content({
-          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
-          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
-          eventType: 'checkpoint-saved',
-          message: 'Saved checkpoint 1.',
-          emittedBy: 'system',
-          detail: {
-            checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
-            reason: params.checkpointReason,
-          },
-        })
-        .output('after')
-      params.emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
+    const updatedRunRaw = yield* params.tx
+      .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
+      .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
+      .output('after')
+    const updatedRun = yield* parseRowOrFail(PlanRunSchema, updatedRunRaw, 'createInitializedRunGraph:updatedRun')
 
-      return updatedRun
-    }),
-  )
+    const checkpointEvent = yield* params.tx
+      .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+      .content({
+        planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+        runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
+        eventType: 'checkpoint-saved',
+        message: 'Saved checkpoint 1.',
+        emittedBy: 'system',
+        detail: {
+          checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
+          reason: params.checkpointReason,
+        },
+      })
+      .output('after')
+    params.emittedEvents.push(
+      yield* parseRowOrFail(PlanEventSchema, checkpointEvent, 'createInitializedRunGraph:checkpointEvent'),
+    )
+
+    return updatedRun
+  })
 }

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

@@ -1,4 +1,3 @@
-import type { PlanRunRecord } from '@lota-sdk/shared'
 import { PlanRunSchema } from '@lota-sdk/shared'
 import { Schema, Effect } from 'effect'
 
@@ -6,7 +5,6 @@ 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 { runPromise } from '../../effect/runtime'
 import { toDatabaseDateTime } from '../../utils/date-time'
 import { toRunData } from '../plan/plan-run-data'
 import type { makePlanRunService } from '../plan/plan-run.service'
@@ -21,7 +19,7 @@ function toPlanScheduleAttachError(operation: string, cause: unknown) {
   return new PlanScheduleAttachError({ cause: `${operation}: ${detail}` })
 }
 
-function attachPlanScheduleIfNeededEffect(params: {
+export function attachPlanScheduleIfNeeded(params: {
   db: SurrealDBService
   planRunService: ReturnType<typeof makePlanRunService>
   planSchedulerService: ReturnType<typeof makePlanSchedulerService>
@@ -70,15 +68,3 @@ function attachPlanScheduleIfNeededEffect(params: {
     return updatedRun ?? run
   })
 }
-
-export function attachPlanScheduleIfNeeded(params: {
-  db: SurrealDBService
-  planRunService: ReturnType<typeof makePlanRunService>
-  planSchedulerService: ReturnType<typeof makePlanSchedulerService>
-  organizationId: RecordIdInput
-  threadId: RecordIdInput
-  runId: RecordIdInput
-  planSpecId: RecordIdInput
-}): Promise<PlanRunRecord> {
-  return runPromise(attachPlanScheduleIfNeededEffect(params))
-}

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

@@ -10,6 +10,7 @@ import type {
 import { PlanDraftSchema, PlanRunSchema, PlanSpecSchema } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer, Match } from 'effect'
 import { RecordId } from 'surrealdb'
+import type { z } from 'zod'
 
 import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
@@ -84,6 +85,17 @@ const effectTryPromise = makeEffectTryPromiseWithMessage(
   (message, cause) => new ExecutionPlanServiceError({ message, cause }),
 )
 
+function parseRowEffect<TSchema extends z.ZodTypeAny>(
+  schema: TSchema,
+  value: unknown,
+  label: string,
+): Effect.Effect<z.infer<TSchema>, ExecutionPlanServiceError> {
+  return Effect.try({
+    try: () => schema.parse(value) as z.infer<TSchema>,
+    catch: (cause) => new ExecutionPlanServiceError({ message: `Failed to parse ${label}.`, cause }),
+  })
+}
+
 function toSerializablePlanEffect(
   deps: ExecutionPlanDeps,
   run: PlanRunRecord,
@@ -285,7 +297,8 @@ function createPlanEffect(
     const databaseService = deps.db
     const requireApproval =
       params.requireApproval ?? hasCrossThreadSourceContext(params.sourceThreadId, params.threadId)
-    const preparedDraft = deps.planBuilder.prepareDraft(PlanDraftSchema.parse(params.input))
+    const parsedDraft = yield* parseRowEffect(PlanDraftSchema, params.input, 'plan draft input')
+    const preparedDraft = deps.planBuilder.prepareDraft(parsedDraft)
     const validation = deps.planValidator.validateDraft(preparedDraft)
     if (validation.blocking.length > 0) {
       return yield* new BadRequestError({
@@ -319,7 +332,7 @@ function createPlanEffect(
                 .output('after'),
             'Failed to create execution plan spec.',
           )
-          const spec = PlanSpecSchema.parse(createdSpec)
+          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'created plan spec')
 
           yield* effectTryPromise(
             () =>
@@ -391,7 +404,8 @@ function replacePlanEffect(
 
     const activeSpec = yield* deps.planRun.getPlanSpecById(activeRun.planSpecId)
     const { runId: _runId, reason: _reason, requireApproval: requestedRequireApproval, ...draftInput } = params.input
-    const preparedDraft = deps.planBuilder.prepareDraft(PlanDraftSchema.parse(draftInput))
+    const parsedDraft = yield* parseRowEffect(PlanDraftSchema, draftInput, 'plan draft replacement input')
+    const preparedDraft = deps.planBuilder.prepareDraft(parsedDraft)
     const validation = deps.planValidator.validateDraft(preparedDraft)
     if (validation.blocking.length > 0) {
       return yield* new BadRequestError({
@@ -419,7 +433,7 @@ function replacePlanEffect(
                 .output('after'),
             'Failed to update superseded execution plan spec.',
           )
-          const supersededSpec = PlanSpecSchema.parse(updatedSpec)
+          const supersededSpec = yield* parseRowEffect(PlanSpecSchema, updatedSpec, 'superseded plan spec')
 
           const updatedRun = yield* effectTryPromise(
             () =>
@@ -437,7 +451,7 @@ function replacePlanEffect(
                 .output('after'),
             'Failed to abort previous execution run.',
           )
-          const abortedRun = PlanRunSchema.parse(updatedRun)
+          const abortedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'aborted plan run')
 
           const createdSpec = yield* effectTryPromise(
             () =>
@@ -456,7 +470,7 @@ function replacePlanEffect(
                 .output('after'),
             'Failed to create replacement execution plan spec.',
           )
-          const spec = PlanSpecSchema.parse(createdSpec)
+          const spec = yield* parseRowEffect(PlanSpecSchema, createdSpec, 'replacement plan spec')
 
           yield* effectTryPromise(
             () =>
@@ -523,18 +537,19 @@ function submitPlanTurnResultEffect(
   },
 ) {
   return Effect.gen(function* () {
-    const result = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.submitNodeResult({
-          threadId: params.threadId,
-          runId: params.runId,
-          nodeId: params.nodeId,
-          emittedBy: params.emittedBy,
-          result: params.input,
-        }),
-      catch: (cause) =>
-        new ExecutionPlanServiceError({ message: 'Failed to submit execution plan node result.', cause }),
-    })
+    const result = yield* deps.planExecutor
+      .submitNodeResult({
+        threadId: params.threadId,
+        runId: params.runId,
+        nodeId: params.nodeId,
+        emittedBy: params.emittedBy,
+        result: params.input,
+      })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit execution plan node result.', cause }),
+        ),
+      )
 
     const plan = yield* finalizePlanSnapshotEffect(deps, { runId: params.runId, emittedBy: params.emittedBy })
     return buildExecutionPlanToolResult({
@@ -550,15 +565,13 @@ function resumeRunEffect(
   params: { threadId: RecordIdInput; emittedBy: string; input: { runId: string } },
 ) {
   return Effect.gen(function* () {
-    const result = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.resumeRun({
-          threadId: params.threadId,
-          runId: params.input.runId,
-          emittedBy: params.emittedBy,
-        }),
-      catch: (cause) => new ExecutionPlanServiceError({ message: 'Failed to resume execution run.', cause }),
-    })
+    const result = yield* deps.planExecutor
+      .resumeRun({ threadId: params.threadId, runId: params.input.runId, emittedBy: params.emittedBy })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to resume execution run.', cause }),
+        ),
+      )
 
     const plan = yield* finalizePlanSnapshotEffect(deps, { runId: params.input.runId, emittedBy: params.emittedBy })
     return buildExecutionPlanToolResult({
@@ -609,7 +622,7 @@ function approvePlanEffect(
                 .output('after'),
             'Failed to activate execution run.',
           )
-          const activatedRun = PlanRunSchema.parse(updatedRun)
+          const activatedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'activated plan run')
 
           const synced = yield* effectTryPromise(
             () =>
@@ -729,7 +742,7 @@ function rejectPlanEffect(
                 .output('after'),
             'Failed to abort execution run.',
           )
-          const rejectedRun = PlanRunSchema.parse(updatedRun)
+          const rejectedRun = yield* parseRowEffect(PlanRunSchema, updatedRun, 'rejected plan run')
 
           yield* emitEvent({
             tx,
@@ -778,17 +791,19 @@ function respondToApprovalEffect(
     const run = yield* deps.planRun.getActiveRunRecord(params.threadId)
     if (!run) return null
 
-    const plan = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.submitHumanNodeResponse({
-          threadId: params.threadId,
-          approvalId: params.input.approvalId,
-          respondedBy: params.emittedBy,
-          response: params.input.response,
-          approvalMessageId: params.input.approvalMessageId,
-        }),
-      catch: (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human approval response.', cause }),
-    })
+    const plan = yield* deps.planExecutor
+      .submitHumanNodeResponse({
+        threadId: params.threadId,
+        approvalId: params.input.approvalId,
+        respondedBy: params.emittedBy,
+        response: params.input.response,
+        approvalMessageId: params.input.approvalMessageId,
+      })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human approval response.', cause }),
+        ),
+      )
     if (!plan) return null
 
     return yield* finalizePlanSnapshotEffect(deps, { runId: run.id, emittedBy: params.emittedBy })
@@ -825,16 +840,18 @@ function applyHumanInputFromUserMessageEffect(
     )
     if (!response) return null
 
-    const plan = yield* Effect.tryPromise({
-      try: () =>
-        deps.planExecutor.submitHumanNodeResponse({
-          threadId: params.threadId,
-          respondedBy: params.respondedBy,
-          response,
-          approvalMessageId: params.message.id,
-        }),
-      catch: (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human node response.', cause }),
-    })
+    const plan = yield* deps.planExecutor
+      .submitHumanNodeResponse({
+        threadId: params.threadId,
+        respondedBy: params.respondedBy,
+        response,
+        approvalMessageId: params.message.id,
+      })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ExecutionPlanServiceError({ message: 'Failed to submit human node response.', cause }),
+        ),
+      )
     if (!plan) return null
 
     return yield* finalizePlanSnapshotEffect(deps, { runId: run.id, emittedBy: params.respondedBy })
@@ -1010,7 +1027,7 @@ export function makeExecutionPlanService(deps: ExecutionPlanDeps) {
 export class ExecutionPlanServiceTag extends Context.Service<
   ExecutionPlanServiceTag,
   ReturnType<typeof makeExecutionPlanService>
->()('ExecutionPlanService') {}
+>()('@lota-sdk/core/ExecutionPlanService') {}
 
 export const ExecutionPlanServiceLive = Layer.effect(
   ExecutionPlanServiceTag,

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

@@ -141,7 +141,7 @@ export function makeFeedbackLoopService(planRunService: ReturnType<typeof makePl
 export class FeedbackLoopServiceTag extends Context.Service<
   FeedbackLoopServiceTag,
   ReturnType<typeof makeFeedbackLoopService>
->()('FeedbackLoopService') {}
+>()('@lota-sdk/core/FeedbackLoopService') {}
 
 export const FeedbackLoopServiceLive = Layer.effect(
   FeedbackLoopServiceTag,

package/src/services/global-orchestrator.service.ts

@@ -1,10 +1,20 @@
-import type { ConvergenceState } from '@lota-sdk/shared'
+import type {
+  ConvergenceState,
+  ExecutionMode,
+  PlanNodeResultSubmission,
+  PlanNodeRunRecord,
+  PlanNodeSpecRecord,
+  PlanRunRecord,
+  PlanSpecRecord,
+} from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
-import { runPromise } from '../effect/runtime'
-import { getCurrentRuntime } from '../effect/runtime-ref'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { AgentConfigServiceTag } from '../effect/services'
+import type { PlanAgentHeartbeatQueueRuntime } from '../queues/plan-agent-heartbeat.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import { routeGraphFullEffect } from './graph-full-routing'
-import type { makeOwnershipDispatcherService } from './ownership-dispatcher.service'
+import type { OwnershipDispatcherService } from './ownership-dispatcher.service'
 import { OwnershipDispatcherServiceTag } from './ownership-dispatcher.service'
 import type { makePlanExecutorService } from './plan/plan-executor.service'
 import { PlanExecutorServiceTag } from './plan/plan-executor.service'
@@ -48,20 +58,36 @@ function decideRerouteAction(params: {
 }
 
 interface GlobalOrchestratorDeps {
-  ownershipDispatcherService: ReturnType<typeof makeOwnershipDispatcherService>
+  agentConfig: ResolvedAgentConfig
+  ownershipDispatcherService: Pick<OwnershipDispatcherService, 'dispatchReadyNode'>
   planExecutorService: ReturnType<typeof makePlanExecutorService>
   planRunService: ReturnType<typeof makePlanRunService>
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
 }
 
+type DispatchReadyNodeParams = {
+  run: PlanRunRecord
+  nodeSpecRecord: PlanNodeSpecRecord
+  nodeRun: PlanNodeRunRecord
+  spec: PlanSpecRecord
+  executionModeOverride?: ExecutionMode
+}
+
+type DispatchReadyNode = (params: DispatchReadyNodeParams) => Effect.Effect<PlanNodeResultSubmission, unknown, never>
+
 export function makeGlobalOrchestratorService(deps: GlobalOrchestratorDeps) {
+  const dispatchReadyNode: DispatchReadyNode = (params) => deps.ownershipDispatcherService.dispatchReadyNode(params)
+
   return {
     detectConvergence,
     decideRerouteAction,
     routeGraphFull: (params: { threadId: string; runId: string }) =>
       routeGraphFullEffect(params, {
-        dispatchReadyNode: (dispatchParams) => deps.ownershipDispatcherService.dispatchReadyNode(dispatchParams),
+        agentConfig: deps.agentConfig,
+        dispatchReadyNode,
         planExecutorService: deps.planExecutorService,
         planRunService: deps.planRunService,
+        planAgentHeartbeatQueue: deps.planAgentHeartbeatQueue,
       }),
   }
 }
@@ -69,22 +95,30 @@ export function makeGlobalOrchestratorService(deps: GlobalOrchestratorDeps) {
 export class GlobalOrchestratorServiceTag extends Context.Service<
   GlobalOrchestratorServiceTag,
   ReturnType<typeof makeGlobalOrchestratorService>
->()('GlobalOrchestratorService') {}
+>()('@lota-sdk/core/GlobalOrchestratorService') {}
 
 export const GlobalOrchestratorServiceLive = Layer.effect(
   GlobalOrchestratorServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const ownershipDispatcherService = yield* OwnershipDispatcherServiceTag
     const planExecutorService = yield* PlanExecutorServiceTag
     const planRunService = yield* PlanRunServiceTag
-    return makeGlobalOrchestratorService({ ownershipDispatcherService, planExecutorService, planRunService })
+    const queues = yield* LotaQueuesServiceTag
+    return makeGlobalOrchestratorService({
+      agentConfig,
+      ownershipDispatcherService,
+      planExecutorService,
+      planRunService,
+      planAgentHeartbeatQueue: queues.planAgentHeartbeat,
+    })
   }),
 )
 
-function getGlobalOrchestratorService() {
-  return getCurrentRuntime().runSync(Effect.service(GlobalOrchestratorServiceTag))
-}
-
-export function routeGraphFull(params: { threadId: string; runId: string }): Promise<void> {
-  return runPromise(getGlobalOrchestratorService().routeGraphFull(params))
-}
+export const routeGraphFull = Effect.fn('GlobalOrchestrator.routeGraphFull')(function* (params: {
+  threadId: string
+  runId: string
+}) {
+  const globalOrchestratorService = yield* GlobalOrchestratorServiceTag
+  return yield* globalOrchestratorService.routeGraphFull(params)
+})