@toolproof-core/lib 1.0.32 → 1.0.33

package/src/utils/resolveResourceChain.ts

@@ -1,18 +1,15 @@
 import type {
     CreationContext,
-    ExternalInputPotentialShell,
-    InternalInputPotentialShell,
-    OutputPotentialShell,
-    Resource,
-    ResourcePotential,
-    StrategyState,
+    ExternalInput,
+    ReferenceInput,
+    StrategyStateInputEntry,
+    ValueInput,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
+import { getStrategyStateEntry, type StrategyState } from './strategyState.js';
 
 export type ResolveResult =
-    | { 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: 'valueInput'; entry: ValueInput; path: CreationContext[] }
+    | { status: 'externalInput'; entry: ExternalInput; path: CreationContext[] }
     | { status: 'unresolved'; reason: 'not-found' | 'cycle' | 'depth-exceeded'; path: CreationContext[] };
 
 export function resolveResourceChain(
@@ -27,39 +24,28 @@ export function resolveResourceChain(
 
     for (let depth = 0; depth <= maxDepth; depth++) {
         path.push(current);
-        const visitKey = `${current.toolStepId}::${current.resourceRoleId}`;
+        const visitKey = `${current.toolStepPath}::${current.roleName}`;
         if (visited.has(visitKey)) {
             return { status: 'unresolved', reason: 'cycle', path };
         }
         visited.add(visitKey);
 
-        const bucket = strategyState[current.toolStepId];
-        if (!bucket) return { status: 'unresolved', reason: 'not-found', path };
-        const entry = bucket[current.resourceRoleId] as (
-            | Resource
-            | ResourcePotential
-            | undefined
-        );
+        const entry = getStrategyStateEntry(strategyState, current) as StrategyStateInputEntry | 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 Resource, path };
+        if (entry.strategyStateInputKind === 'valueInput') {
+            return { status: 'valueInput', entry: entry, path };
         }
-        if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.externalInputPotential) {
-            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 OutputPotentialShell, path };
+        if (entry.strategyStateInputKind === 'externalInput') {
+            return { status: 'externalInput', entry: entry, path };
         }
 
-        // internalInputPotential: follow ref backwards
-        if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.internalInputPotential) {
-            current = (entry as InternalInputPotentialShell).creationContext;
-            continue;
-        }
+        current = {
+            toolStepPath: (entry as ReferenceInput).toolStepPath,
+            roleName: (entry as ReferenceInput).roleName,
+        };
+        continue;
 
-        // Unknown case
-        return { status: 'unresolved', reason: 'not-found', path };
     }
 
     return { status: 'unresolved', reason: 'depth-exceeded', path };

package/src/utils/roleSpec.ts

@@ -0,0 +1,80 @@
+import type {
+    RoleName,
+    RoleValue,
+    Strategy,
+    Step,
+    Tool,
+    ToolStep,
+} from '@toolproof-core/schema';
+
+export interface ToolRoleDescriptor extends RoleValue {
+    id: RoleName;
+    name: string;
+}
+
+export function getInputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]> {
+    return Object.entries(tool.roleSpec.inputRoleValueByName) as Array<[RoleName, RoleValue]>;
+}
+
+export function getOutputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]> {
+    return Object.entries(tool.roleSpec.outputRoleValueByName) as Array<[RoleName, RoleValue]>;
+}
+
+export function getInputRoleNames(tool: Tool): RoleName[] {
+    return getInputRoleEntries(tool).map(([roleName]) => roleName);
+}
+
+export function getOutputRoleNames(tool: Tool): RoleName[] {
+    return getOutputRoleEntries(tool).map(([roleName]) => roleName);
+}
+
+export function toToolRoleDescriptor([roleName, roleValue]: [RoleName, RoleValue]): ToolRoleDescriptor {
+    return {
+        id: roleName,
+        name: roleName,
+        ...roleValue,
+    };
+}
+
+export function extractToolStepsFromStrategy(strategy: Strategy): ToolStep[] {
+    const toolSteps: ToolStep[] = [];
+
+    const visitStep = (step: Step) => {
+        switch (step.stepKind) {
+            case 'tool': {
+                toolSteps.push(step);
+                return;
+            }
+            case 'branch': {
+                for (const conditional of step.cases) {
+                    toolSteps.push(conditional.when, conditional.what);
+                }
+                return;
+            }
+            case 'while':
+            case 'for': {
+                toolSteps.push(step.case.when, step.case.what);
+                return;
+            }
+            default: {
+                const _exhaustive: never = step;
+                return _exhaustive;
+            }
+        }
+    };
+
+    if ('steps' in strategy) {
+        for (const step of strategy.steps) {
+            visitStep(step);
+        }
+        return toolSteps;
+    }
+
+    for (const threadSteps of strategy.stepsByThreadIndex) {
+        for (const step of threadSteps) {
+            visitStep(step);
+        }
+    }
+
+    return toolSteps;
+}

package/src/utils/strategyState.ts

@@ -0,0 +1,56 @@
+import type {
+    CreationContext,
+    Strategy,
+    StrategyStateInputEntry,
+    StrategyStateInputEntryByRoleName,
+} from '@toolproof-core/schema';
+
+export type StrategyState = Strategy['strategyState'];
+
+export function getStrategyStateBucket(
+    strategyState: StrategyState,
+    toolStepPath: CreationContext['toolStepPath'],
+): StrategyStateInputEntryByRoleName | undefined {
+    return strategyState[toolStepPath];
+}
+
+export function getStrategyStateEntry(
+    strategyState: StrategyState,
+    context: CreationContext,
+): StrategyStateInputEntry | undefined {
+    return getStrategyStateBucket(strategyState, context.toolStepPath)?.[context.roleName];
+}
+
+export function setStrategyStateEntry(
+    strategyState: StrategyState,
+    context: CreationContext,
+    entry: StrategyStateInputEntry,
+): StrategyState {
+    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath) ?? {};
+
+    return {
+        ...strategyState,
+        [context.toolStepPath]: {
+            ...bucket,
+            [context.roleName]: entry,
+        },
+    };
+}
+
+export function clearStrategyStateEntry(
+    strategyState: StrategyState,
+    context: CreationContext,
+): StrategyState {
+    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath);
+    if (!bucket || !(context.roleName in bucket)) {
+        return strategyState;
+    }
+
+    const nextBucket = { ...bucket };
+    delete nextBucket[context.roleName];
+
+    return {
+        ...strategyState,
+        [context.toolStepPath]: nextBucket,
+    };
+}