@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -12,48 +12,53 @@ import { nowDate } from '../../utils/date-time'
 import type { HumanNodeResponsePayload } from './plan-executor-helpers'
 
 export function makePlanApprovalService(db: SurrealDBService) {
-  const createPendingApprovalEffect = (params: {
+  const createPendingApprovalEffect = Effect.fn('PlanApproval.createPendingApproval')(function* (params: {
     tx: DatabaseTransaction
     runId: RecordIdInput
     nodeRunId: RecordIdInput
     nodeId: string
     requestedBy: string
     presented: Record<string, unknown>
-  }) =>
-    Effect.gen(function* () {
-      const approvalId = new RecordId(TABLES.PLAN_APPROVAL, Bun.randomUUIDv7())
-      const created = yield* params.tx
-        .create(approvalId)
-        .content({
-          runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
-          nodeRunId: ensureRecordId(params.nodeRunId, TABLES.PLAN_NODE_RUN),
-          nodeId: params.nodeId,
-          status: 'pending',
-          requestedBy: params.requestedBy,
-          presented: params.presented,
-          requiredEdits: [],
-        })
-        .output('after')
+  }) {
+    const approvalId = new RecordId(TABLES.PLAN_APPROVAL, Bun.randomUUIDv7())
+    const created = yield* params.tx
+      .create(approvalId)
+      .content({
+        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+        nodeRunId: ensureRecordId(params.nodeRunId, TABLES.PLAN_NODE_RUN),
+        nodeId: params.nodeId,
+        status: 'pending',
+        requestedBy: params.requestedBy,
+        presented: params.presented,
+        requiredEdits: [],
+      })
+      .output('after')
 
-      return PlanApprovalSchema.parse(created)
-    })
+    return PlanApprovalSchema.parse(created)
+  })
 
-  const getApprovalByIdEffect = (approvalId: RecordIdInput) =>
-    db.findOne(TABLES.PLAN_APPROVAL, { id: ensureRecordId(approvalId, TABLES.PLAN_APPROVAL) }, PlanApprovalSchema)
+  const getApprovalByIdEffect = Effect.fn('PlanApproval.getApprovalById')(function* (approvalId: RecordIdInput) {
+    return yield* db.findOne(
+      TABLES.PLAN_APPROVAL,
+      { id: ensureRecordId(approvalId, TABLES.PLAN_APPROVAL) },
+      PlanApprovalSchema,
+    )
+  })
 
-  const getPendingApprovalForNodeRunEffect = (nodeRunId: RecordIdInput) =>
-    Effect.gen(function* () {
-      const approvals = yield* db.findMany(
-        TABLES.PLAN_APPROVAL,
-        { nodeRunId: ensureRecordId(nodeRunId, TABLES.PLAN_NODE_RUN), status: 'pending' },
-        PlanApprovalSchema,
-        { orderBy: 'createdAt', orderDir: 'DESC', limit: 1 },
-      )
+  const getPendingApprovalForNodeRunEffect = Effect.fn('PlanApproval.getPendingApprovalForNodeRun')(function* (
+    nodeRunId: RecordIdInput,
+  ) {
+    const approvals = yield* db.findMany(
+      TABLES.PLAN_APPROVAL,
+      { nodeRunId: ensureRecordId(nodeRunId, TABLES.PLAN_NODE_RUN), status: 'pending' },
+      PlanApprovalSchema,
+      { orderBy: 'createdAt', orderDir: 'DESC', limit: 1 },
+    )
 
-      return approvals.at(0) ?? null
-    })
+    return approvals.at(0) ?? null
+  })
 
-  const updateApprovalResponseEffect = (params: {
+  const updateApprovalResponseEffect = Effect.fn('PlanApproval.updateApprovalResponse')(function* (params: {
     tx: DatabaseTransaction
     approval: PlanApprovalRecord
     status: PlanApprovalStatus
@@ -62,23 +67,22 @@ export function makePlanApprovalService(db: SurrealDBService) {
     approvalMessageId?: string
     comments?: string
     requiredEdits?: string[]
-  }) =>
-    Effect.gen(function* () {
-      const updated = yield* params.tx
-        .update(ensureRecordId(params.approval.id, TABLES.PLAN_APPROVAL))
-        .merge({
-          status: params.status,
-          response: params.response,
-          respondedBy: params.respondedBy,
-          ...(params.approvalMessageId ? { approvalMessageId: params.approvalMessageId } : {}),
-          ...(params.comments ? { comments: params.comments } : {}),
-          ...(params.requiredEdits ? { requiredEdits: params.requiredEdits } : {}),
-          respondedAt: nowDate(),
-        })
-        .output('after')
+  }) {
+    const updated = yield* params.tx
+      .update(ensureRecordId(params.approval.id, TABLES.PLAN_APPROVAL))
+      .merge({
+        status: params.status,
+        response: params.response,
+        respondedBy: params.respondedBy,
+        ...(params.approvalMessageId ? { approvalMessageId: params.approvalMessageId } : {}),
+        ...(params.comments ? { comments: params.comments } : {}),
+        ...(params.requiredEdits ? { requiredEdits: params.requiredEdits } : {}),
+        respondedAt: nowDate(),
+      })
+      .output('after')
 
-      return PlanApprovalSchema.parse(updated)
-    })
+    return PlanApprovalSchema.parse(updated)
+  })
 
   return {
     createPendingApproval: createPendingApprovalEffect,
@@ -91,7 +95,7 @@ export function makePlanApprovalService(db: SurrealDBService) {
 export class PlanApprovalServiceTag extends Context.Service<
   PlanApprovalServiceTag,
   ReturnType<typeof makePlanApprovalService>
->()('PlanApprovalService') {}
+>()('@lota-sdk/core/PlanApprovalService') {}
 
 export const PlanApprovalServiceLive = Layer.effect(
   PlanApprovalServiceTag,

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

@@ -55,6 +55,6 @@ export function makePlanArtifactService() {
 export class PlanArtifactServiceTag extends Context.Service<
   PlanArtifactServiceTag,
   ReturnType<typeof makePlanArtifactService>
->()('PlanArtifactService') {}
+>()('@lota-sdk/core/PlanArtifactService') {}
 
-export const PlanArtifactServiceLive = Layer.succeed(PlanArtifactServiceTag, makePlanArtifactService())
+export const PlanArtifactServiceLive = Layer.sync(PlanArtifactServiceTag, () => makePlanArtifactService())

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

@@ -71,6 +71,6 @@ export function makePlanBuilderService() {
 export class PlanBuilderServiceTag extends Context.Service<
   PlanBuilderServiceTag,
   ReturnType<typeof makePlanBuilderService>
->()('PlanBuilderService') {}
+>()('@lota-sdk/core/PlanBuilderService') {}
 
-export const PlanBuilderServiceLive = Layer.succeed(PlanBuilderServiceTag, makePlanBuilderService())
+export const PlanBuilderServiceLive = Layer.sync(PlanBuilderServiceTag, () => makePlanBuilderService())

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

@@ -91,7 +91,7 @@ export function makePlanCheckpointService(deps: PlanCheckpointDeps) {
 export class PlanCheckpointServiceTag extends Context.Service<
   PlanCheckpointServiceTag,
   ReturnType<typeof makePlanCheckpointService>
->()('PlanCheckpointService') {}
+>()('@lota-sdk/core/PlanCheckpointService') {}
 
 export const PlanCheckpointServiceLive = Layer.effect(
   PlanCheckpointServiceTag,

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

@@ -95,7 +95,7 @@ export function makePlanCompilerService(planValidatorService: ReturnType<typeof
 export class PlanCompilerServiceTag extends Context.Service<
   PlanCompilerServiceTag,
   ReturnType<typeof makePlanCompilerService>
->()('PlanCompilerService') {}
+>()('@lota-sdk/core/PlanCompilerService') {}
 
 export const PlanCompilerServiceLive = Layer.effect(
   PlanCompilerServiceTag,

package/src/services/plan/plan-completion-side-effects.ts

@@ -6,7 +6,7 @@ import { aiLogger } from '../../config/logger'
 import { ensureRecordId } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { runPromise } from '../../effect/runtime'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 import type { makeFeedbackLoopService } from '../feedback-loop.service'
 import type { makeInstitutionalMemoryService } from '../institutional-memory.service'
@@ -33,25 +33,15 @@ class PlanCompletionSideEffectsError extends Schema.TaggedErrorClass<PlanComplet
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
+const effectTryPlanCompletionPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new PlanCompletionSideEffectsError({ message, cause }),
+)
+
 function tryPlanCompletionPromise<A>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, PlanCompletionSideEffectsError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new PlanCompletionSideEffectsError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new PlanCompletionSideEffectsError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new PlanCompletionSideEffectsError({ message, cause }))
-    }
-  })
+  return effectTryPlanCompletionPromise(evaluate, message)
 }
 
 export function makePlanCompletionSideEffects({
@@ -62,114 +52,110 @@ export function makePlanCompletionSideEffects({
   planRunService,
   qualityMetricsService,
 }: PlanCompletionSideEffectsDeps) {
-  function runPlanNodeCompletionSideEffects(params: {
-    runId: string
-    organizationId: string
-    nodeId: string
-    nodeLabel: string
-    nodeOwnerRef: string
-    nodeOwnerType: PlanNodeOwner['executorType']
-    nodeType: PlanNodeType
-    nodeStartedAt?: string | Date | null
-    nodeAttemptCount: number
-    artifactCount: number
-    validationIssues: PlanValidationIssueInput[]
-  }): Promise<void> {
-    return runPromise(
-      Effect.gen(function* () {
-        const executionTimeMs = params.nodeStartedAt
-          ? nowEpochMillis() - unsafeDateFrom(params.nodeStartedAt).getTime()
-          : 0
-        if (executionTimeMs > 0) {
-          yield* Metric.update(
-            Metric.withAttributes(planNodeExecutionDuration, { nodeType: params.nodeType }),
-            executionTimeMs,
-          )
-        }
-        yield* qualityMetricsService.recordNodeMetrics({
-          organizationId: params.organizationId,
-          runId: params.runId,
-          nodeId: params.nodeId,
-          metrics: {
-            executionTimeMs: Math.max(0, executionTimeMs),
-            attemptCount: params.nodeAttemptCount,
-            artifactCount: params.artifactCount,
-            validationIssueCount: params.validationIssues.length,
-            ownerRef: params.nodeOwnerRef,
-            ownerType: params.nodeOwnerType,
-            nodeType: params.nodeType,
-          },
-        })
-      }),
-    )
-  }
+  const runPlanNodeCompletionSideEffects = Effect.fn('PlanCompletionSideEffects.runPlanNodeCompletionSideEffects')(
+    function* (params: {
+      runId: string
+      organizationId: string
+      nodeId: string
+      nodeLabel: string
+      nodeOwnerRef: string
+      nodeOwnerType: PlanNodeOwner['executorType']
+      nodeType: PlanNodeType
+      nodeStartedAt?: string | Date | null
+      nodeAttemptCount: number
+      artifactCount: number
+      validationIssues: PlanValidationIssueInput[]
+    }) {
+      const executionTimeMs = params.nodeStartedAt
+        ? nowEpochMillis() - unsafeDateFrom(params.nodeStartedAt).getTime()
+        : 0
+      if (executionTimeMs > 0) {
+        yield* Metric.update(
+          Metric.withAttributes(planNodeExecutionDuration, { nodeType: params.nodeType }),
+          executionTimeMs,
+        )
+      }
+      yield* qualityMetricsService.recordNodeMetrics({
+        organizationId: params.organizationId,
+        runId: params.runId,
+        nodeId: params.nodeId,
+        metrics: {
+          executionTimeMs: Math.max(0, executionTimeMs),
+          attemptCount: params.nodeAttemptCount,
+          artifactCount: params.artifactCount,
+          validationIssueCount: params.validationIssues.length,
+          ownerRef: params.nodeOwnerRef,
+          ownerType: params.nodeOwnerType,
+          nodeType: params.nodeType,
+        },
+      })
+    },
+  )
 
-  function runPlanCompletionSideEffects(params: { runId: string; organizationId: string }): Promise<void> {
-    return runPromise(
-      Effect.gen(function* () {
-        yield* qualityMetricsService.recordCycleMetrics({ organizationId: params.organizationId, runId: params.runId })
+  const runPlanCompletionSideEffects = Effect.fn('PlanCompletionSideEffects.runPlanCompletionSideEffects')(
+    function* (params: { runId: string; organizationId: string }) {
+      yield* qualityMetricsService.recordCycleMetrics({ organizationId: params.organizationId, runId: params.runId })
 
-        const recommendations = yield* feedbackLoopService
-          .analyzeOutcomes({ runId: params.runId, organizationId: params.organizationId })
+      const recommendations = yield* feedbackLoopService
+        .analyzeOutcomes({ runId: params.runId, organizationId: params.organizationId })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new PlanCompletionSideEffectsError({ message: 'Failed to analyze plan feedback outcomes.', cause }),
+          ),
+        )
+      if (recommendations.length > 0) {
+        const run = yield* planRunService.getRunById(params.runId)
+        const specRecord = yield* planRunService.getPlanSpecById(run.planSpecId)
+        const event = yield* tryPlanCompletionPromise('Failed to create feedback analyzed plan event.', () =>
+          databaseService.create(
+            TABLES.PLAN_EVENT,
+            {
+              planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
+              runId: ensureRecordId(run.id, TABLES.PLAN_RUN),
+              eventType: 'feedback-analyzed',
+              message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
+              detail: { recommendations },
+              emittedBy: 'system',
+            },
+            PlanEventSchema,
+          ),
+        )
+        yield* planEventDeliveryService
+          .dispatchEvent(event)
           .pipe(
             Effect.mapError(
-              (cause) =>
-                new PlanCompletionSideEffectsError({ message: 'Failed to analyze plan feedback outcomes.', cause }),
-            ),
-          )
-        if (recommendations.length > 0) {
-          const run = yield* planRunService.getRunById(params.runId)
-          const specRecord = yield* planRunService.getPlanSpecById(run.planSpecId)
-          const event = yield* tryPlanCompletionPromise('Failed to create feedback analyzed plan event.', () =>
-            databaseService.create(
-              TABLES.PLAN_EVENT,
-              {
-                planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
-                runId: ensureRecordId(run.id, TABLES.PLAN_RUN),
-                eventType: 'feedback-analyzed',
-                message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
-                detail: { recommendations },
-                emittedBy: 'system',
-              },
-              PlanEventSchema,
+              (error) =>
+                new PlanCompletionSideEffectsError({
+                  message: 'Failed to dispatch feedback analyzed plan event.',
+                  cause: error,
+                }),
             ),
           )
-          yield* Effect.tryPromise({
-            try: () => planEventDeliveryService.dispatchEvent(event),
-            catch: (cause) =>
+      }
+
+      yield* institutionalMemoryService
+        .extractPatterns({ organizationId: params.organizationId, runId: params.runId })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
               new PlanCompletionSideEffectsError({
-                message: 'Failed to dispatch feedback analyzed plan event.',
+                message: 'Failed to extract institutional memory patterns.',
                 cause,
               }),
-          })
-        }
-
-        yield* institutionalMemoryService
-          .extractPatterns({ organizationId: params.organizationId, runId: params.runId })
-          .pipe(
-            Effect.mapError(
-              (cause) =>
-                new PlanCompletionSideEffectsError({
-                  message: 'Failed to extract institutional memory patterns.',
-                  cause,
-                }),
-            ),
-          )
-      }),
-    )
-  }
+          ),
+        )
+    },
+  )
 
-  function runPlanCompletionSideEffectsSafely(params: { runId: string; organizationId: string }): Promise<void> {
-    return runPromise(
-      Effect.catch(
-        tryPlanCompletionPromise('Plan completion side effects failed.', () => runPlanCompletionSideEffects(params)),
-        (error: unknown) =>
-          Effect.sync(() => {
-            aiLogger.warn`Plan completion side effects failed for run ${params.runId}: ${error instanceof Error ? error.message : String(error)}`
-          }),
+  const runPlanCompletionSideEffectsSafely = (params: { runId: string; organizationId: string }) =>
+    runPlanCompletionSideEffects(params).pipe(
+      Effect.catch((error) =>
+        Effect.sync(() => {
+          aiLogger.warn`Plan completion side effects failed for run ${params.runId}: ${error instanceof Error ? error.message : String(error)}`
+        }),
       ),
     )
-  }
 
   return { runPlanNodeCompletionSideEffects, runPlanCompletionSideEffectsSafely }
 }

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

@@ -170,7 +170,7 @@ export function makePlanCoordinationService(planRunService: ReturnType<typeof ma
 export class PlanCoordinationServiceTag extends Context.Service<
   PlanCoordinationServiceTag,
   ReturnType<typeof makePlanCoordinationService>
->()('PlanCoordinationService') {}
+>()('@lota-sdk/core/PlanCoordinationService') {}
 
 export const PlanCoordinationServiceLive = Layer.effect(
   PlanCoordinationServiceTag,