@mastra/core 0.9.4 → 0.10.0-alpha.1

package/dist/workflows/index.d.cts

@@ -1,88 +1,208 @@
-import { aA as VariableReference, aH as StepResult, K as Step, L as Workflow, F as Agent, aK as WorkflowContext, b4 as ToolsInput, a as Mastra, av as StepAction, aJ as WorkflowRunResult } from '../base-CAEcd6q2.cjs';
-export { aC as ActionContext, aB as BaseCondition, aQ as DependencyCheckOutput, aX as ExtractSchemaFromStep, a_ as ExtractSchemaType, aY as ExtractStepResult, a$ as PathsToStringProps, aN as ResolverFunctionInput, aO as ResolverFunctionOutput, az as RetryConfig, aF as StepCondition, aG as StepConfig, aE as StepDef, au as StepExecutionContext, ay as StepGraph, aW as StepId, aZ as StepInputType, ax as StepNode, aR as StepResolverOutput, aw as StepVariableType, aI as StepsRecord, aP as SubscriberFunctionOutput, aD as WhenConditionReturnValue, aT as WorkflowActionParams, aU as WorkflowActions, aS as WorkflowActors, aM as WorkflowEvent, aL as WorkflowLogMessage, O as WorkflowOptions, b1 as WorkflowResumeResult, b0 as WorkflowRunState, aV as WorkflowState } from '../base-CAEcd6q2.cjs';
-import { z } from 'zod';
-import { a as Metric } from '../types-BtMyV38I.cjs';
-import { L as Logger } from '../index-QV27jkxQ.cjs';
-import '../base-H7siSAfu.cjs';
+import { a$ as ExecutionEngine, b4 as StepResult, a_ as ExecutionGraph, aR as StepFlowEntry, ae as Step, b0 as ExecuteFunction } from '../base-aJ3etsh5.cjs';
+export { b6 as DynamicMapping, b9 as ExtractSchemaFromStep, b8 as ExtractSchemaType, b7 as PathsToStringProps, aZ as Run, aS as SerializedStep, aT as SerializedStepFlowEntry, b2 as StepFailure, b1 as StepSuccess, b3 as StepSuspended, b5 as StepsRecord, ba as VariableReference, bb as WatchEvent, af as Workflow, ag as WorkflowConfig, aY as WorkflowResult, bd as WorkflowRunState, bc as ZodPathType, aV as cloneStep, aX as cloneWorkflow, aU as createStep, aW as createWorkflow } from '../base-aJ3etsh5.cjs';
+import { Span } from '@opentelemetry/api';
+import { RuntimeContext } from '../runtime-context/index.cjs';
 import 'ai';
-import 'sift';
-import 'json-schema';
-import '../runtime-context/index.cjs';
-import '@opentelemetry/api';
-import 'xstate';
-import 'node:events';
-import '../vector/index.cjs';
-import '../vector/filter/index.cjs';
+import '../base-aPYtPBT2.cjs';
+import '../logger-EhZkzZOr.cjs';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
-import '../tts/index.cjs';
-import 'node:http';
-import 'hono';
-import 'events';
+import '../types-Bo1uigWx.cjs';
+import 'sift';
+import 'zod';
+import 'json-schema';
 import '../deployer/index.cjs';
 import '../bundler/index.cjs';
+import 'node:http';
+import 'hono';
+import '../vector/index.cjs';
+import '../vector/filter/index.cjs';
 import 'hono/cors';
 import 'hono-openapi';
+import '../tts/index.cjs';
+import 'xstate';
+import 'node:events';
+import 'events';
 import 'ai/test';
 
-declare function isErrorEvent(stateEvent: any): stateEvent is {
-    type: `xstate.error.actor.${string}`;
-    error: Error;
-};
-declare function isTransitionEvent(stateEvent: any): stateEvent is {
-    type: `xstate.done.actor.${string}`;
-    output?: unknown;
-};
-declare function isVariableReference(value: any): value is VariableReference<any, any>;
-declare function getStepResult(result?: StepResult<any>): any;
-declare function getSuspendedPaths({ value, path, suspendedPaths, }: {
-    value: string | Record<string, string>;
-    path: string;
-    suspendedPaths: Set<string>;
-}): void;
-declare function isFinalState(status: string): boolean;
-declare function isLimboState(status: string): boolean;
-declare function recursivelyCheckForFinalState({ value, suspendedPaths, path, }: {
-    value: string | Record<string, string>;
-    suspendedPaths: Set<string>;
-    path: string;
-}): boolean;
-declare function getActivePathsAndStatus(value: Record<string, any>): Array<{
-    stepPath: string[];
-    stepId: string;
-    status: string;
-}>;
-declare function mergeChildValue(startStepId: string, parent: Record<string, any>, child: Record<string, any>): Record<string, any>;
-declare const updateStepInHierarchy: (value: Record<string, any>, targetStepId: string) => Record<string, any>;
-declare function getResultActivePaths(state: {
-    value: Record<string, string>;
-    context: {
-        steps: Record<string, any>;
-    };
-}): Map<string, {
-    status: string;
-    suspendPayload?: any;
-    stepPath: string[];
-}>;
-declare function isWorkflow(step: Step<any, any, any, any> | Workflow<any, any, any, any> | Agent<any, any, any>): step is Workflow<any, any, any, any>;
-declare function isAgent(step: Step<any, any, any, any> | Agent<any, any, any> | Workflow<any, any, any, any>): step is Agent<any, any, any>;
-declare function resolveVariables({ runId, logger, variables, context, }: {
+type ExecutionContext = {
+    workflowId: string;
     runId: string;
-    logger: Logger;
-    variables: Record<string, VariableReference<any, any>>;
-    context: WorkflowContext;
-}): Record<string, any>;
-declare function agentToStep<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>>(agent: Agent<TAgentId, TTools, TMetrics>, { mastra }?: {
-    mastra?: Mastra;
-}): StepAction<TAgentId, z.ZodObject<{
-    prompt: z.ZodString;
-}>, z.ZodObject<{
-    text: z.ZodString;
-}>, any>;
-declare function workflowToStep<TSteps extends Step<any, any, any, any>[], TStepId extends string = any, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any>(workflow: Workflow<TSteps, TStepId, TTriggerSchema, TResultSchema>, { mastra }: {
-    mastra?: Mastra;
-}): StepAction<TStepId, TTriggerSchema, z.ZodType<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
-declare function isConditionalKey(key: string): boolean;
+    executionPath: number[];
+    suspendedPaths: Record<string, number[]>;
+    retryConfig: {
+        attempts: number;
+        delay: number;
+    };
+    executionSpan: Span;
+};
+/**
+ * Default implementation of the ExecutionEngine using XState
+ */
+declare class DefaultExecutionEngine extends ExecutionEngine {
+    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: {
+        emit: (event: string, data: any) => Promise<void>;
+    }, stepResults: Record<string, StepResult<any>>, lastOutput: StepResult<any>, error?: Error | string): Promise<TOutput>;
+    /**
+     * Executes a workflow run with the provided execution graph and input
+     * @param graph The execution graph to execute
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<TOutput>;
+    getStepOutput(stepResults: Record<string, any>, step?: StepFlowEntry): any;
+    executeStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        step: Step<string, any, any>;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+        };
+        prevOutput: any;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeParallel({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'parallel';
+            steps: StepFlowEntry[];
+        };
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'conditional';
+            steps: StepFlowEntry[];
+            conditions: ExecuteFunction<any, any, any, any>[];
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeLoop({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'loop';
+            step: Step;
+            condition: ExecuteFunction<any, any, any, any>;
+            loopType: 'dowhile' | 'dountil';
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeForeach({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'foreach';
+            step: Step;
+            opts: {
+                concurrency: number;
+            };
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    protected persistStepUpdate({ workflowId, runId, stepResults, executionContext, }: {
+        workflowId: string;
+        runId: string;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+    }): Promise<void>;
+    executeEntry({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: StepFlowEntry;
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+}
 
-export { Step, StepAction, StepResult, VariableReference, Workflow, WorkflowContext, WorkflowRunResult, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };
+export { DefaultExecutionEngine, ExecuteFunction, type ExecutionContext, ExecutionEngine, ExecutionGraph, Step, StepFlowEntry, StepResult };

package/dist/workflows/index.d.ts

@@ -1,88 +1,208 @@
-import { aA as VariableReference, aH as StepResult, K as Step, L as Workflow, F as Agent, aK as WorkflowContext, b4 as ToolsInput, a as Mastra, av as StepAction, aJ as WorkflowRunResult } from '../base-BCfssGt6.js';
-export { aC as ActionContext, aB as BaseCondition, aQ as DependencyCheckOutput, aX as ExtractSchemaFromStep, a_ as ExtractSchemaType, aY as ExtractStepResult, a$ as PathsToStringProps, aN as ResolverFunctionInput, aO as ResolverFunctionOutput, az as RetryConfig, aF as StepCondition, aG as StepConfig, aE as StepDef, au as StepExecutionContext, ay as StepGraph, aW as StepId, aZ as StepInputType, ax as StepNode, aR as StepResolverOutput, aw as StepVariableType, aI as StepsRecord, aP as SubscriberFunctionOutput, aD as WhenConditionReturnValue, aT as WorkflowActionParams, aU as WorkflowActions, aS as WorkflowActors, aM as WorkflowEvent, aL as WorkflowLogMessage, O as WorkflowOptions, b1 as WorkflowResumeResult, b0 as WorkflowRunState, aV as WorkflowState } from '../base-BCfssGt6.js';
-import { z } from 'zod';
-import { a as Metric } from '../types-BtMyV38I.js';
-import { L as Logger } from '../index-QV27jkxQ.js';
-import '../base-4Z34GQL8.js';
+import { a$ as ExecutionEngine, b4 as StepResult, a_ as ExecutionGraph, aR as StepFlowEntry, ae as Step, b0 as ExecuteFunction } from '../base-DttB7sJD.js';
+export { b6 as DynamicMapping, b9 as ExtractSchemaFromStep, b8 as ExtractSchemaType, b7 as PathsToStringProps, aZ as Run, aS as SerializedStep, aT as SerializedStepFlowEntry, b2 as StepFailure, b1 as StepSuccess, b3 as StepSuspended, b5 as StepsRecord, ba as VariableReference, bb as WatchEvent, af as Workflow, ag as WorkflowConfig, aY as WorkflowResult, bd as WorkflowRunState, bc as ZodPathType, aV as cloneStep, aX as cloneWorkflow, aU as createStep, aW as createWorkflow } from '../base-DttB7sJD.js';
+import { Span } from '@opentelemetry/api';
+import { RuntimeContext } from '../runtime-context/index.js';
 import 'ai';
-import 'sift';
-import 'json-schema';
-import '../runtime-context/index.js';
-import '@opentelemetry/api';
-import 'xstate';
-import 'node:events';
-import '../vector/index.js';
-import '../vector/filter/index.js';
+import '../base-tc5kgDTD.js';
+import '../logger-EhZkzZOr.js';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
-import '../tts/index.js';
-import 'node:http';
-import 'hono';
-import 'events';
+import '../types-Bo1uigWx.js';
+import 'sift';
+import 'zod';
+import 'json-schema';
 import '../deployer/index.js';
 import '../bundler/index.js';
+import 'node:http';
+import 'hono';
+import '../vector/index.js';
+import '../vector/filter/index.js';
 import 'hono/cors';
 import 'hono-openapi';
+import '../tts/index.js';
+import 'xstate';
+import 'node:events';
+import 'events';
 import 'ai/test';
 
-declare function isErrorEvent(stateEvent: any): stateEvent is {
-    type: `xstate.error.actor.${string}`;
-    error: Error;
-};
-declare function isTransitionEvent(stateEvent: any): stateEvent is {
-    type: `xstate.done.actor.${string}`;
-    output?: unknown;
-};
-declare function isVariableReference(value: any): value is VariableReference<any, any>;
-declare function getStepResult(result?: StepResult<any>): any;
-declare function getSuspendedPaths({ value, path, suspendedPaths, }: {
-    value: string | Record<string, string>;
-    path: string;
-    suspendedPaths: Set<string>;
-}): void;
-declare function isFinalState(status: string): boolean;
-declare function isLimboState(status: string): boolean;
-declare function recursivelyCheckForFinalState({ value, suspendedPaths, path, }: {
-    value: string | Record<string, string>;
-    suspendedPaths: Set<string>;
-    path: string;
-}): boolean;
-declare function getActivePathsAndStatus(value: Record<string, any>): Array<{
-    stepPath: string[];
-    stepId: string;
-    status: string;
-}>;
-declare function mergeChildValue(startStepId: string, parent: Record<string, any>, child: Record<string, any>): Record<string, any>;
-declare const updateStepInHierarchy: (value: Record<string, any>, targetStepId: string) => Record<string, any>;
-declare function getResultActivePaths(state: {
-    value: Record<string, string>;
-    context: {
-        steps: Record<string, any>;
-    };
-}): Map<string, {
-    status: string;
-    suspendPayload?: any;
-    stepPath: string[];
-}>;
-declare function isWorkflow(step: Step<any, any, any, any> | Workflow<any, any, any, any> | Agent<any, any, any>): step is Workflow<any, any, any, any>;
-declare function isAgent(step: Step<any, any, any, any> | Agent<any, any, any> | Workflow<any, any, any, any>): step is Agent<any, any, any>;
-declare function resolveVariables({ runId, logger, variables, context, }: {
+type ExecutionContext = {
+    workflowId: string;
     runId: string;
-    logger: Logger;
-    variables: Record<string, VariableReference<any, any>>;
-    context: WorkflowContext;
-}): Record<string, any>;
-declare function agentToStep<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>>(agent: Agent<TAgentId, TTools, TMetrics>, { mastra }?: {
-    mastra?: Mastra;
-}): StepAction<TAgentId, z.ZodObject<{
-    prompt: z.ZodString;
-}>, z.ZodObject<{
-    text: z.ZodString;
-}>, any>;
-declare function workflowToStep<TSteps extends Step<any, any, any, any>[], TStepId extends string = any, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any>(workflow: Workflow<TSteps, TStepId, TTriggerSchema, TResultSchema>, { mastra }: {
-    mastra?: Mastra;
-}): StepAction<TStepId, TTriggerSchema, z.ZodType<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
-declare function isConditionalKey(key: string): boolean;
+    executionPath: number[];
+    suspendedPaths: Record<string, number[]>;
+    retryConfig: {
+        attempts: number;
+        delay: number;
+    };
+    executionSpan: Span;
+};
+/**
+ * Default implementation of the ExecutionEngine using XState
+ */
+declare class DefaultExecutionEngine extends ExecutionEngine {
+    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: {
+        emit: (event: string, data: any) => Promise<void>;
+    }, stepResults: Record<string, StepResult<any>>, lastOutput: StepResult<any>, error?: Error | string): Promise<TOutput>;
+    /**
+     * Executes a workflow run with the provided execution graph and input
+     * @param graph The execution graph to execute
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<TOutput>;
+    getStepOutput(stepResults: Record<string, any>, step?: StepFlowEntry): any;
+    executeStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        step: Step<string, any, any>;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+        };
+        prevOutput: any;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeParallel({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'parallel';
+            steps: StepFlowEntry[];
+        };
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'conditional';
+            steps: StepFlowEntry[];
+            conditions: ExecuteFunction<any, any, any, any>[];
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeLoop({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'loop';
+            step: Step;
+            condition: ExecuteFunction<any, any, any, any>;
+            loopType: 'dowhile' | 'dountil';
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeForeach({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'foreach';
+            step: Step;
+            opts: {
+                concurrency: number;
+            };
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    protected persistStepUpdate({ workflowId, runId, stepResults, executionContext, }: {
+        workflowId: string;
+        runId: string;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+    }): Promise<void>;
+    executeEntry({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: StepFlowEntry;
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+}
 
-export { Step, StepAction, StepResult, VariableReference, Workflow, WorkflowContext, WorkflowRunResult, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };
+export { DefaultExecutionEngine, ExecuteFunction, type ExecutionContext, ExecutionEngine, ExecutionGraph, Step, StepFlowEntry, StepResult };

package/dist/workflows/index.js

@@ -1 +1 @@
-export { Step, WhenConditionReturnValue, Workflow, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep } from '../chunk-FW5RS6WV.js';
+export { DefaultExecutionEngine, ExecutionEngine, Run, Workflow, cloneStep, cloneWorkflow, createStep, createWorkflow } from '../chunk-3SQ3G2EJ.js';

package/dist/workflows/legacy/index.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+var chunkAOGUTJUO_cjs = require('../../chunk-AOGUTJUO.cjs');
+
+
+
+Object.defineProperty(exports, "LegacyStep", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.LegacyStep; }
+});
+Object.defineProperty(exports, "LegacyWorkflow", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.LegacyWorkflow; }
+});
+Object.defineProperty(exports, "WhenConditionReturnValue", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.WhenConditionReturnValue; }
+});
+Object.defineProperty(exports, "agentToStep", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.agentToStep; }
+});
+Object.defineProperty(exports, "getActivePathsAndStatus", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.getActivePathsAndStatus; }
+});
+Object.defineProperty(exports, "getResultActivePaths", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.getResultActivePaths; }
+});
+Object.defineProperty(exports, "getStepResult", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.getStepResult; }
+});
+Object.defineProperty(exports, "getSuspendedPaths", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.getSuspendedPaths; }
+});
+Object.defineProperty(exports, "isAgent", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isAgent; }
+});
+Object.defineProperty(exports, "isConditionalKey", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isConditionalKey; }
+});
+Object.defineProperty(exports, "isErrorEvent", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isErrorEvent; }
+});
+Object.defineProperty(exports, "isFinalState", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isFinalState; }
+});
+Object.defineProperty(exports, "isLimboState", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isLimboState; }
+});
+Object.defineProperty(exports, "isTransitionEvent", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isTransitionEvent; }
+});
+Object.defineProperty(exports, "isVariableReference", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isVariableReference; }
+});
+Object.defineProperty(exports, "isWorkflow", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.isWorkflow; }
+});
+Object.defineProperty(exports, "mergeChildValue", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.mergeChildValue; }
+});
+Object.defineProperty(exports, "recursivelyCheckForFinalState", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.recursivelyCheckForFinalState; }
+});
+Object.defineProperty(exports, "resolveVariables", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.resolveVariables; }
+});
+Object.defineProperty(exports, "updateStepInHierarchy", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.updateStepInHierarchy; }
+});
+Object.defineProperty(exports, "workflowToStep", {
+  enumerable: true,
+  get: function () { return chunkAOGUTJUO_cjs.workflowToStep; }
+});