@toolproof-core/lib 1.0.50 → 1.0.52

package/dist/lookups/lookups.d.ts

@@ -42,6 +42,8 @@ export declare const CONSTANTS: {
         readonly InternalInputPotential: "InternalInputPotential";
         readonly JsonScalarLink: "JsonScalarLink";
         readonly JsonSchemaObject: "JsonSchemaObject";
+        readonly MacroStepContext: "MacroStepContext";
+        readonly MacroStepSlot: "MacroStepSlot";
         readonly MaterializedResource: "MaterializedResource";
         readonly Name: "Name";
         readonly NameFacet: "NameFacet";
@@ -96,10 +98,6 @@ export declare const CONSTANTS: {
         readonly Tool: "Tool";
         readonly ToolHandle: "ToolHandle";
         readonly ToolStep: "ToolStep";
-        readonly ToolStepPath: "ToolStepPath";
-        readonly ToolStepPathSlot: "ToolStepPathSlot";
-        readonly ToolStepPathSlotFacet: "ToolStepPathSlotFacet";
-        readonly ToolStepPathSpec: "ToolStepPathSpec";
         readonly ToolStepRoleAddress: "ToolStepRoleAddress";
         readonly TracePoint: "TracePoint";
         readonly TracePointCounterSnapshot: "TracePointCounterSnapshot";

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -1,4 +1,4 @@
-import type { BranchStep, Case, ExternalInputPotential, ForStep, MaterializedResource, InternalInputPotential, Resource, RoleName, Strategy, Tool, ToolHandle, ToolStep, ToolStepRoleAddress, WhileStep } from '@toolproof-core/genesis';
+import type { BranchStep, Case, ExternalInputPotential, ForStep, MaterializedResource, InternalInputPotential, Resource, RoleName, Strategy, Tool, ToolHandle, ToolStep, ToolStepRoleAddress, WhileStep } from '@toolproof-core/genesis/types';
 export type MutableToolStepKey = `TOOL_STEP-${string}`;
 export type MutableBranchStepKey = `BRANCH_STEP-${string}`;
 export type MutableWhileStepKey = `WHILE_STEP-${string}`;
@@ -6,7 +6,7 @@ export type MutableForStepKey = `FOR_STEP-${string}`;
 export type MutableLoopStepKey = MutableWhileStepKey | MutableForStepKey;
 export type MutableStepKey = MutableToolStepKey | MutableBranchStepKey | MutableLoopStepKey;
 export type MutableMaterializedResource = MaterializedResource;
-export type MutableToolStepRoleAddress = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
+export type MutableToolStepRoleAddress = Omit<ToolStepRoleAddress, 'stepPath'> & {
     stepKey: MutableToolStepKey;
 };
 export type MutableInternalInputPotential = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {

package/dist/utils/strategyCanonicalization.d.ts

@@ -1,6 +1,6 @@
-import type { Strategy, ToolStepPath } from '@toolproof-core/genesis';
+import type { Strategy, StepPath } from '@toolproof-core/genesis/types';
 import type { MutableStrategy, MutableStrategyStateEntryByRoleName, MutableToolStepKey } from './mutableStrategyOverlay.js';
 export declare function strategyToMutableStrategy(strategy: Strategy): MutableStrategy;
 export declare function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Strategy;
-export declare function mutableStepKeyToToolStepPath(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey): ToolStepPath;
+export declare function mutableStepKeyToStepPath(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey): StepPath;
 export declare function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey, entries: MutableStrategyStateEntryByRoleName): Strategy['strategyState'];

package/dist/utils/strategyCanonicalization.js

@@ -15,7 +15,7 @@ function buildExecutionPathMap(strategy) {
     const registerStep = (step, pathPrefix) => {
         switch (step.stepKind) {
             case CONSTANTS.Enums.StepKind.tool:
-                executionPathByKey.set(step.stepKey, `${pathPrefix}/self`);
+                executionPathByKey.set(step.stepKey, pathPrefix);
                 return;
             case CONSTANTS.Enums.StepKind.branch:
                 step.cases.forEach((stepCase, caseIndex) => {
@@ -43,14 +43,14 @@ function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry;
     }
-    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
-    if (!sourceToolStepPath) {
+    const sourceStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
+    if (!sourceStepPath) {
         throw new Error(`Cannot project strategy state: no execution path found for stepKey '${entry.toolStepRoleAddress.stepKey}'.`);
     }
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
-            toolStepPath: sourceToolStepPath,
+            stepPath: sourceStepPath,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     };
@@ -84,9 +84,9 @@ function toMutableStrategyStateEntry(entry, executionKeyByPath) {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry;
     }
-    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.toolStepPath);
+    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.stepPath);
     if (!sourceToolStepKey) {
-        throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${entry.toolStepRoleAddress.toolStepPath}'.`);
+        throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${entry.toolStepRoleAddress.stepPath}'.`);
     }
     return {
         strategyStateEntryKind: 'internalInputPotential',
@@ -155,8 +155,8 @@ function toMutableStep(step) {
 function buildExecutionKeyMap(strategy) {
     const executionPathByKey = buildExecutionPathMap(strategy);
     const executionKeyByPath = new Map();
-    for (const [stepKey, toolStepPath] of executionPathByKey.entries()) {
-        executionKeyByPath.set(toolStepPath, stepKey);
+    for (const [stepKey, stepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(stepPath, stepKey);
     }
     return executionKeyByPath;
 }
@@ -169,14 +169,14 @@ export function strategyToMutableStrategy(strategy) {
     };
     const executionKeyByPath = buildExecutionKeyMap(seededMutableStrategy);
     const strategyState = {};
-    for (const [toolStepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
-        const stepKey = executionKeyByPath.get(toolStepPath);
+    for (const [stepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
+        const stepKey = executionKeyByPath.get(stepPath);
         if (!stepKey) {
-            throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${toolStepPath}'.`);
+            throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${stepPath}'.`);
         }
         strategyState[stepKey] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
             if (entry === undefined) {
-                throw new Error(`Cannot deproject strategy state: role '${roleName}' on toolStepPath '${toolStepPath}' is explicitly undefined.`);
+                throw new Error(`Cannot deproject strategy state: role '${roleName}' on stepPath '${stepPath}' is explicitly undefined.`);
             }
             return [
                 roleName,
@@ -197,11 +197,11 @@ export function mutableStrategyToStrategy(mutableStrategy) {
         if (!inputEntryByRoleName) {
             continue;
         }
-        const toolStepPath = executionPathByKey.get(stepKey);
-        if (!toolStepPath) {
+        const stepPath = executionPathByKey.get(stepKey);
+        if (!stepPath) {
             throw new Error(`Cannot project strategy state: no execution path found for stepKey '${stepKey}'.`);
         }
-        strategyState[toolStepPath] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
+        strategyState[stepPath] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
             if (entry === undefined) {
                 throw new Error(`Cannot project strategy state: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`);
             }
@@ -217,18 +217,18 @@ export function mutableStrategyToStrategy(mutableStrategy) {
         strategyState,
     };
 }
-export function mutableStepKeyToToolStepPath(mutableStrategy, stepKey) {
+export function mutableStepKeyToStepPath(mutableStrategy, stepKey) {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
-        throw new Error(`Cannot project toolStepPath: no execution path found for stepKey '${stepKey}'.`);
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
+        throw new Error(`Cannot project stepPath: no execution path found for stepKey '${stepKey}'.`);
     }
-    return toolStepPath;
+    return stepPath;
 }
 export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(mutableStrategy, stepKey, entries) {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
         throw new Error(`Cannot project strategy state delta: no execution path found for stepKey '${stepKey}'.`);
     }
     const canonicalEntries = Object.fromEntries(Object.entries(entries)
@@ -243,6 +243,6 @@ export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(muta
         ];
     }));
     return {
-        [toolStepPath]: canonicalEntries,
+        [stepPath]: canonicalEntries,
     };
 }

package/dist/utils/toolStepPaths.d.ts

@@ -1,2 +1,2 @@
-import type { ToolStepPath, ToolStepPathSpec } from '@toolproof-core/genesis';
-export declare function toToolStepPath(spec: ToolStepPathSpec): ToolStepPath;
+import type { StepPath, StepPathSpec } from '@toolproof-core/genesis/types';
+export declare function toStepPath(spec: StepPathSpec): StepPath;

package/dist/utils/toolStepPaths.js

@@ -1,21 +1,13 @@
-function getToolStepPathSuffix(spec) {
-    if (spec.toolStepPathSlot === 'self') {
-        return '/self';
-    }
-    if (spec.toolStepPathSlot === 'cases/when' || spec.toolStepPathSlot === 'cases/what') {
-        if (typeof spec.caseIndex !== 'number') {
-            throw new Error('Expected caseIndex for branch tool-step path construction');
+function getStepPathSuffix(spec) {
+    return spec.segments
+        .map((segment) => {
+        if (segment.segmentKind === 'case') {
+            return `/case/${segment.slot}`;
         }
-        return `/cases/${spec.caseIndex}/${spec.toolStepPathSlot === 'cases/when' ? 'when' : 'what'}`;
-    }
-    if (spec.toolStepPathSlot === 'case/when') {
-        return '/case/when';
-    }
-    if (spec.toolStepPathSlot === 'case/what') {
-        return '/case/what';
-    }
-    throw new Error(`Unsupported tool-step path slot '${String(spec.toolStepPathSlot)}'`);
+        return `/cases/${segment.caseIndex}/${segment.slot}`;
+    })
+        .join('');
 }
-export function toToolStepPath(spec) {
-    return `/threads/${spec.threadIndex}/steps/${spec.stepIndex}${getToolStepPathSuffix(spec)}`;
+export function toStepPath(spec) {
+    return `/threads/${spec.threadIndex}/steps/${spec.stepIndex}${getStepPathSuffix(spec)}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.50",
+  "version": "1.0.52",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -80,7 +80,7 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/genesis": "^1.0.65",
+    "@toolproof-core/genesis": "^1.0.66",
     "firebase-admin": "^13.7.0"
   },
   "scripts": {

package/src/utils/mutableStrategyOverlay.ts

@@ -13,7 +13,7 @@ import type {
     ToolStep,
     ToolStepRoleAddress,
     WhileStep,
-} from '@toolproof-core/genesis';
+} from '@toolproof-core/genesis/types';
 import { extractResourceTypeHandleFromRoleValue } from './strategyExtraction.js';
 
 export type MutableToolStepKey = `TOOL_STEP-${string}`;
@@ -26,7 +26,7 @@ export type MutableStepKey = MutableToolStepKey | MutableBranchStepKey | Mutable
 export type MutableMaterializedResource = MaterializedResource;
 
 export type MutableToolStepRoleAddress =
-    Omit<ToolStepRoleAddress, 'toolStepPath'> & {
+    Omit<ToolStepRoleAddress, 'stepPath'> & {
         stepKey: MutableToolStepKey;
     };
 

package/src/utils/strategyCanonicalization.ts

@@ -10,9 +10,9 @@ import type {
     Strategy,
     StrategyStateEntry,
     ToolStep,
-    ToolStepPath,
+    StepPath,
     WhileStep,
-} from '@toolproof-core/genesis';
+} from '@toolproof-core/genesis/types';
 import { CONSTANTS } from '../lookups/lookups.js';
 import type {
     MutableBranchStep,
@@ -41,24 +41,24 @@ function stripMutableCase(stepCase: MutableCase): Case {
     };
 }
 
-function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKey, ToolStepPath> {
-    const executionPathByKey = new Map<MutableToolStepKey, ToolStepPath>();
+function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKey, StepPath> {
+    const executionPathByKey = new Map<MutableToolStepKey, StepPath>();
 
     const registerStep = (step: MutableStep, pathPrefix: string) => {
         switch (step.stepKind) {
             case CONSTANTS.Enums.StepKind.tool:
-                executionPathByKey.set(step.stepKey, `${pathPrefix}/self` as ToolStepPath);
+                executionPathByKey.set(step.stepKey, pathPrefix as StepPath);
                 return;
             case CONSTANTS.Enums.StepKind.branch:
                 step.cases.forEach((stepCase, caseIndex) => {
-                    executionPathByKey.set(stepCase.when.stepKey, `${pathPrefix}/cases/${caseIndex}/when` as ToolStepPath);
-                    executionPathByKey.set(stepCase.what.stepKey, `${pathPrefix}/cases/${caseIndex}/what` as ToolStepPath);
+                    executionPathByKey.set(stepCase.when.stepKey, `${pathPrefix}/cases/${caseIndex}/when` as StepPath);
+                    executionPathByKey.set(stepCase.what.stepKey, `${pathPrefix}/cases/${caseIndex}/what` as StepPath);
                 });
                 return;
             case CONSTANTS.Enums.StepKind.while:
             case CONSTANTS.Enums.StepKind.for:
-                executionPathByKey.set(step.case.when.stepKey, `${pathPrefix}/case/when` as ToolStepPath);
-                executionPathByKey.set(step.case.what.stepKey, `${pathPrefix}/case/what` as ToolStepPath);
+                executionPathByKey.set(step.case.when.stepKey, `${pathPrefix}/case/when` as StepPath);
+                executionPathByKey.set(step.case.what.stepKey, `${pathPrefix}/case/what` as StepPath);
                 return;
             default:
                 throw new Error('Unsupported step kind while projecting strategy.');
@@ -76,21 +76,21 @@ function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKe
 
 function toCanonicalStrategyStateEntry(
     entry: MutableStrategyStateEntry,
-    executionPathByKey: ReadonlyMap<MutableToolStepKey, ToolStepPath>,
+    executionPathByKey: ReadonlyMap<MutableToolStepKey, StepPath>,
 ): StrategyStateEntry {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry as MaterializedResource | ExternalInputPotential;
     }
 
-    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
-    if (!sourceToolStepPath) {
+    const sourceStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
+    if (!sourceStepPath) {
         throw new Error(`Cannot project strategy state: no execution path found for stepKey '${entry.toolStepRoleAddress.stepKey}'.`);
     }
 
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
-            toolStepPath: sourceToolStepPath,
+            stepPath: sourceStepPath,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     } satisfies InternalInputPotential;
@@ -124,15 +124,15 @@ function toCanonicalStep(step: MutableStep): Step {
 
 function toMutableStrategyStateEntry(
     entry: StrategyStateEntry,
-    executionKeyByPath: ReadonlyMap<ToolStepPath, MutableToolStepKey>,
+    executionKeyByPath: ReadonlyMap<StepPath, MutableToolStepKey>,
 ): MutableStrategyStateEntry {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry as MaterializedResource | ExternalInputPotential;
     }
 
-    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.toolStepPath);
+    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.stepPath);
     if (!sourceToolStepKey) {
-        throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${entry.toolStepRoleAddress.toolStepPath}'.`);
+        throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${entry.toolStepRoleAddress.stepPath}'.`);
     }
 
     return {
@@ -210,12 +210,12 @@ function toMutableStep(step: Step): MutableStep {
     }
 }
 
-function buildExecutionKeyMap(strategy: MutableStrategy): Map<ToolStepPath, MutableToolStepKey> {
+function buildExecutionKeyMap(strategy: MutableStrategy): Map<StepPath, MutableToolStepKey> {
     const executionPathByKey = buildExecutionPathMap(strategy);
-    const executionKeyByPath = new Map<ToolStepPath, MutableToolStepKey>();
+    const executionKeyByPath = new Map<StepPath, MutableToolStepKey>();
 
-    for (const [stepKey, toolStepPath] of executionPathByKey.entries()) {
-        executionKeyByPath.set(toolStepPath, stepKey);
+    for (const [stepKey, stepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(stepPath, stepKey);
     }
 
     return executionKeyByPath;
@@ -233,17 +233,17 @@ export function strategyToMutableStrategy(strategy: Strategy): MutableStrategy {
     const executionKeyByPath = buildExecutionKeyMap(seededMutableStrategy);
     const strategyState: MutableStrategy['strategyState'] = {};
 
-    for (const [toolStepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
-        const stepKey = executionKeyByPath.get(toolStepPath as ToolStepPath);
+    for (const [stepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
+        const stepKey = executionKeyByPath.get(stepPath as StepPath);
         if (!stepKey) {
-            throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${toolStepPath}'.`);
+            throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${stepPath}'.`);
         }
 
         strategyState[stepKey] = Object.fromEntries(
             Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
-                        `Cannot deproject strategy state: role '${roleName}' on toolStepPath '${toolStepPath}' is explicitly undefined.`
+                        `Cannot deproject strategy state: role '${roleName}' on stepPath '${stepPath}' is explicitly undefined.`
                     );
                 }
 
@@ -271,12 +271,12 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
             continue;
         }
 
-        const toolStepPath = executionPathByKey.get(stepKey as MutableToolStepKey);
-        if (!toolStepPath) {
+        const stepPath = executionPathByKey.get(stepKey as MutableToolStepKey);
+        if (!stepPath) {
             throw new Error(`Cannot project strategy state: no execution path found for stepKey '${stepKey}'.`);
         }
 
-        strategyState[toolStepPath] = Object.fromEntries(
+        strategyState[stepPath] = Object.fromEntries(
             Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
@@ -299,17 +299,17 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
     };
 }
 
-export function mutableStepKeyToToolStepPath(
+export function mutableStepKeyToStepPath(
     mutableStrategy: MutableStrategy,
     stepKey: MutableToolStepKey,
-): ToolStepPath {
+): StepPath {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
-        throw new Error(`Cannot project toolStepPath: no execution path found for stepKey '${stepKey}'.`);
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
+        throw new Error(`Cannot project stepPath: no execution path found for stepKey '${stepKey}'.`);
     }
 
-    return toolStepPath;
+    return stepPath;
 }
 
 export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
@@ -318,12 +318,12 @@ export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
     entries: MutableStrategyStateEntryByRoleName,
 ): Strategy['strategyState'] {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
         throw new Error(`Cannot project strategy state delta: no execution path found for stepKey '${stepKey}'.`);
     }
 
-    const canonicalEntries: Strategy['strategyState'][ToolStepPath] = Object.fromEntries(
+    const canonicalEntries: Strategy['strategyState'][StepPath] = Object.fromEntries(
         Object.entries(entries)
             .filter(([, entry]) => entry !== undefined)
             .map(([roleName, entry]) => {
@@ -341,6 +341,6 @@ export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
     );
 
     return {
-        [toolStepPath]: canonicalEntries,
+        [stepPath]: canonicalEntries,
     };
 }

package/src/utils/toolStepPaths.ts

@@ -1,34 +1,20 @@
 import type {
-    ToolStepPath,
-    ToolStepPathSpec,
-} from '@toolproof-core/genesis';
+    StepPath,
+    StepPathSpec,
+} from '@toolproof-core/genesis/types';
 
-function getToolStepPathSuffix(spec: Pick<ToolStepPathSpec, 'toolStepPathSlot' | 'caseIndex'>): string {
-    if (spec.toolStepPathSlot === 'self') {
-        return '/self';
-    }
+function getStepPathSuffix(spec: StepPathSpec): string {
+    return spec.segments
+        .map((segment) => {
+            if (segment.segmentKind === 'case') {
+                return `/case/${segment.slot}`;
+            }
 
-    if (spec.toolStepPathSlot === 'cases/when' || spec.toolStepPathSlot === 'cases/what') {
-        if (typeof spec.caseIndex !== 'number') {
-            throw new Error('Expected caseIndex for branch tool-step path construction');
-        }
-
-        return `/cases/${spec.caseIndex}/${spec.toolStepPathSlot === 'cases/when' ? 'when' : 'what'}`;
-    }
-
-    if (spec.toolStepPathSlot === 'case/when') {
-        return '/case/when';
-    }
-
-    if (spec.toolStepPathSlot === 'case/what') {
-        return '/case/what';
-    }
-
-    throw new Error(
-        `Unsupported tool-step path slot '${String(spec.toolStepPathSlot)}'`,
-    );
+            return `/cases/${segment.caseIndex}/${segment.slot}`;
+        })
+        .join('');
 }
 
-export function toToolStepPath(spec: ToolStepPathSpec): ToolStepPath {
-    return `/threads/${spec.threadIndex}/steps/${spec.stepIndex}${getToolStepPathSuffix(spec)}` as ToolStepPath;
+export function toStepPath(spec: StepPathSpec): StepPath {
+    return `/threads/${spec.threadIndex}/steps/${spec.stepIndex}${getStepPathSuffix(spec)}` as StepPath;
 }