@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -1,515 +0,0 @@
-import {
-  PlanApprovalSchema,
-  PlanArtifactSchema,
-  PlanCheckpointSchema,
-  PlanEventSchema,
-  PlanNodeAttemptSchema,
-  PlanNodeRunSchema,
-  PlanNodeSpecRecordSchema,
-  PlanRunSchema,
-  PlanSpecSchema,
-  PlanValidationIssueSchema,
-} from '@lota-sdk/shared'
-import type {
-  PlanApprovalRecord,
-  PlanArtifactRecord,
-  PlanCheckpointRecord,
-  PlanEventRecord,
-  PlanNodeAttemptRecord,
-  PlanNodeRunRecord,
-  PlanNodeRunStatus,
-  PlanNodeSpecRecord,
-  PlanRunRecord,
-  PlanSpecRecord,
-  PlanValidationIssueRecord,
-  SerializableExecutionPlan,
-  SerializablePlanApproval,
-  SerializablePlanArtifact,
-  SerializablePlanCheckpoint,
-  SerializablePlanEvent,
-  SerializablePlanNode,
-  SerializablePlanValidationIssue,
-} from '@lota-sdk/shared'
-
-import type { RecordIdInput } from '../db/record-id'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { TABLES } from '../db/tables'
-import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
-
-const ACTIVE_RUN_STATUSES = new Set(['pending-approval', 'running', 'awaiting-human', 'blocked'])
-
-function buildProgress(nodeRuns: PlanNodeRunRecord[]) {
-  const counts = nodeRuns.reduce(
-    (summary, nodeRun) => {
-      summary[nodeRun.status] += 1
-      return summary
-    },
-    {
-      pending: 0,
-      ready: 0,
-      running: 0,
-      'awaiting-human': 0,
-      completed: 0,
-      partial: 0,
-      blocked: 0,
-      failed: 0,
-      skipped: 0,
-      scheduled: 0,
-      monitoring: 0,
-    } satisfies Record<PlanNodeRunStatus, number>,
-  )
-
-  const total = nodeRuns.length
-  const completedWork = counts.completed + counts.partial + counts.skipped
-
-  return {
-    total,
-    pending: counts.pending,
-    ready: counts.ready,
-    running: counts.running,
-    awaitingHuman: counts['awaiting-human'],
-    completed: counts.completed,
-    partial: counts.partial,
-    blocked: counts.blocked,
-    failed: counts.failed,
-    skipped: counts.skipped,
-    scheduled: counts.scheduled,
-    monitoring: counts.monitoring,
-    completionRatio: total > 0 ? Number((completedWork / total).toFixed(4)) : undefined,
-  }
-}
-
-function serializeArtifact(artifact: PlanArtifactRecord): SerializablePlanArtifact {
-  return {
-    id: recordIdToString(artifact.id, TABLES.PLAN_ARTIFACT),
-    nodeId: artifact.nodeId,
-    attemptId: recordIdToString(artifact.attemptId, TABLES.PLAN_NODE_ATTEMPT),
-    name: artifact.name,
-    kind: artifact.kind,
-    pointer: artifact.pointer,
-    schemaRef: artifact.schemaRef,
-    description: artifact.description,
-    content: artifact.content,
-    payload: artifact.payload,
-    publishedArtifactId: artifact.publishedArtifactId
-      ? recordIdToString(artifact.publishedArtifactId, TABLES.ARTIFACT)
-      : undefined,
-    createdAt: toIsoDateTimeString(artifact.createdAt),
-  }
-}
-
-function serializeValidationIssue(issue: PlanValidationIssueRecord): SerializablePlanValidationIssue {
-  return {
-    id: recordIdToString(issue.id, TABLES.PLAN_VALIDATION_ISSUE),
-    nodeId: issue.nodeId,
-    attemptId: issue.attemptId ? recordIdToString(issue.attemptId, TABLES.PLAN_NODE_ATTEMPT) : undefined,
-    severity: issue.severity,
-    code: issue.code,
-    message: issue.message,
-    detail: issue.detail,
-    createdAt: toIsoDateTimeString(issue.createdAt),
-  }
-}
-
-function serializeApproval(approval: PlanApprovalRecord): SerializablePlanApproval {
-  return {
-    id: recordIdToString(approval.id, TABLES.PLAN_APPROVAL),
-    nodeId: approval.nodeId,
-    status: approval.status,
-    presented: approval.presented,
-    response: approval.response,
-    requestedBy: approval.requestedBy,
-    respondedBy: approval.respondedBy,
-    approvalMessageId: approval.approvalMessageId,
-    comments: approval.comments,
-    requiredEdits: [...approval.requiredEdits],
-    createdAt: toIsoDateTimeString(approval.createdAt),
-    respondedAt: toOptionalIsoDateTimeString(approval.respondedAt),
-  }
-}
-
-function serializeCheckpoint(checkpoint: PlanCheckpointRecord): SerializablePlanCheckpoint {
-  return {
-    id: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
-    sequence: checkpoint.sequence,
-    runStatus: checkpoint.runStatus,
-    readyNodeIds: [...checkpoint.readyNodeIds],
-    activeNodeIds: [...checkpoint.activeNodeIds],
-    artifactIds: checkpoint.artifactIds.map((artifactId) => recordIdToString(artifactId, TABLES.PLAN_ARTIFACT)),
-    lastCompletedNodeIds: [...checkpoint.lastCompletedNodeIds],
-    snapshot: checkpoint.snapshot,
-    createdAt: toIsoDateTimeString(checkpoint.createdAt),
-  }
-}
-
-function serializeEvent(event: PlanEventRecord): SerializablePlanEvent {
-  return {
-    id: recordIdToString(event.id, TABLES.PLAN_EVENT),
-    nodeId: event.nodeId,
-    attemptId: event.attemptId ? recordIdToString(event.attemptId, TABLES.PLAN_NODE_ATTEMPT) : undefined,
-    approvalId: event.approvalId ? recordIdToString(event.approvalId, TABLES.PLAN_APPROVAL) : undefined,
-    eventType: event.eventType,
-    fromStatus: event.fromStatus,
-    toStatus: event.toStatus,
-    message: event.message,
-    detail: event.detail,
-    emittedBy: event.emittedBy,
-    createdAt: toIsoDateTimeString(event.createdAt),
-  }
-}
-
-class PlanRunService {
-  async getPlanSpecById(planSpecId: RecordIdInput): Promise<PlanSpecRecord> {
-    const spec = await databaseService.findOne(
-      TABLES.PLAN_SPEC,
-      { id: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) },
-      PlanSpecSchema,
-    )
-    if (!spec) {
-      throw new Error(`Plan spec not found: ${recordIdToString(planSpecId, TABLES.PLAN_SPEC)}`)
-    }
-    return spec
-  }
-
-  async listPlanSpecsByThread(threadId: RecordIdInput): Promise<PlanSpecRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_SPEC,
-      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
-      PlanSpecSchema,
-      { orderBy: 'createdAt', orderDir: 'DESC' },
-    )
-  }
-
-  async listRunsBySpec(planSpecId: RecordIdInput): Promise<PlanRunRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_RUN,
-      { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) },
-      PlanRunSchema,
-      { orderBy: 'createdAt', orderDir: 'DESC' },
-    )
-  }
-
-  async listNodeSpecs(planSpecId: RecordIdInput): Promise<PlanNodeSpecRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_NODE_SPEC,
-      { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) },
-      PlanNodeSpecRecordSchema,
-      { orderBy: 'position', orderDir: 'ASC' },
-    )
-  }
-
-  async getNodeSpecByNodeId(planSpecId: RecordIdInput, nodeId: string): Promise<PlanNodeSpecRecord> {
-    const nodeSpec = await databaseService.findOne(
-      TABLES.PLAN_NODE_SPEC,
-      { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC), nodeId },
-      PlanNodeSpecRecordSchema,
-    )
-    if (!nodeSpec) {
-      throw new Error(`Plan node spec "${nodeId}" not found.`)
-    }
-    return nodeSpec
-  }
-
-  async getRunById(runId: RecordIdInput): Promise<PlanRunRecord> {
-    const run = await databaseService.findOne(
-      TABLES.PLAN_RUN,
-      { id: ensureRecordId(runId, TABLES.PLAN_RUN) },
-      PlanRunSchema,
-    )
-    if (!run) {
-      throw new Error(`Plan run not found: ${recordIdToString(runId, TABLES.PLAN_RUN)}`)
-    }
-    return run
-  }
-
-  async getActiveRunRecord(threadId: RecordIdInput): Promise<PlanRunRecord | null> {
-    const runs = await this.getActiveRunRecords(threadId)
-    return runs[0] ?? null
-  }
-
-  async getActiveRunRecords(threadId: RecordIdInput): Promise<PlanRunRecord[]> {
-    const runs = await databaseService.findMany(
-      TABLES.PLAN_RUN,
-      { threadId: ensureRecordId(threadId, TABLES.THREAD) },
-      PlanRunSchema,
-      { orderBy: 'updatedAt', orderDir: 'DESC' },
-    )
-
-    return runs.filter((run) => ACTIVE_RUN_STATUSES.has(run.status))
-  }
-
-  async getRunsCreatedInContext(params: {
-    organizationId: RecordIdInput
-    sourceThreadId?: RecordIdInput
-    createdByAgentId?: string
-    statuses?: ReadonlyArray<PlanRunRecord['status']>
-  }): Promise<PlanRunRecord[]> {
-    const filter: Record<string, unknown> = {
-      organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-    }
-    if (params.sourceThreadId) {
-      filter.sourceThreadId = ensureRecordId(params.sourceThreadId, TABLES.THREAD)
-    }
-    if (params.createdByAgentId) {
-      filter.createdByAgentId = params.createdByAgentId
-    }
-
-    const runs = await databaseService.findMany(TABLES.PLAN_RUN, filter, PlanRunSchema, {
-      orderBy: 'updatedAt',
-      orderDir: 'DESC',
-    })
-
-    const statuses = params.statuses ? new Set(params.statuses) : ACTIVE_RUN_STATUSES
-    return runs.filter((run) => statuses.has(run.status))
-  }
-
-  async listNodeRuns(runId: RecordIdInput): Promise<PlanNodeRunRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_NODE_RUN,
-      { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
-      PlanNodeRunSchema,
-      { orderBy: 'nodeId', orderDir: 'ASC' },
-    )
-  }
-
-  async getNodeRunByNodeId(runId: RecordIdInput, nodeId: string): Promise<PlanNodeRunRecord> {
-    const nodeRun = await databaseService.findOne(
-      TABLES.PLAN_NODE_RUN,
-      { runId: ensureRecordId(runId, TABLES.PLAN_RUN), nodeId },
-      PlanNodeRunSchema,
-    )
-    if (!nodeRun) {
-      throw new Error(`Plan node run "${nodeId}" not found.`)
-    }
-    return nodeRun
-  }
-
-  async listArtifacts(runId: RecordIdInput): Promise<PlanArtifactRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_ARTIFACT,
-      { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
-      PlanArtifactSchema,
-      { orderBy: 'createdAt', orderDir: 'ASC' },
-    )
-  }
-
-  async listAttempts(runId: RecordIdInput): Promise<PlanNodeAttemptRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_NODE_ATTEMPT,
-      { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
-      PlanNodeAttemptSchema,
-      { orderBy: 'createdAt', orderDir: 'ASC' },
-    )
-  }
-
-  async listValidationIssues(params: {
-    runId?: RecordIdInput
-    planSpecId?: RecordIdInput
-    attemptId?: RecordIdInput
-  }): Promise<PlanValidationIssueRecord[]> {
-    const filter: Record<string, unknown> = {}
-    if (params.runId) filter.runId = ensureRecordId(params.runId, TABLES.PLAN_RUN)
-    if (params.planSpecId) filter.planSpecId = ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC)
-    if (params.attemptId) filter.attemptId = ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT)
-
-    return databaseService.findMany(TABLES.PLAN_VALIDATION_ISSUE, filter, PlanValidationIssueSchema, {
-      orderBy: 'createdAt',
-      orderDir: 'ASC',
-    })
-  }
-
-  async listApprovals(runId: RecordIdInput): Promise<PlanApprovalRecord[]> {
-    return databaseService.findMany(
-      TABLES.PLAN_APPROVAL,
-      { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
-      PlanApprovalSchema,
-      { orderBy: 'createdAt', orderDir: 'ASC' },
-    )
-  }
-
-  async getLatestCheckpoint(runId: RecordIdInput): Promise<PlanCheckpointRecord | null> {
-    const checkpoints = await databaseService.findMany(
-      TABLES.PLAN_CHECKPOINT,
-      { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
-      PlanCheckpointSchema,
-      { orderBy: 'sequence', orderDir: 'DESC', limit: 1 },
-    )
-
-    return checkpoints.at(0) ?? null
-  }
-
-  async getNextCheckpointSequence(runId: RecordIdInput): Promise<number> {
-    const latestCheckpoint = await this.getLatestCheckpoint(runId)
-    return latestCheckpoint ? latestCheckpoint.sequence + 1 : 1
-  }
-
-  async listEvents(runId: RecordIdInput, limit = 20): Promise<PlanEventRecord[]> {
-    return (
-      await databaseService.findMany(
-        TABLES.PLAN_EVENT,
-        { runId: ensureRecordId(runId, TABLES.PLAN_RUN) },
-        PlanEventSchema,
-        { orderBy: 'createdAt', orderDir: 'DESC', limit },
-      )
-    ).reverse()
-  }
-
-  async toSerializablePlan(
-    run: PlanRunRecord,
-    options?: {
-      includeArtifacts?: boolean
-      includeApprovals?: boolean
-      includeCheckpoints?: boolean
-      includeEvents?: boolean
-      includeValidationIssues?: boolean
-      /** When true, non-active/ready nodes are summarized (id, label, status, owner, objective, edges). Reduces prompt tokens. */
-      slim?: boolean
-    },
-  ): Promise<SerializableExecutionPlan> {
-    const slim = options?.slim === true
-    const spec = await this.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await this.listNodeSpecs(spec.id)
-    const nodeRuns = await this.listNodeRuns(run.id)
-    const artifacts = options?.includeArtifacts === false ? [] : await this.listArtifacts(run.id)
-    const lineageArtifacts = options?.includeArtifacts === false || slim ? [] : await this.collectLineageArtifacts(run)
-    const approvals = options?.includeApprovals === false || slim ? [] : await this.listApprovals(run.id)
-    const validationIssues =
-      options?.includeValidationIssues === false || slim
-        ? []
-        : await this.listValidationIssues({ runId: run.id, planSpecId: spec.id })
-    const latestCheckpoint = options?.includeCheckpoints ? await this.getLatestCheckpoint(run.id) : null
-    const eventLimit = slim ? 5 : 20
-    const recentEvents = options?.includeEvents === false ? [] : await this.listEvents(run.id, eventLimit)
-    const nodeRunsById = new Map(nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
-    const activeNodeIds = new Set(run.currentNodeId ? [run.currentNodeId] : [])
-    const readyNodeIds = new Set(run.readyNodeIds)
-
-    const nodes: SerializablePlanNode[] = nodeSpecs.map((nodeSpec) => {
-      const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
-      if (!nodeRun) {
-        throw new Error(
-          `Plan run ${recordIdToString(run.id, TABLES.PLAN_RUN)} is missing node run "${nodeSpec.nodeId}".`,
-        )
-      }
-
-      const isActiveOrReady = activeNodeIds.has(nodeSpec.nodeId) || readyNodeIds.has(nodeSpec.nodeId)
-
-      // Slim mode: non-active/ready nodes get summary only (used for prompt injection via JSON.stringify).
-      // The cast is safe — this data is only consumed by formatExecutionPlansForPrompt, not by Zod validation.
-      // executionPlanQuery calls toSerializablePlan without slim=true for full inspection payloads.
-      if (slim && !isActiveOrReady) {
-        return {
-          id: nodeSpec.nodeId,
-          type: nodeSpec.type,
-          label: nodeSpec.label,
-          owner: { executorType: nodeSpec.owner.executorType, ref: nodeSpec.owner.ref },
-          objective: nodeSpec.objective,
-          status: nodeRun.status,
-          upstreamNodeIds: [...nodeSpec.upstreamNodeIds],
-          downstreamNodeIds: [...nodeSpec.downstreamNodeIds],
-          ...(nodeRun.completedAt ? { completedAt: toOptionalIsoDateTimeString(nodeRun.completedAt) } : {}),
-        } as SerializablePlanNode
-      }
-
-      return {
-        id: nodeSpec.nodeId,
-        type: nodeSpec.type,
-        label: nodeSpec.label,
-        owner: nodeSpec.owner,
-        objective: nodeSpec.objective,
-        instructions: nodeSpec.instructions,
-        inputSchemaRef: nodeSpec.inputSchemaRef,
-        outputSchemaRef: nodeSpec.outputSchemaRef,
-        deliverables: [...nodeSpec.deliverables],
-        successCriteria: [...nodeSpec.successCriteria],
-        completionChecks: [...nodeSpec.completionChecks],
-        retryPolicy: { ...nodeSpec.retryPolicy, retryOn: [...nodeSpec.retryPolicy.retryOn] },
-        failurePolicy: [...nodeSpec.failurePolicy],
-        timeoutMs: nodeSpec.timeoutMs,
-        toolPolicy: { allow: [...nodeSpec.toolPolicy.allow], deny: [...nodeSpec.toolPolicy.deny] },
-        contextPolicy: {
-          retrievalScopes: [...nodeSpec.contextPolicy.retrievalScopes],
-          attachmentPolicy: nodeSpec.contextPolicy.attachmentPolicy,
-          webPolicy: nodeSpec.contextPolicy.webPolicy,
-        },
-        executionVisibility: nodeSpec.executionVisibility,
-        schedule: nodeSpec.schedule,
-        deadline: nodeSpec.deadline,
-        escalation: nodeSpec.escalation,
-        monitoringConfig: nodeSpec.monitoringConfig,
-        delayAfterPredecessorMs: nodeSpec.delayAfterPredecessorMs,
-        deliberationConfig: nodeSpec.deliberationConfig,
-        status: nodeRun.status,
-        attemptCount: nodeRun.attemptCount,
-        retryCount: nodeRun.retryCount,
-        resolvedInput: nodeRun.resolvedInput,
-        latestStructuredOutput: nodeRun.latestStructuredOutput,
-        latestNotes: nodeRun.latestNotes,
-        blockedReason: nodeRun.blockedReason,
-        failureClass: nodeRun.failureClass,
-        upstreamNodeIds: [...nodeSpec.upstreamNodeIds],
-        downstreamNodeIds: [...nodeSpec.downstreamNodeIds],
-        readyAt: toOptionalIsoDateTimeString(nodeRun.readyAt),
-        startedAt: toOptionalIsoDateTimeString(nodeRun.startedAt),
-        completedAt: toOptionalIsoDateTimeString(nodeRun.completedAt),
-      }
-    })
-
-    return {
-      specId: recordIdToString(spec.id, TABLES.PLAN_SPEC),
-      runId: recordIdToString(run.id, TABLES.PLAN_RUN),
-      threadId: recordIdToString(run.threadId, TABLES.THREAD),
-      sourceThreadId: run.sourceThreadId ? recordIdToString(run.sourceThreadId, TABLES.THREAD) : undefined,
-      organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
-      title: spec.title,
-      objective: spec.objective,
-      version: spec.version,
-      status: run.status,
-      leadAgentId: run.leadAgentId,
-      createdByAgentId: run.createdByAgentId,
-      defaultExecutionVisibility: spec.defaultExecutionVisibility,
-      executionMode: spec.executionMode,
-      schemaRegistry: slim ? {} : structuredClone(spec.schemaRegistry),
-      entryNodeIds: [...spec.entryNodeIds],
-      edges: [...spec.edges],
-      schedule: spec.schedule,
-      activeNodeIds: run.currentNodeId ? [run.currentNodeId] : [],
-      readyNodeIds: [...run.readyNodeIds],
-      waitingNodeId: run.waitingNodeId,
-      replacedRunId: run.replacedRunId ? recordIdToString(run.replacedRunId, TABLES.PLAN_RUN) : undefined,
-      failureCount: run.failureCount,
-      startedAt: toOptionalIsoDateTimeString(run.startedAt),
-      completedAt: toOptionalIsoDateTimeString(run.completedAt),
-      progress: buildProgress(nodeRuns),
-      nodes,
-      artifacts: artifacts.map(serializeArtifact),
-      lineageArtifacts,
-      validationIssues: validationIssues.map(serializeValidationIssue),
-      approvals: approvals.map(serializeApproval),
-      latestCheckpoint: latestCheckpoint ? serializeCheckpoint(latestCheckpoint) : null,
-      recentEvents: recentEvents.map(serializeEvent),
-    }
-  }
-
-  private async collectLineageArtifacts(run: PlanRunRecord): Promise<SerializablePlanArtifact[]> {
-    const lineageArtifacts: SerializablePlanArtifact[] = []
-    let currentRunId = run.replacedRunId ? ensureRecordId(run.replacedRunId, TABLES.PLAN_RUN) : null
-    let depth = 0
-
-    while (currentRunId && depth < 5) {
-      const previousRun = await databaseService.findOne(TABLES.PLAN_RUN, { id: currentRunId }, PlanRunSchema)
-      if (!previousRun) break
-
-      const artifacts = await this.listArtifacts(previousRun.id)
-      lineageArtifacts.unshift(...artifacts.map(serializeArtifact))
-
-      currentRunId = previousRun.replacedRunId ? ensureRecordId(previousRun.replacedRunId, TABLES.PLAN_RUN) : null
-      depth += 1
-    }
-
-    return lineageArtifacts
-  }
-}
-
-export const planRunService = new PlanRunService()