@toolproof-core/lib 1.0.48 → 1.0.49

package/src/utils/strategyCanonicalization.ts

@@ -31,8 +31,8 @@ import { generateIdentifier } from './identifierGeneration.js';
 
 function stripMutableCase(stepCase: MutableCase): Case {
     const { when, what, ...rest } = stepCase;
-    const { stepKey: _whenStepKey, toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
-    const { stepKey: _whatStepKey, toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
+    const { stepKey: _whenStepKey, ...canonicalWhen } = when;
+    const { stepKey: _whatStepKey, ...canonicalWhat } = what;
 
     return {
         ...rest,
@@ -47,18 +47,18 @@ function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKe
     const registerStep = (step: MutableStep, pathPrefix: string) => {
         switch (step.stepKind) {
             case CONSTANTS.Enums.StepKind.tool:
-                executionPathByKey.set(step.toolStepKey, `${pathPrefix}/self` as ToolStepPath);
+                executionPathByKey.set(step.stepKey, `${pathPrefix}/self` as ToolStepPath);
                 return;
             case CONSTANTS.Enums.StepKind.branch:
                 step.cases.forEach((stepCase, caseIndex) => {
-                    executionPathByKey.set(stepCase.when.toolStepKey, `${pathPrefix}/cases/${caseIndex}/when` as ToolStepPath);
-                    executionPathByKey.set(stepCase.what.toolStepKey, `${pathPrefix}/cases/${caseIndex}/what` as ToolStepPath);
+                    executionPathByKey.set(stepCase.when.stepKey, `${pathPrefix}/cases/${caseIndex}/when` as ToolStepPath);
+                    executionPathByKey.set(stepCase.what.stepKey, `${pathPrefix}/cases/${caseIndex}/what` as ToolStepPath);
                 });
                 return;
             case CONSTANTS.Enums.StepKind.while:
             case CONSTANTS.Enums.StepKind.for:
-                executionPathByKey.set(step.case.when.toolStepKey, `${pathPrefix}/case/when` as ToolStepPath);
-                executionPathByKey.set(step.case.what.toolStepKey, `${pathPrefix}/case/what` as ToolStepPath);
+                executionPathByKey.set(step.case.when.stepKey, `${pathPrefix}/case/when` as ToolStepPath);
+                executionPathByKey.set(step.case.what.stepKey, `${pathPrefix}/case/what` as ToolStepPath);
                 return;
             default:
                 throw new Error('Unsupported step kind while projecting strategy.');
@@ -82,9 +82,9 @@ function toCanonicalStrategyStateEntry(
         return entry as MaterializedResource | ExternalInputPotential;
     }
 
-    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.toolStepKey);
+    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
     if (!sourceToolStepPath) {
-        throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${entry.toolStepRoleAddress.toolStepKey}'.`);
+        throw new Error(`Cannot project strategy state: no execution path found for stepKey '${entry.toolStepRoleAddress.stepKey}'.`);
     }
 
     return {
@@ -99,7 +99,7 @@ function toCanonicalStrategyStateEntry(
 function toCanonicalStep(step: MutableStep): Step {
     switch (step.stepKind) {
         case CONSTANTS.Enums.StepKind.tool: {
-            const { stepKey: _stepKey, toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            const { stepKey: _stepKey, ...canonicalToolStep } = step;
             return canonicalToolStep;
         }
         case CONSTANTS.Enums.StepKind.branch: {
@@ -139,7 +139,6 @@ function toMutableStrategyStateEntry(
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             stepKey: sourceToolStepKey,
-            toolStepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     } satisfies MutableInternalInputPotential;
@@ -150,7 +149,6 @@ function toMutableToolStep(step: ToolStep): MutableToolStep {
     return {
         ...step,
         stepKey: key,
-        toolStepKey: key,
     };
 }
 
@@ -219,8 +217,8 @@ function buildExecutionKeyMap(strategy: MutableStrategy): Map<ToolStepPath, Muta
     const executionPathByKey = buildExecutionPathMap(strategy);
     const executionKeyByPath = new Map<ToolStepPath, MutableToolStepKey>();
 
-    for (const [toolStepKey, toolStepPath] of executionPathByKey.entries()) {
-        executionKeyByPath.set(toolStepPath, toolStepKey);
+    for (const [stepKey, toolStepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(toolStepPath, stepKey);
     }
 
     return executionKeyByPath;
@@ -271,21 +269,21 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
     const strategyState: Strategy['strategyState'] = {};
 
-    for (const [toolStepKey, inputEntryByRoleName] of Object.entries(mutableStrategy.strategyState)) {
+    for (const [stepKey, inputEntryByRoleName] of Object.entries(mutableStrategy.strategyState)) {
         if (!inputEntryByRoleName) {
             continue;
         }
 
-        const toolStepPath = executionPathByKey.get(toolStepKey as MutableToolStepKey);
+        const toolStepPath = executionPathByKey.get(stepKey as MutableToolStepKey);
         if (!toolStepPath) {
-            throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${toolStepKey}'.`);
+            throw new Error(`Cannot project strategy state: no execution path found for stepKey '${stepKey}'.`);
         }
 
         strategyState[toolStepPath] = Object.fromEntries(
             Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
-                        `Cannot project strategy state: role '${roleName}' on toolStepKey '${toolStepKey}' is explicitly undefined.`
+                        `Cannot project strategy state: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`
                     );
                 }
 
@@ -304,28 +302,28 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
     };
 }
 
-export function mutableToolStepKeyToToolStepPath(
+export function mutableStepKeyToToolStepPath(
     mutableStrategy: MutableStrategy,
-    toolStepKey: MutableToolStepKey,
+    stepKey: MutableToolStepKey,
 ): ToolStepPath {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(toolStepKey);
+    const toolStepPath = executionPathByKey.get(stepKey);
     if (!toolStepPath) {
-        throw new Error(`Cannot project toolStepPath: no execution path found for toolStepKey '${toolStepKey}'.`);
+        throw new Error(`Cannot project toolStepPath: no execution path found for stepKey '${stepKey}'.`);
     }
 
     return toolStepPath;
 }
 
-export function projectMutableStrategyStateEntriesByToolStepKeyToCanonicalDelta(
+export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
     mutableStrategy: MutableStrategy,
-    toolStepKey: MutableToolStepKey,
+    stepKey: MutableToolStepKey,
     entries: MutableStrategyStateEntryByRoleName,
 ): Strategy['strategyState'] {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(toolStepKey);
+    const toolStepPath = executionPathByKey.get(stepKey);
     if (!toolStepPath) {
-        throw new Error(`Cannot project strategy state delta: no execution path found for toolStepKey '${toolStepKey}'.`);
+        throw new Error(`Cannot project strategy state delta: no execution path found for stepKey '${stepKey}'.`);
     }
 
     const canonicalEntries: Strategy['strategyState'][ToolStepPath] = Object.fromEntries(
@@ -334,7 +332,7 @@ export function projectMutableStrategyStateEntriesByToolStepKeyToCanonicalDelta(
             .map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
-                        `Cannot project strategy state delta: role '${roleName}' on toolStepKey '${toolStepKey}' is explicitly undefined.`
+                        `Cannot project strategy state delta: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`
                     );
                 }
 

package/src/utils/strategyStateResolution.ts

@@ -28,7 +28,7 @@ export function resolveStrategyStateChain(
 	for (let depth = 0; depth <= maxDepth; depth++) {
 		path.push(current);
 
-		const visitKey = `${current.toolStepKey}::${current.roleName}`;
+		const visitKey = `${current.stepKey}::${current.roleName}`;
 		if (visited.has(visitKey)) {
 			return { status: 'unresolved', reason: 'cycle', path };
 		}