@toolproof-core/lib 1.0.33 → 1.0.34

package/src/utils/extractData.ts

@@ -1,7 +1,6 @@
 import type {
     RoleName,
     RoleValue,
-    Strategy,
     ToolId,
     Tool,
     ToolStep,
@@ -15,12 +14,13 @@ import {
     getInputRoleEntries,
     getOutputRoleEntries,
     toToolRoleDescriptor,
+    type StrategyStepGraph,
     type ToolRoleDescriptor,
 } from './roleSpec.js';
 
 
-export function extractToolIdsFromRawStrategy(rawStrategy: Strategy): ToolId[] {
-    const toolSteps = extractToolStepsFromRawStrategy(rawStrategy);
+export function extractToolIdsFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolId[] {
+    const toolSteps = extractToolStepsFromUnthreadedStrategy(unthreadedStrategy);
     const ids = new Set<ToolId>();
     for (const jStep of toolSteps) {
         ids.add(jStep.toolId);
@@ -28,14 +28,14 @@ export function extractToolIdsFromRawStrategy(rawStrategy: Strategy): ToolId[] {
     return Array.from(ids);
 }
 
-export function extractToolStepsFromRawStrategy(rawStrategy: Strategy): ToolStep[] {
-    return extractToolStepsFromStrategy(rawStrategy);
+export function extractToolStepsFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolStep[] {
+    return extractToolStepsFromStrategy(unthreadedStrategy);
 }
 
 
-export function extractRoleMapFromRawStrategy(rawStrategy: Strategy, toolMap: Map<ToolId, Tool>): Map<RoleName, ToolRoleDescriptor> {
+export function extractRoleMapFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph, toolMap: Map<ToolId, Tool>): Map<RoleName, ToolRoleDescriptor> {
     const roleMap = new Map<RoleName, ToolRoleDescriptor>();
-    const toolIds = extractToolIdsFromRawStrategy(rawStrategy);
+    const toolIds = extractToolIdsFromUnthreadedStrategy(unthreadedStrategy);
 
     for (const toolId of toolIds) {
         const tool = toolMap.get(toolId);

package/src/utils/roleSpec.ts

@@ -1,12 +1,16 @@
 import type {
     RoleName,
     RoleValue,
-    Strategy,
     Step,
+    StepArrayArray,
     Tool,
     ToolStep,
 } from '@toolproof-core/schema';
 
+export type StrategyStepGraph =
+    | { steps: Step[] }
+    | { stepsByThreadIndex: StepArrayArray };
+
 export interface ToolRoleDescriptor extends RoleValue {
     id: RoleName;
     name: string;
@@ -36,7 +40,7 @@ export function toToolRoleDescriptor([roleName, roleValue]: [RoleName, RoleValue
     };
 }
 
-export function extractToolStepsFromStrategy(strategy: Strategy): ToolStep[] {
+export function extractToolStepsFromStrategy(strategy: StrategyStepGraph): ToolStep[] {
     const toolSteps: ToolStep[] = [];
 
     const visitStep = (step: Step) => {

package/src/utils/strategyState.ts

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