@toolproof-core/lib 1.0.34 → 1.0.37

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 };
-}

package/src/utils/roleSpec.ts

@@ -1,84 +0,0 @@
-import type {
-    RoleName,
-    RoleValue,
-    Step,
-    StepArrayArray,
-    Tool,
-    ToolStep,
-} from '@toolproof-core/schema';
-
-export type StrategyStepGraph =
-    | { steps: Step[] }
-    | { stepsByThreadIndex: StepArrayArray };
-
-export interface ToolRoleDescriptor extends RoleValue {
-    id: RoleName;
-    name: string;
-}
-
-export function getInputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]> {
-    return Object.entries(tool.roleSpec.inputRoleValueByName) as Array<[RoleName, RoleValue]>;
-}
-
-export function getOutputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]> {
-    return Object.entries(tool.roleSpec.outputRoleValueByName) as Array<[RoleName, RoleValue]>;
-}
-
-export function getInputRoleNames(tool: Tool): RoleName[] {
-    return getInputRoleEntries(tool).map(([roleName]) => roleName);
-}
-
-export function getOutputRoleNames(tool: Tool): RoleName[] {
-    return getOutputRoleEntries(tool).map(([roleName]) => roleName);
-}
-
-export function toToolRoleDescriptor([roleName, roleValue]: [RoleName, RoleValue]): ToolRoleDescriptor {
-    return {
-        id: roleName,
-        name: roleName,
-        ...roleValue,
-    };
-}
-
-export function extractToolStepsFromStrategy(strategy: StrategyStepGraph): ToolStep[] {
-    const toolSteps: ToolStep[] = [];
-
-    const visitStep = (step: Step) => {
-        switch (step.stepKind) {
-            case 'tool': {
-                toolSteps.push(step);
-                return;
-            }
-            case 'branch': {
-                for (const conditional of step.cases) {
-                    toolSteps.push(conditional.when, conditional.what);
-                }
-                return;
-            }
-            case 'while':
-            case 'for': {
-                toolSteps.push(step.case.when, step.case.what);
-                return;
-            }
-            default: {
-                const _exhaustive: never = step;
-                return _exhaustive;
-            }
-        }
-    };
-
-    if ('steps' in strategy) {
-        for (const step of strategy.steps) {
-            visitStep(step);
-        }
-        return toolSteps;
-    }
-
-    for (const threadSteps of strategy.stepsByThreadIndex) {
-        for (const step of threadSteps) {
-            visitStep(step);
-        }
-    }
-
-    return toolSteps;
-}

package/src/utils/strategyState.ts

@@ -1,57 +0,0 @@
-import type {
-    CreationContext,
-    Strategy,
-    StrategyStateInputEntry,
-    StrategyStateInputEntryByRoleName,
-} from '@toolproof-core/schema';
-
-export type StrategyState = Strategy['strategyState'];
-export type StrategyStateLike = Record<string, Record<string, unknown>>;
-
-export function getStrategyStateBucket(
-    strategyState: StrategyStateLike,
-    toolStepPath: CreationContext['toolStepPath'],
-): StrategyStateInputEntryByRoleName | undefined {
-    return strategyState[toolStepPath] as StrategyStateInputEntryByRoleName | undefined;
-}
-
-export function getStrategyStateEntry(
-    strategyState: StrategyStateLike,
-    context: CreationContext,
-): StrategyStateInputEntry | undefined {
-    return getStrategyStateBucket(strategyState, context.toolStepPath)?.[context.roleName];
-}
-
-export function setStrategyStateEntry<TStrategyState extends StrategyStateLike>(
-    strategyState: TStrategyState,
-    context: CreationContext,
-    entry: StrategyStateInputEntry,
-): TStrategyState {
-    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath) ?? {};
-
-    return {
-        ...strategyState,
-        [context.toolStepPath]: {
-            ...bucket,
-            [context.roleName]: entry,
-        },
-    } as TStrategyState;
-}
-
-export function clearStrategyStateEntry<TStrategyState extends StrategyStateLike>(
-    strategyState: TStrategyState,
-    context: CreationContext,
-): TStrategyState {
-    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath);
-    if (!bucket || !(context.roleName in bucket)) {
-        return strategyState;
-    }
-
-    const nextBucket = { ...bucket };
-    delete nextBucket[context.roleName];
-
-    return {
-        ...strategyState,
-        [context.toolStepPath]: nextBucket,
-    } as TStrategyState;
-}