@lota-sdk/core 0.1.9 → 0.1.11

package/src/services/learned-skill.service.ts

@@ -7,9 +7,9 @@ import { serverLogger } from '../config/logger'
 import { ensureRecordId } from '../db/record-id'
 import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { createDefaultEmbeddings } from '../embeddings/provider'
+import { getDefaultEmbeddings } from '../embeddings/provider'
 
-const embeddings = createDefaultEmbeddings()
+const embeddings = getDefaultEmbeddings()
 
 const PROMOTION_MIN_USES = 5
 const PROMOTION_MIN_SUCCESS_RATE = 0.6

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

@@ -0,0 +1,83 @@
+import { PlanApprovalSchema } from '@lota-sdk/shared/schemas/execution-plan'
+import type { PlanApprovalRecord, PlanApprovalStatus } from '@lota-sdk/shared/schemas/execution-plan'
+import { RecordId } from 'surrealdb'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import type { DatabaseTransaction } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class PlanApprovalService {
+  async createPendingApproval(params: {
+    tx: DatabaseTransaction
+    runId: RecordIdInput
+    nodeRunId: RecordIdInput
+    nodeId: string
+    requestedBy: string
+    presented: Record<string, unknown>
+  }): Promise<PlanApprovalRecord> {
+    const approvalId = new RecordId(TABLES.PLAN_APPROVAL, Bun.randomUUIDv7())
+    const created = await 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)
+  }
+
+  async getApprovalById(approvalId: RecordIdInput): Promise<PlanApprovalRecord | null> {
+    return await databaseService.findOne(
+      TABLES.PLAN_APPROVAL,
+      { id: ensureRecordId(approvalId, TABLES.PLAN_APPROVAL) },
+      PlanApprovalSchema,
+    )
+  }
+
+  async getPendingApprovalForNodeRun(nodeRunId: RecordIdInput): Promise<PlanApprovalRecord | null> {
+    const approvals = await databaseService.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
+  }
+
+  async updateApprovalResponse(params: {
+    tx: DatabaseTransaction
+    approval: PlanApprovalRecord
+    status: PlanApprovalStatus
+    response: Record<string, unknown>
+    respondedBy: string
+    approvalMessageId?: string
+    comments?: string
+    requiredEdits?: string[]
+  }): Promise<PlanApprovalRecord> {
+    const updated = await 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: new Date(),
+      })
+      .output('after')
+
+    return PlanApprovalSchema.parse(updated)
+  }
+}
+
+export const planApprovalService = new PlanApprovalService()

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

@@ -0,0 +1,45 @@
+import { PlanArtifactSchema } from '@lota-sdk/shared/schemas/execution-plan'
+import type { PlanArtifactRecord } from '@lota-sdk/shared/schemas/execution-plan'
+import type { PlanArtifactSubmission } from '@lota-sdk/shared/schemas/tools'
+import { RecordId } from 'surrealdb'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId } from '../db/record-id'
+import type { DatabaseTransaction } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class PlanArtifactService {
+  async persistArtifacts(params: {
+    tx: DatabaseTransaction
+    runId: RecordIdInput
+    attemptId: RecordIdInput
+    nodeId: string
+    artifacts: PlanArtifactSubmission[]
+  }): Promise<PlanArtifactRecord[]> {
+    const records: PlanArtifactRecord[] = []
+
+    for (const artifact of params.artifacts) {
+      const artifactId = new RecordId(TABLES.PLAN_ARTIFACT, Bun.randomUUIDv7())
+      const created = await params.tx
+        .create(artifactId)
+        .content({
+          runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+          attemptId: ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT),
+          nodeId: params.nodeId,
+          name: artifact.name,
+          kind: artifact.kind,
+          pointer: artifact.pointer,
+          ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
+          ...(artifact.description ? { description: artifact.description } : {}),
+          ...(artifact.payload ? { payload: artifact.payload } : {}),
+        })
+        .output('after')
+
+      records.push(PlanArtifactSchema.parse(created))
+    }
+
+    return records
+  }
+}
+
+export const planArtifactService = new PlanArtifactService()

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

@@ -0,0 +1,61 @@
+import type { PlanDraft } from '@lota-sdk/shared/schemas/execution-plan'
+
+function buildImplicitLinearEdges(draft: PlanDraft) {
+  if (draft.edges.length > 0 || draft.nodes.length <= 1) {
+    return draft.edges
+  }
+
+  return draft.nodes
+    .slice(0, -1)
+    .map((node, index) => ({
+      id: `edge_${node.id}_to_${draft.nodes[index + 1]?.id ?? index + 1}`,
+      source: node.id,
+      target: draft.nodes[index + 1].id,
+      map: {},
+    }))
+}
+
+class PlanBuilderService {
+  roleAssignment(draft: PlanDraft): PlanDraft {
+    return draft
+  }
+
+  structureDesign(draft: PlanDraft): PlanDraft {
+    return {
+      ...draft,
+      edges: buildImplicitLinearEdges(draft),
+      entryNodeIds: draft.entryNodeIds && draft.entryNodeIds.length > 0 ? draft.entryNodeIds : [draft.nodes[0].id],
+    }
+  }
+
+  semanticCompletion(draft: PlanDraft): PlanDraft {
+    return {
+      ...draft,
+      nodes: draft.nodes.map((node) => ({
+        ...node,
+        deliverables: [...node.deliverables],
+        successCriteria: [...node.successCriteria],
+        completionChecks: [...node.completionChecks],
+        failurePolicy: [...node.failurePolicy],
+        retryPolicy: { ...node.retryPolicy, retryOn: [...node.retryPolicy.retryOn] },
+        toolPolicy: { allow: [...node.toolPolicy.allow], deny: [...node.toolPolicy.deny] },
+        contextPolicy: {
+          retrievalScopes: [...node.contextPolicy.retrievalScopes],
+          attachmentPolicy: node.contextPolicy.attachmentPolicy,
+          webPolicy: node.contextPolicy.webPolicy,
+        },
+      })),
+      edges: draft.edges.map((edge) => ({ ...edge, map: { ...edge.map } })),
+      schemas: structuredClone(draft.schemas),
+      entryNodeIds: [...(draft.entryNodeIds ?? [])],
+    }
+  }
+
+  prepareDraft(draft: PlanDraft): PlanDraft {
+    const withRoles = this.roleAssignment(draft)
+    const withStructure = this.structureDesign(withRoles)
+    return this.semanticCompletion(withStructure)
+  }
+}
+
+export const planBuilderService = new PlanBuilderService()

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

@@ -0,0 +1,53 @@
+import { PlanCheckpointSchema } from '@lota-sdk/shared/schemas/execution-plan'
+import type { PlanCheckpointRecord, PlanRunStatus } from '@lota-sdk/shared/schemas/execution-plan'
+import { RecordId } from 'surrealdb'
+
+import type { RecordIdInput } from '../db/record-id'
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import type { DatabaseTransaction } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class PlanCheckpointService {
+  async createCheckpoint(params: {
+    tx: DatabaseTransaction
+    runId: RecordIdInput
+    sequence: number
+    runStatus: PlanRunStatus
+    readyNodeIds: string[]
+    activeNodeIds: string[]
+    artifactIds: RecordIdInput[]
+    lastCompletedNodeIds: string[]
+    snapshot: Record<string, unknown>
+  }): Promise<PlanCheckpointRecord> {
+    const checkpointId = new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7())
+    const created = await params.tx
+      .create(checkpointId)
+      .content({
+        runId: ensureRecordId(params.runId, TABLES.PLAN_RUN),
+        sequence: params.sequence,
+        runStatus: params.runStatus,
+        readyNodeIds: [...params.readyNodeIds],
+        activeNodeIds: [...params.activeNodeIds],
+        artifactIds: params.artifactIds.map((artifactId) => ensureRecordId(artifactId, TABLES.PLAN_ARTIFACT)),
+        lastCompletedNodeIds: [...params.lastCompletedNodeIds],
+        snapshot: params.snapshot,
+      })
+      .output('after')
+
+    return PlanCheckpointSchema.parse(created)
+  }
+
+  async loadLatestForRun(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
+  }
+}
+
+export const planCheckpointService = new PlanCheckpointService()

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

@@ -0,0 +1,81 @@
+import type { PlanDraft, PlanNodeSpec, PlanNodeSpecRecord } from '@lota-sdk/shared/schemas/execution-plan'
+
+import { planValidatorService } from './plan-validator.service'
+
+export interface CompiledPlanNode {
+  node: PlanNodeSpec
+  position: number
+  upstreamNodeIds: string[]
+  downstreamNodeIds: string[]
+}
+
+export interface CompiledPlanDraft {
+  draft: PlanDraft
+  nodes: CompiledPlanNode[]
+}
+
+class PlanCompilerService {
+  compile(draft: PlanDraft): CompiledPlanDraft {
+    const validation = planValidatorService.validateDraft(draft)
+    if (validation.blocking.length > 0) {
+      throw new Error(
+        `Plan draft failed validation: ${validation.blocking.map((issue) => `${issue.code}: ${issue.message}`).join(' | ')}`,
+      )
+    }
+
+    const upstreamByNodeId = new Map<string, string[]>()
+    const downstreamByNodeId = new Map<string, string[]>()
+
+    for (const node of draft.nodes) {
+      upstreamByNodeId.set(node.id, [])
+      downstreamByNodeId.set(node.id, [])
+    }
+
+    for (const edge of draft.edges) {
+      upstreamByNodeId.get(edge.target)?.push(edge.source)
+      downstreamByNodeId.get(edge.source)?.push(edge.target)
+    }
+
+    return {
+      draft,
+      nodes: draft.nodes.map((node, index) => ({
+        node,
+        position: index,
+        upstreamNodeIds: [...(upstreamByNodeId.get(node.id) ?? [])],
+        downstreamNodeIds: [...(downstreamByNodeId.get(node.id) ?? [])],
+      })),
+    }
+  }
+
+  toNodeSpecRecords(
+    compiled: CompiledPlanDraft,
+  ): Array<Omit<PlanNodeSpecRecord, 'id' | 'planSpecId' | 'createdAt' | 'updatedAt'>> {
+    return compiled.nodes.map(({ node, position, upstreamNodeIds, downstreamNodeIds }) => ({
+      nodeId: node.id,
+      position,
+      type: node.type,
+      label: node.label,
+      owner: node.owner,
+      objective: node.objective,
+      instructions: node.instructions,
+      ...(node.inputSchemaRef ? { inputSchemaRef: node.inputSchemaRef } : {}),
+      ...(node.outputSchemaRef ? { outputSchemaRef: node.outputSchemaRef } : {}),
+      deliverables: [...node.deliverables],
+      successCriteria: [...node.successCriteria],
+      completionChecks: [...node.completionChecks],
+      retryPolicy: { ...node.retryPolicy, retryOn: [...node.retryPolicy.retryOn] },
+      failurePolicy: [...node.failurePolicy],
+      ...(node.timeoutMs ? { timeoutMs: node.timeoutMs } : {}),
+      toolPolicy: { allow: [...node.toolPolicy.allow], deny: [...node.toolPolicy.deny] },
+      contextPolicy: {
+        retrievalScopes: [...node.contextPolicy.retrievalScopes],
+        attachmentPolicy: node.contextPolicy.attachmentPolicy,
+        webPolicy: node.contextPolicy.webPolicy,
+      },
+      upstreamNodeIds,
+      downstreamNodeIds,
+    }))
+  }
+}
+
+export const planCompilerService = new PlanCompilerService()