@toolproof-core/lib 1.0.47 → 1.0.49

package/src/utils/strategyCanonicalization.ts

@@ -23,6 +23,7 @@ import type {
     MutableStep,
     MutableStrategyStateEntryByRoleName,
     MutableStrategyStateEntry,
+    MutableToolStep,
     MutableToolStepKey,
     MutableWhileStep,
 } from './mutableStrategyOverlay.js';
@@ -30,8 +31,8 @@ import { generateIdentifier } from './identifierGeneration.js';
 
 function stripMutableCase(stepCase: MutableCase): Case {
     const { when, what, ...rest } = stepCase;
-    const { toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
-    const { toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
+    const { stepKey: _whenStepKey, ...canonicalWhen } = when;
+    const { stepKey: _whatStepKey, ...canonicalWhat } = what;
 
     return {
         ...rest,
@@ -46,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.');
@@ -81,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 {
@@ -98,11 +99,11 @@ function toCanonicalStrategyStateEntry(
 function toCanonicalStep(step: MutableStep): Step {
     switch (step.stepKind) {
         case CONSTANTS.Enums.StepKind.tool: {
-            const { toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            const { stepKey: _stepKey, ...canonicalToolStep } = step;
             return canonicalToolStep;
         }
         case CONSTANTS.Enums.StepKind.branch: {
-            const { macroStepKey: _macroStepKey, cases, ...rest } = step;
+            const { stepKey: _stepKey, macroStepKey: _macroStepKey, cases, ...rest } = step;
             return {
                 ...rest,
                 cases: cases.map(stripMutableCase) as [Case, ...Case[]],
@@ -110,7 +111,7 @@ function toCanonicalStep(step: MutableStep): Step {
         }
         case CONSTANTS.Enums.StepKind.while:
         case CONSTANTS.Enums.StepKind.for: {
-            const { macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
+            const { stepKey: _stepKey, macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
             return {
                 ...rest,
                 case: stripMutableCase(stepCase),
@@ -137,16 +138,17 @@ function toMutableStrategyStateEntry(
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
-            toolStepKey: sourceToolStepKey,
+            stepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     } satisfies MutableInternalInputPotential;
 }
 
-function toMutableToolStep(step: ToolStep) {
+function toMutableToolStep(step: ToolStep): MutableToolStep {
+    const key = generateIdentifier('ToolStepKey');
     return {
         ...step,
-        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKey: key,
     };
 }
 
@@ -163,9 +165,11 @@ function toMutableCase(stepCase: Case): MutableCase {
 function toMutableBranchStep(step: BranchStep): MutableBranchStep {
     const { cases, ...rest } = step;
 
+    const key = generateIdentifier('BranchStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('BranchStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         cases: cases.map(toMutableCase) as [MutableCase, ...MutableCase[]],
     };
 }
@@ -173,9 +177,11 @@ function toMutableBranchStep(step: BranchStep): MutableBranchStep {
 function toMutableWhileStep(step: WhileStep): MutableWhileStep {
     const { case: stepCase, ...rest } = step;
 
+    const key = generateIdentifier('WhileStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('WhileStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -183,9 +189,11 @@ function toMutableWhileStep(step: WhileStep): MutableWhileStep {
 function toMutableForStep(step: ForStep): MutableForStep {
     const { case: stepCase, ...rest } = step;
 
+    const key = generateIdentifier('ForStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('ForStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -209,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;
@@ -261,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);
+        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.`
                     );
                 }
 
@@ -294,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(
@@ -324,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

@@ -1,43 +1,40 @@
 import type {
 	MutableMaterializedResource,
 	MutableExternalInputPotential,
-	MutableInternalInputPotential,
 	MutableStrategyState,
-	MutableStrategyStateEntry,
-	MutableToolStepKey,
 	MutableToolStepRoleAddress,
 } from './mutableStrategyOverlay.js';
 import { getStrategyStateEntry } from './mutableStrategyOverlay.js';
 
-export type ResolveResult<TKey extends string = MutableToolStepKey> =
-	| { status: 'materializedResource'; entry: MutableMaterializedResource; path: MutableToolStepRoleAddress<TKey>[] }
-	| { status: 'externalInputPotential'; entry: MutableExternalInputPotential; path: MutableToolStepRoleAddress<TKey>[] }
+export type ResolveResult =
+	| { status: 'materializedResource'; entry: MutableMaterializedResource; path: MutableToolStepRoleAddress[] }
+	| { status: 'externalInputPotential'; entry: MutableExternalInputPotential; path: MutableToolStepRoleAddress[] }
 	| {
 		status: 'unresolved';
 		reason: 'not-found' | 'cycle' | 'depth-exceeded';
-		path: MutableToolStepRoleAddress<TKey>[];
+		path: MutableToolStepRoleAddress[];
 	};
 
-export function resolveStrategyStateChain<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-	strategyState: TStrategyState,
-	start: MutableToolStepRoleAddress<TKey>,
+export function resolveStrategyStateChain(
+	strategyState: MutableStrategyState,
+	start: MutableToolStepRoleAddress,
 	opts?: { maxDepth?: number },
-): ResolveResult<TKey> {
+): ResolveResult {
 	const maxDepth = opts?.maxDepth ?? 50;
 	const visited = new Set<string>();
-	const path: MutableToolStepRoleAddress<TKey>[] = [];
-	let current: MutableToolStepRoleAddress<TKey> = start;
+	const path: MutableToolStepRoleAddress[] = [];
+	let current: MutableToolStepRoleAddress = start;
 
 	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 };
 		}
 		visited.add(visitKey);
 
-		const entry = getStrategyStateEntry(strategyState, current) as MutableStrategyStateEntry<TKey> | undefined;
+		const entry = getStrategyStateEntry(strategyState, current);
 		if (!entry) {
 			return { status: 'unresolved', reason: 'not-found', path };
 		}
@@ -50,7 +47,7 @@ export function resolveStrategyStateChain<TKey extends string, TStrategyState ex
 			return { status: 'externalInputPotential', entry, path };
 		}
 
-		current = (entry as MutableInternalInputPotential<TKey>).toolStepRoleAddress;
+		current = entry.toolStepRoleAddress;
 	}
 
 	return { status: 'unresolved', reason: 'depth-exceeded', path };

package/src/utils/strategyThreading.ts

@@ -1,19 +1,12 @@
 import { getIndependentThreads } from './stepParallelization.js';
 import type {
     MutableStrategy,
-    MutableStep,
-    MutableStrategyState,
-    MutableToolStepKey,
 } from './mutableStrategyOverlay.js';
 import { getAuthoringSteps as getAuthoringThreadSteps } from './mutableStrategyOverlay.js';
 
-export function toExecutionMutableStrategy<
-    TKey extends string = MutableToolStepKey,
-    TStep extends MutableStep<TKey> = MutableStep<TKey>,
-    TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>,
->(
-    mutableStrategy: MutableStrategy<TKey, TStep, TState>,
-): MutableStrategy<TKey, TStep, TState> {
+export function toExecutionMutableStrategy(
+    mutableStrategy: MutableStrategy,
+): MutableStrategy {
     const authoringSteps = getAuthoringThreadSteps(mutableStrategy);
     const stepsByThreadIndex = getIndependentThreads(
         authoringSteps,