@toolproof-core/lib 1.0.31 → 1.0.32

package/src/utils/parallelizeSteps.ts

@@ -1,17 +1,17 @@
 import type {
-    BranchStepJson,
-    ForStepJson,
-    ToolStepIdJson,
-    ToolStepJson,
-    ResourceRoleIdJson,
-    StepJson,
-    StrategyStateJson,
-    WhileStepJson,
+    BranchStep,
+    ForStep,
+    ToolStepId,
+    ToolStep,
+    ResourceRoleId,
+    Step,
+    StrategyState,
+    WhileStep,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 
 
-export function getIndependentThreads(steps: StepJson[], strategyState: StrategyStateJson): StepJson[][] {
+export function getIndependentThreads(steps: Step[], strategyState: StrategyState): Step[][] {
     type OwnerIndex = number;
 
     const getOwnerLabel = (ownerIndex: OwnerIndex) => {
@@ -20,11 +20,11 @@ export function getIndependentThreads(steps: StepJson[], strategyState: Strategy
     };
 
     // Map each toolStep.id (including macro-nested tool steps) to owning top-level step index.
-    const toolStepIdToOwner = new Map<ToolStepIdJson, OwnerIndex>();
-    const ownerToToolStepIds = new Map<OwnerIndex, ToolStepIdJson[]>();
-    const toolStepById = new Map<ToolStepIdJson, ToolStepJson>();
+    const toolStepIdToOwner = new Map<ToolStepId, OwnerIndex>();
+    const ownerToToolStepIds = new Map<OwnerIndex, ToolStepId[]>();
+    const toolStepById = new Map<ToolStepId, ToolStep>();
 
-    const addToolStep = (toolStep: ToolStepJson | undefined, ownerIndex: OwnerIndex) => {
+    const addToolStep = (toolStep: ToolStep | undefined, ownerIndex: OwnerIndex) => {
         if (!toolStep?.id) return;
 
         const existingOwner = toolStepIdToOwner.get(toolStep.id);
@@ -43,26 +43,26 @@ export function getIndependentThreads(steps: StepJson[], strategyState: Strategy
 
     steps.forEach((step, ownerIndex) => {
         if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
-            addToolStep(step as ToolStepJson, ownerIndex);
+            addToolStep(step as ToolStep, ownerIndex);
             return;
         }
 
         if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-            const loop = step as ForStepJson;
+            const loop = step as ForStep;
             addToolStep(loop.case?.what, ownerIndex);
             addToolStep(loop.case?.when, ownerIndex);
             return;
         }
 
         if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
-            const loop = step as WhileStepJson;
+            const loop = step as WhileStep;
             addToolStep(loop.case?.what, ownerIndex);
             addToolStep(loop.case?.when, ownerIndex);
             return;
         }
 
         if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
-            const branch = step as BranchStepJson;
+            const branch = step as BranchStep;
             for (const caseItem of branch.cases ?? []) {
                 addToolStep(caseItem?.what, ownerIndex);
                 addToolStep(caseItem?.when, ownerIndex);
@@ -94,10 +94,10 @@ export function getIndependentThreads(steps: StepJson[], strategyState: Strategy
         const bucket = strategyState?.[toolStepId] ?? ({} as any);
 
         for (const inputRoleId of inputBindings) {
-            const entry = bucket?.[inputRoleId as ResourceRoleIdJson] as any;
+            const entry = bucket?.[inputRoleId as ResourceRoleId] as any;
             if (!entry || entry.resourceShellKind !== 'internalInputPotential') continue;
 
-            const creatorToolStepId = entry?.creationContext?.toolStepId as ToolStepIdJson | undefined;
+            const creatorToolStepId = entry?.creationContext?.toolStepId as ToolStepId | undefined;
             if (!creatorToolStepId) {
                 throw new Error(
                     `Unresolvable internalInputPotential in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): missing creationContext.toolStepId for role '${inputRoleId}'`

package/src/utils/resolveResourceChain.ts

@@ -1,29 +1,29 @@
 import type {
-    CreationContextJson,
-    ExternalInputPotentialShellJson,
-    InternalInputPotentialShellJson,
-    OutputPotentialShellJson,
-    ResourceJson,
-    ResourcePotentialJson,
-    StrategyStateJson,
+    CreationContext,
+    ExternalInputPotentialShell,
+    InternalInputPotentialShell,
+    OutputPotentialShell,
+    Resource,
+    ResourcePotential,
+    StrategyState,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 
 export type ResolveResult =
-    | { status: typeof CONSTANTS.Enums.ResourceShellKind.materialized; entry: ResourceJson; path: CreationContextJson[] }
-    | { status: typeof CONSTANTS.Enums.ResourceShellKind.externalInputPotential; entry: ExternalInputPotentialShellJson; path: CreationContextJson[] }
-    | { status: typeof CONSTANTS.Enums.ResourceShellKind.outputPotential; entry: OutputPotentialShellJson; path: CreationContextJson[] }
-    | { status: 'unresolved'; reason: 'not-found' | 'cycle' | 'depth-exceeded'; path: CreationContextJson[] };
+    | { status: typeof CONSTANTS.Enums.ResourceShellKind.materialized; entry: Resource; path: CreationContext[] }
+    | { status: typeof CONSTANTS.Enums.ResourceShellKind.externalInputPotential; entry: ExternalInputPotentialShell; path: CreationContext[] }
+    | { status: typeof CONSTANTS.Enums.ResourceShellKind.outputPotential; entry: OutputPotentialShell; path: CreationContext[] }
+    | { status: 'unresolved'; reason: 'not-found' | 'cycle' | 'depth-exceeded'; path: CreationContext[] };
 
 export function resolveResourceChain(
-    strategyState: StrategyStateJson,
-    start: CreationContextJson,
+    strategyState: StrategyState,
+    start: CreationContext,
     opts?: { maxDepth?: number }
 ): ResolveResult {
     const maxDepth = opts?.maxDepth ?? 50;
     const visited = new Set<string>();
-    const path: CreationContextJson[] = [];
-    let current: CreationContextJson = start;
+    const path: CreationContext[] = [];
+    let current: CreationContext = start;
 
     for (let depth = 0; depth <= maxDepth; depth++) {
         path.push(current);
@@ -36,25 +36,25 @@ export function resolveResourceChain(
         const bucket = strategyState[current.toolStepId];
         if (!bucket) return { status: 'unresolved', reason: 'not-found', path };
         const entry = bucket[current.resourceRoleId] as (
-            | ResourceJson
-            | ResourcePotentialJson
+            | Resource
+            | ResourcePotential
             | undefined
         );
         if (!entry) return { status: 'unresolved', reason: 'not-found', path };
 
         if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.materialized) {
-            return { status: CONSTANTS.Enums.ResourceShellKind.materialized, entry: entry as ResourceJson, path };
+            return { status: CONSTANTS.Enums.ResourceShellKind.materialized, entry: entry as Resource, path };
         }
         if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.externalInputPotential) {
-            return { status: CONSTANTS.Enums.ResourceShellKind.externalInputPotential, entry: entry as ExternalInputPotentialShellJson, path };
+            return { status: CONSTANTS.Enums.ResourceShellKind.externalInputPotential, entry: entry as ExternalInputPotentialShell, path };
         }
         if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.outputPotential) {
-            return { status: CONSTANTS.Enums.ResourceShellKind.outputPotential, entry: entry as OutputPotentialShellJson, path };
+            return { status: CONSTANTS.Enums.ResourceShellKind.outputPotential, entry: entry as OutputPotentialShell, path };
         }
 
         // internalInputPotential: follow ref backwards
         if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.internalInputPotential) {
-            current = (entry as InternalInputPotentialShellJson).creationContext;
+            current = (entry as InternalInputPotentialShell).creationContext;
             continue;
         }