@toolproof-core/lib 1.0.32 → 1.0.33

package/src/types/types.ts

@@ -18,7 +18,7 @@ export type IdName = keyof typeof MAPPINGS.IdNameToIdPrefix;
 
 export type IdStringByIdName<K extends IdName> = `${(typeof MAPPINGS.IdNameToIdPrefix)[K]}${string}`;
 
-export type StepIdStringByStepKind<K extends StepKind> = `${(typeof MAPPINGS.StepKindToStepIdPrefix)[K]}${string}`;
+export type StepIdStringByStepKind<K extends StepKind> = string & { readonly __stepKind?: K };
 
 export interface NucleusBaseSmall<T extends string = string> {
     id: T;

package/src/utils/bindInputRoleToResource.ts

@@ -1,14 +1,15 @@
 import type {
     CreationContext,
-    ExternalInputPotentialShell,
-    InternalInputPotentialShell,
-    OutputPotentialShell,
     Resource,
-    ResourcePotential,
-    StrategyState,
+    ReferenceInput,
+    ValueInput,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { resolveResourceChain } from './resolveResourceChain.js';
+import {
+    clearStrategyStateEntry,
+    getStrategyStateEntry,
+    setStrategyStateEntry,
+    type StrategyState,
+} from './strategyState.js';
 
 
 export function bindInputResInStrategyState(
@@ -16,14 +17,13 @@ export function bindInputResInStrategyState(
     target: CreationContext,
     resource: Resource
 ): StrategyState {
-    const bucket = strategyState[target.toolStepId] ?? {};
-    return {
-        ...strategyState,
-        [target.toolStepId]: {
-            ...bucket,
-            [target.resourceRoleId]: resource,
-        },
+    const entry: ValueInput = {
+        strategyStateInputKind: 'valueInput',
+        resourceTypeId: resource.resourceTypeId,
+        nucleus: resource.nucleus,
     };
+
+    return setStrategyStateEntry(strategyState, target, entry);
 }
 
 export function bindInputRefInStrategyState(
@@ -31,80 +31,23 @@ export function bindInputRefInStrategyState(
     target: CreationContext,
     source: CreationContext
 ): StrategyState {
-    const sourceEntry = strategyState?.[source.toolStepId]?.[source.resourceRoleId] as (
-        | Resource
-        | ResourcePotential
-        | undefined
-    );
+    const sourceEntry = getStrategyStateEntry(strategyState, source);
     if (!sourceEntry) {
-        throw new Error(`resourceEntry not found for source (${source.toolStepId}, ${source.resourceRoleId})`);
-    }
-
-    const result = resolveResourceChain(strategyState, source);
-    const bucket = strategyState[target.toolStepId] ?? {};
-
-    if (result.status === CONSTANTS.Enums.ResourceShellKind.materialized) {
-        return {
-            ...strategyState,
-            [target.toolStepId]: {
-                ...bucket,
-                [target.resourceRoleId]: result.entry,
-            },
-        };
-    }
-
-    if (result.status === CONSTANTS.Enums.ResourceShellKind.externalInputPotential) {
-        const externalInput = result.entry;
-        const reusedExternalInput: ExternalInputPotentialShell = {
-            id: externalInput.id,
-            resourceTypeId: externalInput.resourceTypeId,
-            resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
-        };
-
-        return {
-            ...strategyState,
-            [target.toolStepId]: {
-                ...bucket,
-                [target.resourceRoleId]: reusedExternalInput,
-            },
-        };
+        throw new Error(`resourceEntry not found for source (${source.toolStepPath}, ${source.roleName})`);
     }
 
-    if (result.status === CONSTANTS.Enums.ResourceShellKind.outputPotential) {
-        const potentialInput: InternalInputPotentialShell = {
-            id: sourceEntry.id,
-            resourceTypeId: sourceEntry.resourceTypeId,
-            creationContext: {
-                toolStepId: source.toolStepId,
-                resourceRoleId: source.resourceRoleId,
-            },
-            resourceShellKind: CONSTANTS.Enums.ResourceShellKind.internalInputPotential,
-        };
-
-        return {
-            ...strategyState,
-            [target.toolStepId]: {
-                ...bucket,
-                [target.resourceRoleId]: potentialInput,
-            },
-        };
-    }
+    const entry: ReferenceInput = {
+        strategyStateInputKind: 'referenceInput',
+        toolStepPath: source.toolStepPath,
+        roleName: source.roleName,
+    };
 
-    throw new Error(`Failed to resolve resource chain: ${result.reason}`);
+    return setStrategyStateEntry(strategyState, target, entry);
 }
 
 export function clearInputBindingInStrategyState(
     strategyState: StrategyState,
     target: CreationContext
 ): StrategyState {
-    const bucket = strategyState?.[target.toolStepId];
-    if (!bucket?.[target.resourceRoleId]) return strategyState;
-
-    const nextBucket = { ...bucket } as Record<string, unknown>;
-    delete nextBucket[target.resourceRoleId];
-
-    return {
-        ...strategyState,
-        [target.toolStepId]: nextBucket as any,
-    };
+    return clearStrategyStateEntry(strategyState, target);
 }

package/src/utils/creation/resourceCreation.ts

@@ -1,20 +1,33 @@
 import type {
     CreationContext,
-    ExternalInputPotentialShell,
-    InternalInputPotentialShell,
-    OutputPotentialShell,
+    ExternalInput,
+    ReferenceInput,
     ResourceId,
     Resource,
     ResourceTypeId,
+    StrategyRunId,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
+
+export interface OutputPotential {
+    id: ResourceId;
+    resourceTypeId: ResourceTypeId;
+    creationContext: CreationContext;
+    strategyRunId?: StrategyRunId;
+}
+
+export type InputPotential = ReferenceInput & {
+    id: ResourceId;
+    resourceTypeId: ResourceTypeId;
+    creationContext: CreationContext;
+    strategyRunId?: StrategyRunId;
+};
 
 export function generatePath(resourceTypeId: ResourceTypeId, id: ResourceId): string {
     return `${resourceTypeId}/${id}.json`;
 }
 
 export function createMaterializedFromOutputPotential(
-    outputPotential: OutputPotentialShell,
+    outputPotential: OutputPotential,
     nucleus: unknown,
     timestamp?: string,
 ): Resource {
@@ -24,8 +37,11 @@ export function createMaterializedFromOutputPotential(
     return {
         id,
         resourceTypeId,
-        creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.materialized,
+        provenance: {
+            resourceProvenanceKind: 'strategy',
+            strategyRunId: outputPotential.strategyRunId ?? ('STRATEGY_RUN-UNKNOWN' as StrategyRunId),
+            creationContext,
+        },
         version: 1,
         timestamp: timestamp ?? new Date().toISOString(),
         path,
@@ -34,7 +50,7 @@ export function createMaterializedFromOutputPotential(
 }
 
 export function createMaterializedFromInputPotential(
-    inputPotential: InternalInputPotentialShell,
+    inputPotential: InputPotential,
     nucleus: unknown,
     timestamp?: string,
 ): Resource {
@@ -44,8 +60,11 @@ export function createMaterializedFromInputPotential(
     return {
         id,
         resourceTypeId,
-        creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.materialized,
+        provenance: {
+            resourceProvenanceKind: 'strategy',
+            strategyRunId: inputPotential.strategyRunId ?? ('STRATEGY_RUN-UNKNOWN' as StrategyRunId),
+            creationContext,
+        },
         version: 1,
         timestamp: timestamp ?? new Date().toISOString(),
         path,
@@ -54,11 +73,11 @@ export function createMaterializedFromInputPotential(
 }
 
 export function createMaterializedFromPotential(
-    potential: InternalInputPotentialShell | OutputPotentialShell,
+    potential: InputPotential | OutputPotential,
     nucleus: unknown,
     timestamp?: string,
 ): Resource {
-    if (potential.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.internalInputPotential) {
+    if ('strategyStateInputKind' in potential && potential.strategyStateInputKind === 'referenceInput') {
         return createMaterializedFromInputPotential(potential, nucleus, timestamp);
     }
 
@@ -66,13 +85,11 @@ export function createMaterializedFromPotential(
 }
 
 export function createExternalInputPotential(
-    id: ResourceId,
-    resourceTypeId: ResourceTypeId,
-): ExternalInputPotentialShell {
+    _id: ResourceId,
+    _resourceTypeId: ResourceTypeId,
+): ExternalInput {
     return {
-        id,
-        resourceTypeId,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
+        strategyStateInputKind: 'externalInput',
     };
 }
 
@@ -80,12 +97,14 @@ export function createInputPotential(
     id: ResourceId,
     resourceTypeId: ResourceTypeId,
     creationContext: CreationContext,
-): InternalInputPotentialShell {
+): InputPotential {
     return {
         id,
         resourceTypeId,
+        strategyStateInputKind: 'referenceInput',
+        toolStepPath: creationContext.toolStepPath,
+        roleName: creationContext.roleName,
         creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.internalInputPotential,
     };
 }
 
@@ -93,11 +112,10 @@ export function createOutputPotential(
     id: ResourceId,
     resourceTypeId: ResourceTypeId,
     creationContext: CreationContext,
-): OutputPotentialShell {
+): OutputPotential {
     return {
         id,
         resourceTypeId,
         creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.outputPotential,
     };
 }

package/src/utils/creation/runnableStrategyCreation.ts

@@ -1,42 +1,28 @@
 import type {
-    RawStrategy,
-    RunnableStrategyId,
-    RunnableStrategy,
     Step,
-    StepArrayByStrategyThread,
-    StrategyThreadId,
+    Strategy,
+    StrategyId,
 } from '@toolproof-core/schema';
 import { getIndependentThreads } from '../parallelizeSteps.js';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
 
-export function getRunnableStrategyThreadGroups(rawStrategy: RawStrategy): Step[][] {
-    return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState);
+export function getRunnableStrategyThreadGroups(rawStrategy: Strategy): Step[][] {
+    if ('steps' in rawStrategy) {
+        return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState as any);
+    }
+
+    return rawStrategy.stepsByThreadIndex;
 }
 
 export function buildRunnableStrategy(
-    rawStrategy: RawStrategy,
-    runnableStrategyId: RunnableStrategyId,
     threadStepGroups: Step[][],
-    threadIdentities: StrategyThreadId[],
-): RunnableStrategy {
-    if (threadStepGroups.length !== threadIdentities.length) {
-        throw new Error('buildRunnableStrategy requires one thread id per thread group');
-    }
-
-    const stepsByStrategyThread: StepArrayByStrategyThread = {};
-
-    for (const [index, group] of threadStepGroups.entries()) {
-        const threadId = threadIdentities[index];
-
-        if (!threadId) {
-            throw new Error(`Missing thread id for thread group index ${index}`);
-        }
-
-        stepsByStrategyThread[threadId] = group;
-    }
-
+    runnableStrategyId: StrategyId,
+    rawStrategy: Strategy,
+): Strategy {
     return {
         id: runnableStrategyId,
-        stepsByStrategyThread,
+        strategyKind: CONSTANTS.Enums.StrategyKind.threaded,
+        stepsByThreadIndex: threadStepGroups,
         strategyState: rawStrategy.strategyState,
     };
 }

package/src/utils/creation/stepCreation.ts

@@ -1,17 +1,23 @@
 import type {
-    BranchStepId,
     BranchStep,
     Case,
-    ForStepId,
     ForStep,
     Tool,
-    ToolStepId,
     ToolStep,
-    ResourceRoleId,
-    WhileStepId,
     WhileStep,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
+import { getInputRoleNames, getOutputRoleNames } from '../roleSpec.js';
+
+type ToolStepId = string;
+type BranchStepId = string;
+type ForStepId = string;
+type WhileStepId = string;
+
+type ToolStepWithId = ToolStep & { id: ToolStepId };
+type BranchStepWithId = BranchStep & { id: BranchStepId };
+type ForStepWithId = ForStep & { id: ForStepId };
+type WhileStepWithId = WhileStep & { id: WhileStepId };
 
 export type LoopStepBuildIdentities =
     | {
@@ -40,21 +46,21 @@ function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
 
 function getRoleBindingSpec(tool: Tool): ToolStep['roleBindingSpec'] {
     return {
-        inputBindings: Object.keys(tool.roleSpec.inputRoleValueById) as ResourceRoleId[],
-        outputBindings: Object.keys(tool.roleSpec.outputRoleValueById) as ResourceRoleId[],
+        inputBindings: getInputRoleNames(tool),
+        outputBindings: getOutputRoleNames(tool),
     };
 }
 
 export function buildToolStepFromTool(
     tool: Tool,
     id: ToolStepId,
-): ToolStep {
+): ToolStepWithId {
     return {
         id,
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolId: tool.id,
         roleBindingSpec: getRoleBindingSpec(tool),
-    };
+    } as ToolStepWithId;
 }
 
 export function buildLoopStepFromToolPair(
@@ -70,21 +76,21 @@ export function buildLoopStepFromToolPair(
             id: identities.stepId,
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: { what, when },
-        };
+        } as ForStepWithId;
     }
 
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: { what, when },
-    };
+    } as WhileStepWithId;
 }
 
 export function buildBranchStepFromToolPairs(
     cases: Array<{ whatTool: Tool; whenTool: Tool }>,
     branchId: BranchStepId,
     caseIdentities: BranchCaseBuildIdentities[],
-): BranchStep {
+): BranchStepWithId {
     if (cases.length !== caseIdentities.length) {
         throw new Error('buildBranchStepFromToolPairs requires one id pair per case');
     }
@@ -107,7 +113,7 @@ export function buildBranchStepFromToolPairs(
         id: branchId,
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases: resolved,
-    };
+    } as BranchStepWithId;
 }
 
 export function cloneForStepWithIdentities(
@@ -117,7 +123,7 @@ export function cloneForStepWithIdentities(
         whatId: ToolStepId;
         whenId: ToolStepId;
     },
-): ForStep {
+): ForStepWithId {
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.for,
@@ -131,7 +137,7 @@ export function cloneForStepWithIdentities(
                 id: identities.whenId,
             },
         },
-    };
+    } as ForStepWithId;
 }
 
 export function cloneWhileStepWithIdentities(
@@ -141,7 +147,7 @@ export function cloneWhileStepWithIdentities(
         whatId: ToolStepId;
         whenId: ToolStepId;
     },
-): WhileStep {
+): WhileStepWithId {
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
@@ -155,5 +161,5 @@ export function cloneWhileStepWithIdentities(
                 id: identities.whenId,
             },
         },
-    };
+    } as WhileStepWithId;
 }

package/src/utils/extractData.ts

@@ -1,20 +1,25 @@
 import type {
-    RawStrategy,
+    RoleName,
+    RoleValue,
+    Strategy,
     ToolId,
     Tool,
-    ToolStepId,
     ToolStep,
-    Step,
-    ResourceRoleId,
-    ResourceRole,
     ResourceId,
     ResourceTypeId,
     Resource,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
+import {
+    extractToolStepsFromStrategy,
+    getInputRoleEntries,
+    getOutputRoleEntries,
+    toToolRoleDescriptor,
+    type ToolRoleDescriptor,
+} from './roleSpec.js';
 
 
-export function extractToolIdsFromRawStrategy(rawStrategy: RawStrategy): ToolId[] {
+export function extractToolIdsFromRawStrategy(rawStrategy: Strategy): ToolId[] {
     const toolSteps = extractToolStepsFromRawStrategy(rawStrategy);
     const ids = new Set<ToolId>();
     for (const jStep of toolSteps) {
@@ -23,71 +28,24 @@ export function extractToolIdsFromRawStrategy(rawStrategy: RawStrategy): ToolId[
     return Array.from(ids);
 }
 
-export function extractToolStepsFromRawStrategy(rawStrategy: RawStrategy): ToolStep[] {
-    const toolSteps: ToolStep[] = [];
-    const seen = new Set<ToolStepId>();
-
-    const addToolStep = (toolStep: ToolStep) => {
-        if (seen.has(toolStep.id)) {
-            throw new Error(`Duplicate tool step id encountered: ${toolStep.id}`);
-        }
-        seen.add(toolStep.id);
-        toolSteps.push(toolStep);
-    };
-
-    const visitStep = (step: Step) => {
-        switch (step.stepKind) {
-            case CONSTANTS.Enums.StepKind.tool: {
-                addToolStep(step);
-                return;
-            }
-            case CONSTANTS.Enums.StepKind.branch: {
-                for (const conditional of step.cases) {
-                    addToolStep(conditional.when);
-                    addToolStep(conditional.what);
-                }
-                return;
-            }
-            case CONSTANTS.Enums.StepKind.while:
-            case CONSTANTS.Enums.StepKind.for: {
-                addToolStep(step.case.when);
-                addToolStep(step.case.what);
-                return;
-            }
-            default: {
-                const _exhaustive: never = step;
-                return _exhaustive;
-            }
-        }
-    };
-
-    for (const step of rawStrategy.steps) {
-        visitStep(step);
-    }
-
-    return toolSteps;
+export function extractToolStepsFromRawStrategy(rawStrategy: Strategy): ToolStep[] {
+    return extractToolStepsFromStrategy(rawStrategy);
 }
 
 
-export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategy, toolMap: Map<ToolId, Tool>): Map<ResourceRoleId, ResourceRole> {
-    const roleMap = new Map<ResourceRoleId, ResourceRole>();
+export function extractRoleMapFromRawStrategy(rawStrategy: Strategy, toolMap: Map<ToolId, Tool>): Map<RoleName, ToolRoleDescriptor> {
+    const roleMap = new Map<RoleName, ToolRoleDescriptor>();
     const toolIds = extractToolIdsFromRawStrategy(rawStrategy);
 
     for (const toolId of toolIds) {
         const tool = toolMap.get(toolId);
         if (!tool) continue;
 
-        for (const [rid, role] of Object.entries(tool.roleSpec.inputRoleValueById)) {
-            roleMap.set(rid as ResourceRoleId, {
-                id: rid as ResourceRoleId,
-                ...role,
-            });
+        for (const entry of getInputRoleEntries(tool)) {
+            roleMap.set(entry[0], toToolRoleDescriptor(entry));
         }
-        for (const [rid, role] of Object.entries(tool.roleSpec.outputRoleValueById)) {
-            roleMap.set(rid as ResourceRoleId, {
-                id: rid as ResourceRoleId,
-                ...role,
-            });
+        for (const entry of getOutputRoleEntries(tool)) {
+            roleMap.set(entry[0], toToolRoleDescriptor(entry));
         }
     }
 
@@ -96,11 +54,11 @@ export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategy, toolMap:
 
 export function extractSingleNonErrorOutputTypeId(tool: Tool): ResourceTypeId | null {
     const errorRoleId = CONSTANTS.Cosmos.ROLE_ErrorOutput;
-    const outputEntries = Object.entries(tool.roleSpec.outputRoleValueById).filter(([roleId]) => roleId !== errorRoleId);
+    const outputEntries = getOutputRoleEntries(tool).filter(([roleName]) => roleName !== errorRoleId);
     if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
         throw new Error(`Tool ${tool.id} must have exactly one non-error output role to be branchable/loopable`);
     } // ATTENTION_PUREIFY
-    const outputRole = outputEntries[0][1];
+    const outputRole = outputEntries[0][1] as RoleValue;
     return outputRole.resourceTypeId;
 }
 

package/src/utils/parallelizeSteps.ts

@@ -1,14 +1,20 @@
 import type {
     BranchStep,
     ForStep,
-    ToolStepId,
     ToolStep,
-    ResourceRoleId,
     Step,
-    StrategyState,
     WhileStep,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
+import type { StrategyState } from './strategyState.js';
+
+type ToolStepId = string;
+type ToolStepWithId = ToolStep & { id: ToolStepId };
+
+function getToolStepId(toolStep: ToolStep | undefined): ToolStepId | undefined {
+    const maybeId = (toolStep as Partial<ToolStepWithId> | undefined)?.id;
+    return typeof maybeId === 'string' ? maybeId : undefined;
+}
 
 
 export function getIndependentThreads(steps: Step[], strategyState: StrategyState): Step[][] {
@@ -22,22 +28,23 @@ export function getIndependentThreads(steps: Step[], strategyState: StrategyStat
     // Map each toolStep.id (including macro-nested tool steps) to owning top-level step index.
     const toolStepIdToOwner = new Map<ToolStepId, OwnerIndex>();
     const ownerToToolStepIds = new Map<OwnerIndex, ToolStepId[]>();
-    const toolStepById = new Map<ToolStepId, ToolStep>();
+    const toolStepById = new Map<ToolStepId, ToolStepWithId>();
 
     const addToolStep = (toolStep: ToolStep | undefined, ownerIndex: OwnerIndex) => {
-        if (!toolStep?.id) return;
+        const toolStepId = getToolStepId(toolStep);
+        if (!toolStepId || !toolStep) return;
 
-        const existingOwner = toolStepIdToOwner.get(toolStep.id);
+        const existingOwner = toolStepIdToOwner.get(toolStepId);
         if (existingOwner !== undefined) {
             throw new Error(
-                `Duplicate toolStep.id '${toolStep.id}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
+                `Duplicate toolStep.id '${toolStepId}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
             );
         }
 
-        toolStepIdToOwner.set(toolStep.id, ownerIndex);
-        toolStepById.set(toolStep.id, toolStep);
+        toolStepIdToOwner.set(toolStepId, ownerIndex);
+        toolStepById.set(toolStepId, toolStep as ToolStepWithId);
         const bucket = ownerToToolStepIds.get(ownerIndex) ?? [];
-        bucket.push(toolStep.id);
+        bucket.push(toolStepId);
         ownerToToolStepIds.set(ownerIndex, bucket);
     };
 
@@ -94,20 +101,22 @@ export function getIndependentThreads(steps: Step[], strategyState: StrategyStat
         const bucket = strategyState?.[toolStepId] ?? ({} as any);
 
         for (const inputRoleId of inputBindings) {
-            const entry = bucket?.[inputRoleId as ResourceRoleId] as any;
-            if (!entry || entry.resourceShellKind !== 'internalInputPotential') continue;
+            const entry = bucket?.[inputRoleId] as any;
+            if (!entry || entry.strategyStateInputKind !== 'referenceInput') continue;
 
-            const creatorToolStepId = entry?.creationContext?.toolStepId as ToolStepId | undefined;
+            const creatorToolStepId = typeof entry?.toolStepPath === 'string'
+                ? entry.toolStepPath as ToolStepId
+                : undefined;
             if (!creatorToolStepId) {
                 throw new Error(
-                    `Unresolvable internalInputPotential in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): missing creationContext.toolStepId for role '${inputRoleId}'`
+                    `Unresolvable referenceInput in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): missing toolStepPath for role '${inputRoleId}'`
                 );
             }
 
             const producerOwner = toolStepIdToOwner.get(creatorToolStepId);
             if (producerOwner === undefined) {
                 throw new Error(
-                    `Unresolvable internalInputPotential in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): creator toolStepId '${creatorToolStepId}' not found in strategy steps`
+                    `Unresolvable referenceInput in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): creator toolStepPath '${creatorToolStepId}' not found in strategy steps`
                 );
             }