@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -0,0 +1,266 @@
+import type { PlanEventRecord } from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
+
+import { ensureRecordId, recordIdToString } from '../../db/record-id'
+import type { SurrealDBService } from '../../db/service'
+import { TABLES } from '../../db/tables'
+import { runPromise } from '../../effect/runtime'
+import { DatabaseServiceTag, RedisServiceTag } from '../../effect/services'
+import type { RedisConnectionManager } from '../../redis/connection'
+import { resolvePlanNodeExecutionVisibility } from '../../runtime/execution-plan-visibility'
+import { getRuntimeAdapters } from '../../runtime/runtime-extensions'
+import type { LotaRuntimePlanEventEnvelope } from '../../runtime/runtime-extensions'
+import { getErrorMessage } from '../../utils/errors'
+import { ThreadSchema } from '../thread/thread.types'
+import type { makeUserService } from '../user.service'
+import { UserServiceTag } from '../user.service'
+import type { makePlanRunService } from './plan-run.service'
+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),
+}) {}
+
+function buildDeliveredKey(eventId: string): string {
+  return `plan-event:delivered:${eventId}`
+}
+
+function dispatchAdapterEvent(envelope: LotaRuntimePlanEventEnvelope) {
+  const adapter = getRuntimeAdapters().planEventAdapter
+  if (!adapter) {
+    return Effect.void
+  }
+
+  return Effect.tryPromise({
+    try: () => adapter.onPlanEvent(envelope),
+    catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+  })
+}
+
+function resolveWakeTarget(
+  envelope: LotaRuntimePlanEventEnvelope,
+  nodeSpecsById: Map<string, NonNullable<LotaRuntimePlanEventEnvelope['nodeSpec']>>,
+): { nodeId: string; agentId: string; reason: string } | null {
+  const currentNodeId = envelope.run.currentNodeId ?? envelope.event.nodeId
+  if (!currentNodeId) {
+    return null
+  }
+
+  const effectiveNodeSpec =
+    (envelope.event.nodeId === currentNodeId ? envelope.nodeSpec : undefined) ?? nodeSpecsById.get(currentNodeId)
+  if (!effectiveNodeSpec || effectiveNodeSpec.owner.executorType !== 'agent') {
+    return null
+  }
+
+  const isVisible = resolvePlanNodeExecutionVisibility(envelope.spec, effectiveNodeSpec) === 'visible'
+  if (!isVisible) {
+    return null
+  }
+
+  const supportedEventTypes = new Set([
+    'node-ready',
+    'node-unblocked',
+    'approval-resolved',
+    'run-resumed',
+    'deadline-warning',
+    'escalation-triggered',
+  ])
+  if (!supportedEventTypes.has(envelope.event.eventType)) {
+    return null
+  }
+
+  return { nodeId: currentNodeId, agentId: effectiveNodeSpec.owner.ref, reason: envelope.event.eventType }
+}
+
+function enqueueWakeIfNeeded(
+  envelope: LotaRuntimePlanEventEnvelope,
+  nodeSpecsById: Map<string, NonNullable<LotaRuntimePlanEventEnvelope['nodeSpec']>>,
+) {
+  return Effect.gen(function* () {
+    const wakeTarget = resolveWakeTarget(envelope, nodeSpecsById)
+    if (!wakeTarget) {
+      return
+    }
+
+    const { enqueuePlanAgentHeartbeatWake } = yield* Effect.tryPromise({
+      try: () => import('../../queues/plan-agent-heartbeat.queue'),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    })
+    yield* Effect.tryPromise({
+      try: () =>
+        enqueuePlanAgentHeartbeatWake({
+          organizationId: envelope.organizationId,
+          threadId: envelope.threadId,
+          runId: envelope.runId,
+          nodeId: wakeTarget.nodeId,
+          agentId: wakeTarget.agentId,
+          reason: wakeTarget.reason,
+        }),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    })
+  })
+}
+
+interface PlanEventDeliveryDeps {
+  db: SurrealDBService
+  redis: RedisConnectionManager
+  planRunService: ReturnType<typeof makePlanRunService>
+  userService: ReturnType<typeof makeUserService>
+}
+
+export function makePlanEventDeliveryService(deps: PlanEventDeliveryDeps) {
+  const { db, redis, planRunService, userService } = deps
+
+  function deliverEvent(event: PlanEventRecord) {
+    return Effect.gen(function* () {
+      const run = yield* planRunService
+        .getRunById(event.runId)
+        .pipe(Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })))
+      const [spec, nodeSpecs, nodeRuns, thread] = yield* Effect.all([
+        planRunService
+          .getPlanSpecById(run.planSpecId)
+          .pipe(
+            Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })),
+          ),
+        planRunService
+          .listNodeSpecs(run.planSpecId)
+          .pipe(
+            Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })),
+          ),
+        planRunService
+          .listNodeRuns(run.id)
+          .pipe(
+            Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })),
+          ),
+        db
+          .findOne(TABLES.THREAD, { id: ensureRecordId(run.threadId, TABLES.THREAD) }, ThreadSchema)
+          .pipe(
+            Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })),
+          ),
+      ])
+
+      const nodeSpecsById = new Map(nodeSpecs.map((nodeSpec) => [nodeSpec.nodeId, nodeSpec]))
+      const nodeRunsById = new Map(nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
+      const organizationId = recordIdToString(run.organizationId, TABLES.ORGANIZATION)
+      const threadId = recordIdToString(run.threadId, TABLES.THREAD)
+      const runIdString = recordIdToString(run.id, TABLES.PLAN_RUN)
+      const planSpecId = recordIdToString(spec.id, TABLES.PLAN_SPEC)
+      const userId = thread?.userId
+        ? recordIdToString(ensureRecordId(thread.userId, TABLES.USER), TABLES.USER)
+        : undefined
+      const userName =
+        userId === undefined
+          ? undefined
+          : yield* Effect.orElseSucceed(
+              Effect.map(
+                userService
+                  .getUser(userId)
+                  .pipe(
+                    Effect.mapError(
+                      (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+                    ),
+                  ),
+                (user) => user.name,
+              ),
+              () => undefined,
+            )
+
+      const envelope: LotaRuntimePlanEventEnvelope = {
+        event,
+        spec,
+        run,
+        ...(event.nodeId ? { nodeSpec: nodeSpecsById.get(event.nodeId) } : {}),
+        ...(event.nodeId ? { nodeRun: nodeRunsById.get(event.nodeId) } : {}),
+        organizationId,
+        threadId,
+        runId: runIdString,
+        planSpecId,
+        ...(userId ? { userId } : {}),
+        ...(userName ? { userName } : {}),
+      }
+
+      yield* dispatchAdapterEvent(envelope)
+      yield* enqueueWakeIfNeeded(envelope, nodeSpecsById)
+    })
+  }
+
+  const dispatchEventEffect = Effect.fn('PlanEventDelivery.dispatchEvent')(function* (event: PlanEventRecord) {
+    const eventId = recordIdToString(event.id, TABLES.PLAN_EVENT)
+    const deliveredKey = buildDeliveredKey(eventId)
+    const exists = yield* Effect.tryPromise({
+      try: () => redis.getConnection().exists(deliveredKey),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    })
+    if (exists) {
+      return
+    }
+
+    yield* deliverEvent(event)
+    yield* Effect.tryPromise({
+      try: () => redis.getConnection().set(deliveredKey, '1', 'PX', PLAN_EVENT_DELIVERED_TTL_MS),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    })
+  })
+
+  const dispatchUndeliveredEventsEffect = Effect.fn('PlanEventDelivery.dispatchUndeliveredEvents')(function* (
+    runId: string,
+    options?: { limit?: number },
+  ) {
+    const run = yield* planRunService
+      .getRunById(runId)
+      .pipe(Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })))
+    const events = yield* planRunService
+      .listEvents(run.id, options?.limit ?? 200)
+      .pipe(Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })))
+
+    for (const event of events) {
+      yield* dispatchEventEffect(event)
+    }
+  })
+
+  const dispatchEventsEffect = Effect.fn('PlanEventDelivery.dispatchEvents')(function* (events: PlanEventRecord[]) {
+    const runIds = new Set(events.map((event) => recordIdToString(event.runId, TABLES.PLAN_RUN)))
+    for (const runId of runIds) {
+      yield* dispatchUndeliveredEventsEffect(runId)
+    }
+  })
+
+  return {
+    dispatchEvents(events: PlanEventRecord[]): Promise<void> {
+      return runPromise(dispatchEventsEffect(events))
+    },
+
+    dispatchEventsEffect,
+
+    dispatchEvent(event: PlanEventRecord): Promise<void> {
+      return runPromise(dispatchEventEffect(event))
+    },
+
+    dispatchEventEffect,
+
+    dispatchUndeliveredEvents(runId: string, options?: { limit?: number }): Promise<void> {
+      return runPromise(dispatchUndeliveredEventsEffect(runId, options))
+    },
+
+    dispatchUndeliveredEventsEffect,
+  }
+}
+
+export class PlanEventDeliveryServiceTag extends Context.Service<
+  PlanEventDeliveryServiceTag,
+  ReturnType<typeof makePlanEventDeliveryService>
+>()('@lota-sdk/core/PlanEventDeliveryService') {}
+
+export const PlanEventDeliveryServiceLive = Layer.effect(
+  PlanEventDeliveryServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const redis = yield* RedisServiceTag
+    const planRunService = yield* PlanRunServiceTag
+    const userService = yield* UserServiceTag
+    return makePlanEventDeliveryService({ db, redis, planRunService, userService })
+  }),
+)

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

@@ -0,0 +1,35 @@
+import type { Context } from 'effect'
+
+import type { SurrealDBService } from '../../db/service'
+import type { makeGeneratedDocumentStorageService } from '../../storage/generated-document-storage.service'
+import type { makeArtifactService } from '../artifact.service'
+import type { FeedbackLoopServiceTag } from '../feedback-loop.service'
+import type { InstitutionalMemoryServiceTag } from '../institutional-memory.service'
+import type { QualityMetricsServiceTag } from '../quality-metrics.service'
+import type { makePlanApprovalService } from './plan-approval.service'
+import type { makePlanArtifactService } from './plan-artifact.service'
+import type { makePlanCheckpointService } from './plan-checkpoint.service'
+import type { makePlanCompletionSideEffects } from './plan-completion-side-effects'
+import type { makePlanCoordinationService } from './plan-coordination.service'
+import type { makePlanEventDeliveryService } from './plan-event-delivery.service'
+import type { makePlanRunService } from './plan-run.service'
+import type { makePlanSchedulerService } from './plan-scheduler.service'
+import type { makePlanValidatorService } from './plan-validator.service'
+
+export interface PlanExecutorContext {
+  databaseService: SurrealDBService
+  generatedDocumentStorageService: ReturnType<typeof makeGeneratedDocumentStorageService>
+  artifactService: ReturnType<typeof makeArtifactService>
+  feedbackLoopService: Context.Service.Shape<typeof FeedbackLoopServiceTag>
+  institutionalMemoryService: Context.Service.Shape<typeof InstitutionalMemoryServiceTag>
+  planApprovalService: ReturnType<typeof makePlanApprovalService>
+  planArtifactService: ReturnType<typeof makePlanArtifactService>
+  planCheckpointService: ReturnType<typeof makePlanCheckpointService>
+  planCoordinationService: ReturnType<typeof makePlanCoordinationService>
+  planEventDeliveryService: ReturnType<typeof makePlanEventDeliveryService>
+  planRunService: ReturnType<typeof makePlanRunService>
+  planSchedulerService: ReturnType<typeof makePlanSchedulerService>
+  planValidatorService: ReturnType<typeof makePlanValidatorService>
+  qualityMetricsService: Context.Service.Shape<typeof QualityMetricsServiceTag>
+  planCompletionSideEffects: ReturnType<typeof makePlanCompletionSideEffects>
+}