@toolproof-core/lib 1.0.33 → 1.0.36

package/src/utils/bindInputRoleToResource.ts

@@ -1,53 +0,0 @@
-import type {
-    CreationContext,
-    Resource,
-    ReferenceInput,
-    ValueInput,
-} from '@toolproof-core/schema';
-import {
-    clearStrategyStateEntry,
-    getStrategyStateEntry,
-    setStrategyStateEntry,
-    type StrategyState,
-} from './strategyState.js';
-
-
-export function bindInputResInStrategyState(
-    strategyState: StrategyState,
-    target: CreationContext,
-    resource: Resource
-): StrategyState {
-    const entry: ValueInput = {
-        strategyStateInputKind: 'valueInput',
-        resourceTypeId: resource.resourceTypeId,
-        nucleus: resource.nucleus,
-    };
-
-    return setStrategyStateEntry(strategyState, target, entry);
-}
-
-export function bindInputRefInStrategyState(
-    strategyState: StrategyState,
-    target: CreationContext,
-    source: CreationContext
-): StrategyState {
-    const sourceEntry = getStrategyStateEntry(strategyState, source);
-    if (!sourceEntry) {
-        throw new Error(`resourceEntry not found for source (${source.toolStepPath}, ${source.roleName})`);
-    }
-
-    const entry: ReferenceInput = {
-        strategyStateInputKind: 'referenceInput',
-        toolStepPath: source.toolStepPath,
-        roleName: source.roleName,
-    };
-
-    return setStrategyStateEntry(strategyState, target, entry);
-}
-
-export function clearInputBindingInStrategyState(
-    strategyState: StrategyState,
-    target: CreationContext
-): StrategyState {
-    return clearStrategyStateEntry(strategyState, target);
-}

package/src/utils/creation/runnableStrategyCreation.ts

@@ -1,28 +0,0 @@
-import type {
-    Step,
-    Strategy,
-    StrategyId,
-} from '@toolproof-core/schema';
-import { getIndependentThreads } from '../parallelizeSteps.js';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
-
-export function getRunnableStrategyThreadGroups(rawStrategy: Strategy): Step[][] {
-    if ('steps' in rawStrategy) {
-        return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState as any);
-    }
-
-    return rawStrategy.stepsByThreadIndex;
-}
-
-export function buildRunnableStrategy(
-    threadStepGroups: Step[][],
-    runnableStrategyId: StrategyId,
-    rawStrategy: Strategy,
-): Strategy {
-    return {
-        id: runnableStrategyId,
-        strategyKind: CONSTANTS.Enums.StrategyKind.threaded,
-        stepsByThreadIndex: threadStepGroups,
-        strategyState: rawStrategy.strategyState,
-    };
-}

package/src/utils/resolveResourceChain.ts

@@ -1,52 +0,0 @@
-import type {
-    CreationContext,
-    ExternalInput,
-    ReferenceInput,
-    StrategyStateInputEntry,
-    ValueInput,
-} from '@toolproof-core/schema';
-import { getStrategyStateEntry, type StrategyState } from './strategyState.js';
-
-export type ResolveResult =
-    | { 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(
-    strategyState: StrategyState,
-    start: CreationContext,
-    opts?: { maxDepth?: number }
-): ResolveResult {
-    const maxDepth = opts?.maxDepth ?? 50;
-    const visited = new Set<string>();
-    const path: CreationContext[] = [];
-    let current: CreationContext = start;
-
-    for (let depth = 0; depth <= maxDepth; depth++) {
-        path.push(current);
-        const visitKey = `${current.toolStepPath}::${current.roleName}`;
-        if (visited.has(visitKey)) {
-            return { status: 'unresolved', reason: 'cycle', path };
-        }
-        visited.add(visitKey);
-
-        const entry = getStrategyStateEntry(strategyState, current) as StrategyStateInputEntry | undefined;
-        if (!entry) return { status: 'unresolved', reason: 'not-found', path };
-
-        if (entry.strategyStateInputKind === 'valueInput') {
-            return { status: 'valueInput', entry: entry, path };
-        }
-        if (entry.strategyStateInputKind === 'externalInput') {
-            return { status: 'externalInput', entry: entry, path };
-        }
-
-        current = {
-            toolStepPath: (entry as ReferenceInput).toolStepPath,
-            roleName: (entry as ReferenceInput).roleName,
-        };
-        continue;
-
-    }
-
-    return { status: 'unresolved', reason: 'depth-exceeded', path };
-}