@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -1,15 +1,21 @@
 import type { PlanEventRecord } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 
+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 { runPromise } from '../../effect/runtime'
-import { DatabaseServiceTag, RedisServiceTag } from '../../effect/services'
+import {
+  AgentConfigServiceTag,
+  DatabaseServiceTag,
+  RedisServiceTag,
+  RuntimeAdaptersServiceTag,
+} from '../../effect/services'
+import type { PlanAgentHeartbeatQueueRuntime } from '../../queues/plan-agent-heartbeat.queue'
+import { LotaQueuesServiceTag } from '../../queues/queues.service'
 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 type { LotaRuntimeAdapters, LotaRuntimePlanEventEnvelope } from '../../runtime/runtime-extensions'
 import { getErrorMessage } from '../../utils/errors'
 import { ThreadSchema } from '../thread/thread.types'
 import type { makeUserService } from '../user.service'
@@ -28,19 +34,22 @@ function buildDeliveredKey(eventId: string): string {
   return `plan-event:delivered:${eventId}`
 }
 
-function dispatchAdapterEvent(envelope: LotaRuntimePlanEventEnvelope) {
-  const adapter = getRuntimeAdapters().planEventAdapter
-  if (!adapter) {
-    return Effect.void
-  }
+function dispatchAdapterEvent(runtimeAdapters: LotaRuntimeAdapters, envelope: LotaRuntimePlanEventEnvelope) {
+  return Effect.gen(function* () {
+    const adapter = runtimeAdapters.planEventAdapter
+    if (!adapter) {
+      return
+    }
 
-  return Effect.tryPromise({
-    try: () => adapter.onPlanEvent(envelope),
-    catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    yield* Effect.tryPromise({
+      try: () => adapter.onPlanEvent(envelope),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    })
   })
 }
 
 function resolveWakeTarget(
+  agentConfig: ResolvedAgentConfig,
   envelope: LotaRuntimePlanEventEnvelope,
   nodeSpecsById: Map<string, NonNullable<LotaRuntimePlanEventEnvelope['nodeSpec']>>,
 ): { nodeId: string; agentId: string; reason: string } | null {
@@ -55,7 +64,7 @@ function resolveWakeTarget(
     return null
   }
 
-  const isVisible = resolvePlanNodeExecutionVisibility(envelope.spec, effectiveNodeSpec) === 'visible'
+  const isVisible = resolvePlanNodeExecutionVisibility(agentConfig, envelope.spec, effectiveNodeSpec) === 'visible'
   if (!isVisible) {
     return null
   }
@@ -76,22 +85,20 @@ function resolveWakeTarget(
 }
 
 function enqueueWakeIfNeeded(
+  agentConfig: ResolvedAgentConfig,
   envelope: LotaRuntimePlanEventEnvelope,
   nodeSpecsById: Map<string, NonNullable<LotaRuntimePlanEventEnvelope['nodeSpec']>>,
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime,
 ) {
   return Effect.gen(function* () {
-    const wakeTarget = resolveWakeTarget(envelope, nodeSpecsById)
+    const wakeTarget = resolveWakeTarget(agentConfig, 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({
+        planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake({
           organizationId: envelope.organizationId,
           threadId: envelope.threadId,
           runId: envelope.runId,
@@ -105,14 +112,17 @@ function enqueueWakeIfNeeded(
 }
 
 interface PlanEventDeliveryDeps {
+  agentConfig: ResolvedAgentConfig
   db: SurrealDBService
   redis: RedisConnectionManager
   planRunService: ReturnType<typeof makePlanRunService>
   userService: ReturnType<typeof makeUserService>
+  planAgentHeartbeatQueue: PlanAgentHeartbeatQueueRuntime
+  runtimeAdapters: LotaRuntimeAdapters
 }
 
 export function makePlanEventDeliveryService(deps: PlanEventDeliveryDeps) {
-  const { db, redis, planRunService, userService } = deps
+  const { agentConfig, db, redis, planRunService, userService, planAgentHeartbeatQueue, runtimeAdapters } = deps
 
   function deliverEvent(event: PlanEventRecord) {
     return Effect.gen(function* () {
@@ -182,80 +192,82 @@ export function makePlanEventDeliveryService(deps: PlanEventDeliveryDeps) {
         ...(userName ? { userName } : {}),
       }
 
-      yield* dispatchAdapterEvent(envelope)
-      yield* enqueueWakeIfNeeded(envelope, nodeSpecsById)
+      yield* dispatchAdapterEvent(runtimeAdapters, envelope)
+      yield* enqueueWakeIfNeeded(agentConfig, envelope, nodeSpecsById, planAgentHeartbeatQueue)
     })
   }
 
-  function dispatchEventEffect(event: PlanEventRecord) {
-    return Effect.gen(function* () {
-      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 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 }),
     })
-  }
-
-  function dispatchUndeliveredEventsEffect(runId: string, options?: { limit?: number }) {
-    return Effect.gen(function* () {
-      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 })))
+    if (exists) {
+      return
+    }
 
-      for (const event of events) {
-        yield* dispatchEventEffect(event)
-      }
+    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 }),
     })
-  }
+  })
 
-  return {
-    dispatchEvents(events: PlanEventRecord[]): Promise<void> {
-      return runPromise(
-        Effect.gen(function* () {
-          const runIds = new Set(events.map((event) => recordIdToString(event.runId, TABLES.PLAN_RUN)))
-          for (const runId of runIds) {
-            yield* dispatchUndeliveredEventsEffect(runId)
-          }
-        }),
-      )
-    },
+  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)
+    }
+  })
 
-    dispatchEvent(event: PlanEventRecord): Promise<void> {
-      return runPromise(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)
+    }
+  })
 
-    dispatchUndeliveredEvents(runId: string, options?: { limit?: number }): Promise<void> {
-      return runPromise(dispatchUndeliveredEventsEffect(runId, options))
-    },
+  return {
+    dispatchEvents: dispatchEventsEffect,
+    dispatchEvent: dispatchEventEffect,
+    dispatchUndeliveredEvents: dispatchUndeliveredEventsEffect,
   }
 }
 
 export class PlanEventDeliveryServiceTag extends Context.Service<
   PlanEventDeliveryServiceTag,
   ReturnType<typeof makePlanEventDeliveryService>
->()('PlanEventDeliveryService') {}
+>()('@lota-sdk/core/PlanEventDeliveryService') {}
 
 export const PlanEventDeliveryServiceLive = Layer.effect(
   PlanEventDeliveryServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const db = yield* DatabaseServiceTag
     const redis = yield* RedisServiceTag
     const planRunService = yield* PlanRunServiceTag
     const userService = yield* UserServiceTag
-    return makePlanEventDeliveryService({ db, redis, planRunService, userService })
+    const queues = yield* LotaQueuesServiceTag
+    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+    return makePlanEventDeliveryService({
+      agentConfig,
+      db,
+      redis,
+      planRunService,
+      userService,
+      planAgentHeartbeatQueue: queues.planAgentHeartbeat,
+      runtimeAdapters,
+    })
   }),
 )

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

@@ -1,6 +1,7 @@
 import type { Context } from 'effect'
 
 import type { SurrealDBService } from '../../db/service'
+import type { DelayedNodePromotionQueueRuntime } from '../../queues/delayed-node-promotion.queue'
 import type { makeGeneratedDocumentStorageService } from '../../storage/generated-document-storage.service'
 import type { makeArtifactService } from '../artifact.service'
 import type { FeedbackLoopServiceTag } from '../feedback-loop.service'
@@ -32,4 +33,5 @@ export interface PlanExecutorContext {
   planValidatorService: ReturnType<typeof makePlanValidatorService>
   qualityMetricsService: Context.Service.Shape<typeof QualityMetricsServiceTag>
   planCompletionSideEffects: ReturnType<typeof makePlanCompletionSideEffects>
+  delayedNodePromotionQueue: DelayedNodePromotionQueueRuntime
 }