@lota-sdk/core 0.4.7 → 0.4.9

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

@@ -0,0 +1,475 @@
+import type {
+  PlanEventRecord,
+  PlanNodeRunRecord,
+  PlanNodeSpecRecord,
+  PlanRunRecord,
+  PlanSpecRecord,
+} from '@lota-sdk/shared'
+import { PlanNodeRunSchema } from '@lota-sdk/shared'
+import { Effect } from 'effect'
+
+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 { runPromise } from '../../effect/runtime'
+import { nowDate } from '../../utils/date-time'
+import type { PlanExecutorContext } from './plan-executor-context'
+import {
+  buildNodeContext,
+  buildResolvedInput,
+  evaluateCondition,
+  isHumanNodeType,
+  isStructuralNodeType,
+  isSuccessfulTerminalStatus,
+  toNodeRunData,
+} from './plan-executor-helpers'
+import { emitEvent, replaceRun } from './plan-executor-persistence'
+
+const delayedNodePromotionQueueModule = Effect.tryPromise(() => import('../../queues/delayed-node-promotion.queue'))
+
+export function syncRunGraph(
+  context: PlanExecutorContext,
+  params: {
+    tx: DatabaseTransaction
+    run: PlanRunRecord
+    spec: PlanSpecRecord
+    nodeSpecs: PlanNodeSpecRecord[]
+    nodeRuns: PlanNodeRunRecord[]
+    artifacts: Array<{
+      id: RecordIdInput
+      nodeId: string
+      name: string
+      kind: string
+      pointer: string
+      schemaRef?: string
+      payload?: unknown
+    }>
+    emittedBy: string
+    capturedEvents?: PlanEventRecord[]
+  },
+): Promise<{
+  run: PlanRunRecord
+  nodeRuns: PlanNodeRunRecord[]
+  artifacts: Array<{
+    id: RecordIdInput
+    nodeId: string
+    name: string
+    kind: string
+    pointer: string
+    schemaRef?: string
+    payload?: unknown
+  }>
+}> {
+  return runPromise(
+    Effect.gen(function* () {
+      const { planApprovalService, planCoordinationService, planSchedulerService } = context
+      const currentTime = nowDate()
+      let currentRun = params.run
+      let currentNodeRuns = [...params.nodeRuns]
+      const currentArtifacts = [...params.artifacts]
+      const sortedNodeSpecs = [...params.nodeSpecs].sort((left, right) => left.position - right.position)
+      const dependencies = params.spec.dependencies
+
+      const updateNodeRun = (nodeRun: PlanNodeRunRecord, patch: Parameters<typeof toNodeRunData>[1]) =>
+        params.tx
+          .update(ensureRecordId(nodeRun.id, TABLES.PLAN_NODE_RUN))
+          .content(toNodeRunData(nodeRun, patch))
+          .output('after')
+
+      const replaceNodeRun = (nextNodeRun: PlanNodeRunRecord) => {
+        currentNodeRuns = currentNodeRuns.map((candidate) =>
+          candidate.nodeId === nextNodeRun.nodeId ? nextNodeRun : candidate,
+        )
+      }
+
+      const getNodeRunsById = () => new Map(currentNodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
+      const getArtifactsByNodeId = () =>
+        currentArtifacts.reduce((groups, artifact) => {
+          const list = groups.get(artifact.nodeId) ?? []
+          list.push(artifact)
+          groups.set(artifact.nodeId, list)
+          return groups
+        }, new Map<string, typeof currentArtifacts>())
+
+      if (dependencies && dependencies.length > 0) {
+        const { unresolved } = yield* planCoordinationService.resolveDependencies({
+          dependencies,
+          threadId: recordIdToString(params.spec.threadId, TABLES.THREAD),
+        })
+        if (unresolved.length > 0) {
+          currentRun = yield* replaceRun(params.tx, currentRun, { status: 'blocked', readyNodeIds: [] })
+          yield* emitEvent({
+            tx: params.tx,
+            run: currentRun,
+            spec: params.spec,
+            eventType: 'run-status-changed',
+            fromStatus: params.run.status,
+            toStatus: currentRun.status,
+            message: `Run blocked: unresolved cross-plan dependencies (${unresolved.map((d) => d.sourcePlanSpecId).join(', ')}).`,
+            emittedBy: params.emittedBy,
+            capturedEvents: params.capturedEvents,
+          })
+          return { run: currentRun, nodeRuns: currentNodeRuns, artifacts: currentArtifacts }
+        }
+      }
+
+      let changed = true
+      while (changed) {
+        changed = false
+        const nodeRunsById = getNodeRunsById()
+        const artifactsByNodeId = getArtifactsByNodeId()
+
+        for (const nodeSpec of sortedNodeSpecs) {
+          const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
+          if (!nodeRun || nodeRun.status !== 'pending') continue
+
+          const upstreamRuns = nodeSpec.upstreamNodeIds
+            .map((nodeId) => nodeRunsById.get(nodeId))
+            .filter(Boolean) as PlanNodeRunRecord[]
+          if (
+            nodeSpec.upstreamNodeIds.length > 0 &&
+            !upstreamRuns.every((upstreamRun) => isSuccessfulTerminalStatus(upstreamRun.status))
+          ) {
+            continue
+          }
+
+          const activeIncomingEdges: typeof params.spec.edges = []
+          for (const edge of params.spec.edges) {
+            if (edge.target !== nodeSpec.nodeId) continue
+            const sourceRun = nodeRunsById.get(edge.source)
+            if (!sourceRun) continue
+            const context = buildNodeContext({
+              nodeRun: sourceRun,
+              artifacts: artifactsByNodeId.get(edge.source) ?? [],
+            })
+            if (yield* evaluateCondition(edge.when, context)) {
+              activeIncomingEdges.push(edge)
+            }
+          }
+
+          if (nodeSpec.upstreamNodeIds.length > 0 && activeIncomingEdges.length === 0) {
+            const skippedNodeRun = PlanNodeRunSchema.parse(
+              yield* updateNodeRun(nodeRun, {
+                status: 'skipped',
+                completedAt: currentTime,
+                blockedReason: null,
+                failureClass: null,
+              }),
+            )
+            replaceNodeRun(skippedNodeRun)
+            yield* emitEvent({
+              tx: params.tx,
+              run: currentRun,
+              spec: params.spec,
+              nodeId: skippedNodeRun.nodeId,
+              eventType: 'node-skipped',
+              fromStatus: nodeRun.status,
+              toStatus: skippedNodeRun.status,
+              message: `Node "${nodeSpec.label}" was skipped because no inbound branch was activated.`,
+              emittedBy: params.emittedBy,
+              capturedEvents: params.capturedEvents,
+            })
+            changed = true
+            continue
+          }
+
+          const resolvedInput = yield* buildResolvedInput({
+            spec: params.spec,
+            nodeSpec,
+            nodeRunsById,
+            artifactsByNodeId,
+          })
+
+          const nodeSchedule = nodeSpec.schedule
+          const hasNonImmediateSchedule = nodeSchedule && nodeSchedule.type !== 'immediate'
+
+          if (hasNonImmediateSchedule) {
+            const scheduledNodeRun = PlanNodeRunSchema.parse(
+              yield* updateNodeRun(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: currentTime }),
+            )
+            replaceNodeRun(scheduledNodeRun)
+            yield* planSchedulerService.createSchedule({
+              organizationId: currentRun.organizationId,
+              threadId: currentRun.threadId,
+              planSpecId: params.spec.id,
+              runId: currentRun.id,
+              nodeId: nodeSpec.nodeId,
+              scheduleSpec: nodeSchedule,
+            })
+            yield* emitEvent({
+              tx: params.tx,
+              run: currentRun,
+              spec: params.spec,
+              nodeId: scheduledNodeRun.nodeId,
+              eventType: 'node-scheduled',
+              fromStatus: nodeRun.status,
+              toStatus: scheduledNodeRun.status,
+              message: `Node "${nodeSpec.label}" is scheduled (${nodeSchedule.type}).`,
+              emittedBy: params.emittedBy,
+              capturedEvents: params.capturedEvents,
+            })
+            changed = true
+          } else if (nodeSpec.delayAfterPredecessorMs) {
+            const delayAfterPredecessorMs = nodeSpec.delayAfterPredecessorMs
+            const { enqueueDelayedNodePromotion } = yield* delayedNodePromotionQueueModule
+            const scheduledNodeRun = PlanNodeRunSchema.parse(
+              yield* updateNodeRun(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: currentTime }),
+            )
+            replaceNodeRun(scheduledNodeRun)
+            yield* Effect.tryPromise(() =>
+              enqueueDelayedNodePromotion(
+                {
+                  runId: recordIdToString(currentRun.id, TABLES.PLAN_RUN),
+                  nodeId: nodeSpec.nodeId,
+                  emittedBy: params.emittedBy,
+                },
+                delayAfterPredecessorMs,
+              ),
+            )
+            yield* emitEvent({
+              tx: params.tx,
+              run: currentRun,
+              spec: params.spec,
+              nodeId: scheduledNodeRun.nodeId,
+              eventType: 'node-scheduled',
+              fromStatus: nodeRun.status,
+              toStatus: scheduledNodeRun.status,
+              message: `Node "${nodeSpec.label}" is delayed by ${delayAfterPredecessorMs}ms after predecessor.`,
+              emittedBy: params.emittedBy,
+              capturedEvents: params.capturedEvents,
+            })
+            changed = true
+          } else {
+            const readyNodeRun = PlanNodeRunSchema.parse(
+              yield* updateNodeRun(nodeRun, { status: 'ready', resolvedInput, readyAt: currentTime }),
+            )
+            replaceNodeRun(readyNodeRun)
+            yield* emitEvent({
+              tx: params.tx,
+              run: currentRun,
+              spec: params.spec,
+              nodeId: readyNodeRun.nodeId,
+              eventType: 'node-ready',
+              fromStatus: nodeRun.status,
+              toStatus: readyNodeRun.status,
+              message: `Node "${nodeSpec.label}" is ready to execute.`,
+              emittedBy: params.emittedBy,
+              capturedEvents: params.capturedEvents,
+            })
+            changed = true
+          }
+        }
+
+        const readyStructuralNodes = sortedNodeSpecs.filter((nodeSpec) => {
+          const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
+          return nodeRun?.status === 'ready' && isStructuralNodeType(nodeSpec.type)
+        })
+
+        for (const nodeSpec of readyStructuralNodes) {
+          const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
+          if (!nodeRun) continue
+
+          const completedNodeRun = PlanNodeRunSchema.parse(
+            yield* updateNodeRun(nodeRun, {
+              status: 'completed',
+              startedAt: nodeRun.startedAt ?? currentTime,
+              completedAt: currentTime,
+            }),
+          )
+          replaceNodeRun(completedNodeRun)
+          yield* emitEvent({
+            tx: params.tx,
+            run: currentRun,
+            spec: params.spec,
+            nodeId: completedNodeRun.nodeId,
+            eventType: 'node-auto-completed',
+            fromStatus: nodeRun.status,
+            toStatus: completedNodeRun.status,
+            message: `Structural node "${nodeSpec.label}" auto-completed.`,
+            emittedBy: params.emittedBy,
+            capturedEvents: params.capturedEvents,
+          })
+          changed = true
+        }
+      }
+
+      const nodeRunsById = getNodeRunsById()
+      const activeRunningNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'running')
+      const activeHumanNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'awaiting-human')
+      const activeMonitoringNode = currentNodeRuns.find((nodeRun) => nodeRun.status === 'monitoring')
+      const hasScheduledOrMonitoring = currentNodeRuns.some(
+        (nodeRun) => nodeRun.status === 'scheduled' || nodeRun.status === 'monitoring',
+      )
+
+      if (!activeRunningNode && !activeHumanNode && !activeMonitoringNode) {
+        const nextHumanNodeSpec = sortedNodeSpecs.find((nodeSpec) => {
+          const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
+          return nodeRun?.status === 'ready' && isHumanNodeType(nodeSpec.type)
+        })
+
+        if (nextHumanNodeSpec) {
+          const nodeRun = nodeRunsById.get(nextHumanNodeSpec.nodeId)
+          if (!nodeRun) {
+            return yield* new NotFoundError({
+              resource: 'plan node run',
+              id: nextHumanNodeSpec.nodeId,
+              message: `Expected ready node run for "${nextHumanNodeSpec.nodeId}".`,
+            })
+          }
+          const awaitingHumanNodeRun = PlanNodeRunSchema.parse(
+            yield* updateNodeRun(nodeRun, { status: 'awaiting-human', startedAt: nodeRun.startedAt ?? currentTime }),
+          )
+          replaceNodeRun(awaitingHumanNodeRun)
+
+          const approval = yield* planApprovalService.createPendingApproval({
+            tx: params.tx,
+            runId: currentRun.id,
+            nodeRunId: awaitingHumanNodeRun.id,
+            nodeId: awaitingHumanNodeRun.nodeId,
+            requestedBy: params.emittedBy,
+            presented: {
+              nodeId: nextHumanNodeSpec.nodeId,
+              label: nextHumanNodeSpec.label,
+              objective: nextHumanNodeSpec.objective,
+              instructions: nextHumanNodeSpec.instructions,
+              deliverables: nextHumanNodeSpec.deliverables,
+              successCriteria: nextHumanNodeSpec.successCriteria,
+              resolvedInput: awaitingHumanNodeRun.resolvedInput ?? {},
+            },
+          })
+
+          currentRun = yield* replaceRun(params.tx, currentRun, {
+            status: 'awaiting-human',
+            currentNodeId: awaitingHumanNodeRun.nodeId,
+            waitingNodeId: awaitingHumanNodeRun.nodeId,
+            readyNodeIds: currentNodeRuns
+              .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== awaitingHumanNodeRun.nodeId)
+              .map((candidate) => candidate.nodeId),
+          })
+
+          yield* emitEvent({
+            tx: params.tx,
+            run: currentRun,
+            spec: params.spec,
+            nodeId: awaitingHumanNodeRun.nodeId,
+            approvalId: approval.id,
+            eventType: 'approval-requested',
+            fromStatus: params.run.status,
+            toStatus: currentRun.status,
+            message: `Node "${nextHumanNodeSpec.label}" is awaiting human input.`,
+            emittedBy: params.emittedBy,
+            capturedEvents: params.capturedEvents,
+          })
+        } else {
+          const nextActionNodeSpec = sortedNodeSpecs.find((nodeSpec) => {
+            const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
+            return nodeRun?.status === 'ready' && !isStructuralNodeType(nodeSpec.type)
+          })
+
+          if (nextActionNodeSpec) {
+            const nodeRun = nodeRunsById.get(nextActionNodeSpec.nodeId)
+            if (!nodeRun) {
+              return yield* new NotFoundError({
+                resource: 'plan node run',
+                id: nextActionNodeSpec.nodeId,
+                message: `Expected ready node run for "${nextActionNodeSpec.nodeId}".`,
+              })
+            }
+            const runningNodeRun = PlanNodeRunSchema.parse(
+              yield* updateNodeRun(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? currentTime }),
+            )
+            replaceNodeRun(runningNodeRun)
+
+            currentRun = yield* replaceRun(params.tx, currentRun, {
+              status: 'running',
+              currentNodeId: runningNodeRun.nodeId,
+              waitingNodeId: null,
+              readyNodeIds: currentNodeRuns
+                .filter((candidate) => candidate.status === 'ready' && candidate.nodeId !== runningNodeRun.nodeId)
+                .map((candidate) => candidate.nodeId),
+            })
+
+            yield* emitEvent({
+              tx: params.tx,
+              run: currentRun,
+              spec: params.spec,
+              nodeId: runningNodeRun.nodeId,
+              eventType: 'node-running',
+              fromStatus: nodeRun.status,
+              toStatus: runningNodeRun.status,
+              message: `Node "${nextActionNodeSpec.label}" is now running.`,
+              emittedBy: params.emittedBy,
+              capturedEvents: params.capturedEvents,
+            })
+            yield* emitEvent({
+              tx: params.tx,
+              run: currentRun,
+              spec: params.spec,
+              nodeId: runningNodeRun.nodeId,
+              eventType: 'ownership-transition',
+              message: `Execution ownership transitioned to "${nextActionNodeSpec.label}".`,
+              detail: {
+                owner: nextActionNodeSpec.owner,
+                fromNodeId: params.run.currentNodeId ?? null,
+                toNodeId: runningNodeRun.nodeId,
+              },
+              emittedBy: params.emittedBy,
+              capturedEvents: params.capturedEvents,
+            })
+          } else if (currentNodeRuns.every((nodeRun) => isSuccessfulTerminalStatus(nodeRun.status))) {
+            currentRun = yield* replaceRun(params.tx, currentRun, {
+              status: 'completed',
+              currentNodeId: null,
+              waitingNodeId: null,
+              readyNodeIds: [],
+              completedAt: currentTime,
+            })
+
+            yield* emitEvent({
+              tx: params.tx,
+              run: currentRun,
+              spec: params.spec,
+              eventType: 'run-status-changed',
+              fromStatus: params.run.status,
+              toStatus: currentRun.status,
+              message: `Run "${params.spec.title}" completed.`,
+              emittedBy: params.emittedBy,
+              capturedEvents: params.capturedEvents,
+            })
+          } else if (hasScheduledOrMonitoring) {
+            currentRun = yield* replaceRun(params.tx, currentRun, {
+              status: 'running',
+              currentNodeId: null,
+              waitingNodeId: null,
+              readyNodeIds: currentNodeRuns
+                .filter((candidate) => candidate.status === 'ready')
+                .map((candidate) => candidate.nodeId),
+            })
+          } else {
+            currentRun = yield* replaceRun(params.tx, currentRun, {
+              status: 'blocked',
+              currentNodeId: null,
+              waitingNodeId: null,
+              readyNodeIds: currentNodeRuns
+                .filter((candidate) => candidate.status === 'ready')
+                .map((candidate) => candidate.nodeId),
+            })
+          }
+        }
+      } else {
+        currentRun = yield* replaceRun(params.tx, currentRun, {
+          status: activeHumanNode ? 'awaiting-human' : 'running',
+          currentNodeId: activeHumanNode?.nodeId ?? activeMonitoringNode?.nodeId ?? activeRunningNode?.nodeId ?? null,
+          waitingNodeId: activeHumanNode?.nodeId ?? null,
+          readyNodeIds: currentNodeRuns
+            .filter((candidate) => candidate.status === 'ready')
+            .map((candidate) => candidate.nodeId),
+        })
+      }
+
+      return { run: currentRun, nodeRuns: currentNodeRuns, artifacts: currentArtifacts }
+    }),
+  )
+}