@mastra/core 0.6.1-alpha.1 → 0.6.1-alpha.2

package/dist/agent/index.d.cts

@@ -1,7 +1,7 @@
 export { Message as AiMessageType } from 'ai';
 import 'json-schema';
 import 'zod';
-export { A as Agent, l as AgentConfig, aD as AgentGenerateOptions, aE as AgentStreamOptions, aw as MastraLanguageModel, a as ToolsInput, aC as ToolsetsInput } from '../base-D8JxJ6GC.cjs';
+export { A as Agent, l as AgentConfig, aD as AgentGenerateOptions, aE as AgentStreamOptions, aw as MastraLanguageModel, a as ToolsInput, aC as ToolsetsInput } from '../base-BNtyxqTf.cjs';
 import '../base-DboIg_Cd.cjs';
 import '../types-CwTG2XyQ.cjs';
 import 'sift';
@@ -14,4 +14,6 @@ import '@opentelemetry/api';
 import '@opentelemetry/sdk-trace-base';
 import '../vector/index.cjs';
 import '../vector/filter/index.cjs';
+import 'xstate';
+import 'node:events';
 import '../tts/index.cjs';

package/dist/agent/index.d.ts

@@ -1,7 +1,7 @@
 export { Message as AiMessageType } from 'ai';
 import 'json-schema';
 import 'zod';
-export { A as Agent, l as AgentConfig, aD as AgentGenerateOptions, aE as AgentStreamOptions, aw as MastraLanguageModel, a as ToolsInput, aC as ToolsetsInput } from '../base-CnxSa6Qc.js';
+export { A as Agent, l as AgentConfig, aD as AgentGenerateOptions, aE as AgentStreamOptions, aw as MastraLanguageModel, a as ToolsInput, aC as ToolsetsInput } from '../base-C1_KzNZ3.js';
 import '../base-BZViaFTt.js';
 import '../types-CwTG2XyQ.js';
 import 'sift';
@@ -14,4 +14,6 @@ import '@opentelemetry/api';
 import '@opentelemetry/sdk-trace-base';
 import '../vector/index.js';
 import '../vector/filter/index.js';
+import 'xstate';
+import 'node:events';
 import '../tts/index.js';

package/dist/{base-D8JxJ6GC.d.cts → base-BNtyxqTf.d.cts}

@@ -9,6 +9,9 @@ import { B as BaseLogMessage, R as RegisteredLogger, L as Logger, d as Run } fro
 import { MastraDeployer } from './deployer/index.cjs';
 import { MastraVector } from './vector/index.cjs';
 import { Span } from '@opentelemetry/api';
+import * as xstate from 'xstate';
+import { Snapshot } from 'xstate';
+import EventEmitter from 'node:events';
 import { MastraTTS } from './tts/index.cjs';
 
 type VercelTool = Tool;
@@ -189,7 +192,9 @@ interface WorkflowOptions<TTriggerSchema extends z.ZodObject<any> = any> {
     mastra?: Mastra;
 }
 interface StepExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined, TContext extends WorkflowContext = WorkflowContext> extends IExecutionContext<TSchemaIn> {
-    context: TSchemaIn extends z.ZodSchema ? z.infer<TSchemaIn> & TContext : TContext;
+    context: TSchemaIn extends z.ZodSchema ? {
+        inputData: z.infer<TSchemaIn>;
+    } & TContext : TContext;
     suspend: (payload?: unknown) => Promise<void>;
     runId: string;
     mastra?: MastraUnion;
@@ -258,6 +263,8 @@ type StepDef<TStepId extends TSteps[number]['id'], TSteps extends StepAction<any
         mastra?: Mastra;
     }) => Promise<boolean | WhenConditionReturnValue>);
     serializedWhen?: Condition<any, any> | string;
+    loopLabel?: string;
+    loopType?: 'when' | 'until';
     data: TSchemaIn;
     handler: (args: ActionContext<TSchemaIn>) => Promise<z.infer<TSchemaOut>>;
 }>;
@@ -283,6 +290,14 @@ interface StepConfig<TStep extends StepAction<any, any, any, any>, CondStep exte
     variables?: StepInputType<TStep, 'inputSchema'> extends never ? Record<string, VariableReference<VarStep, TTriggerSchema>> : {
         [K in keyof StepInputType<TStep, 'inputSchema'>]?: VariableReference<VarStep, TTriggerSchema>;
     };
+    '#internal'?: {
+        when?: Condition<CondStep, TTriggerSchema> | ((args: {
+            context: WorkflowContext<TTriggerSchema, TSteps>;
+            mastra?: Mastra;
+        }) => Promise<boolean | WhenConditionReturnValue>);
+        loopLabel?: string;
+        loopType?: 'when' | 'until';
+    };
 }
 type StepSuccess<T> = {
     status: 'success';
@@ -319,13 +334,13 @@ interface WorkflowRunResult<T extends z.ZodType<any>, TSteps extends Step<string
         suspendPayload?: any;
     }>;
 }
-interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[]> {
+interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[], TInputData extends Record<string, any> = Record<string, any>> {
     mastra?: MastraUnion;
     steps: {
         [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
     };
     triggerData: z.infer<TTrigger>;
-    resumeData?: any;
+    inputData: TInputData;
     attempts: Record<string, number>;
     getStepResult(stepId: 'trigger'): z.infer<TTrigger>;
     getStepResult<T extends keyof StepsRecord<TSteps> | unknown>(stepId: T extends keyof StepsRecord<TSteps> ? T : string): T extends keyof StepsRecord<TSteps> ? StepsRecord<TSteps>[T]['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<StepsRecord<TSteps>[T]['outputSchema']>> : T;
@@ -526,11 +541,441 @@ type WorkflowResumeResult<TTriggerSchema extends z.ZodObject<any>> = {
     results: Record<string, StepResult<any>>;
 };
 
+declare class Machine<TSteps extends Step<any, any, any>[] = any, TTriggerSchema extends z.ZodObject<any> = any> extends EventEmitter {
+    #private;
+    logger: Logger;
+    name: string;
+    constructor({ logger, mastra, workflowInstance, executionSpan, name, runId, steps, stepGraph, retryConfig, startStepId, }: {
+        logger: Logger;
+        mastra?: Mastra;
+        workflowInstance: WorkflowInstance;
+        executionSpan?: Span;
+        name: string;
+        runId: string;
+        steps: Record<string, TSteps[0]>;
+        stepGraph: StepGraph;
+        retryConfig?: RetryConfig;
+        startStepId: string;
+    });
+    get startStepId(): string;
+    execute({ stepId, input, snapshot, resumeData, }?: {
+        stepId?: string;
+        input?: any;
+        snapshot?: Snapshot<any>;
+        resumeData?: any;
+    }): Promise<Pick<WorkflowRunResult<TTriggerSchema, TSteps>, 'results' | 'activePaths'>>;
+    private initializeMachine;
+    getSnapshot(): xstate.MachineSnapshot<Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
+        type: "RESET_TO_PENDING";
+        stepId: string;
+    } | {
+        type: "CONDITIONS_MET";
+        stepId: string;
+    } | {
+        type: "CONDITION_FAILED";
+        stepId: string;
+        error: string;
+    } | {
+        type: "SUSPENDED";
+        stepId: string;
+        suspendPayload?: any;
+    } | {
+        type: "WAITING";
+        stepId: string;
+    } | {
+        type: `xstate.error.actor.${string}`;
+        error: Error;
+    } | {
+        type: `xstate.done.actor.${string}`;
+        output: ResolverFunctionOutput;
+    }, {
+        [x: string]: xstate.ActorRefFromLogic<xstate.PromiseActorLogic<{
+            type: "CONDITIONS_MET";
+            error?: undefined;
+        } | {
+            type: "CONDITIONS_SKIP_TO_COMPLETED";
+            error?: undefined;
+        } | {
+            type: "CONDITIONS_LIMBO";
+            error?: undefined;
+        } | {
+            type: "CONDITIONS_SKIPPED";
+            error?: undefined;
+        } | {
+            type: "CONDITION_FAILED";
+            error: string;
+        }, {
+            context: WorkflowContext;
+            stepNode: StepNode;
+        }, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<{
+            type: "STEP_FAILED";
+            error: string;
+            stepId: any;
+            result?: undefined;
+        } | {
+            type: "STEP_WAITING";
+            stepId: any;
+            error?: undefined;
+            result?: undefined;
+        } | {
+            type: "STEP_SUCCESS";
+            result: any;
+            stepId: any;
+            error?: undefined;
+        }, ResolverFunctionInput, xstate.EventObject>> | xstate.ActorRefFromLogic<xstate.PromiseActorLogic<{
+            steps: {};
+        }, {
+            parentStepId: string;
+            context: WorkflowContext;
+        }, xstate.EventObject>> | undefined;
+    }, {
+        [x: string]: {} | {
+            [x: string]: {} | /*elided*/ any | {
+                [x: string]: {} | /*elided*/ any | /*elided*/ any;
+            };
+        } | {
+            [x: string]: {} | {
+                [x: string]: {} | /*elided*/ any | /*elided*/ any;
+            } | /*elided*/ any;
+        };
+    }, string, xstate.NonReducibleUnknown, xstate.MetaObject, {
+        readonly id: string;
+        readonly type: "parallel";
+        readonly context: ({ input }: {
+            spawn: {
+                <TSrc extends "conditionCheck" | "resolverFunction" | "spawnSubscriberFunction">(logic: TSrc, ...[options]: ({
+                    src: "conditionCheck";
+                    logic: xstate.PromiseActorLogic<{
+                        type: "CONDITIONS_MET";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITIONS_SKIP_TO_COMPLETED";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITIONS_LIMBO";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITIONS_SKIPPED";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITION_FAILED";
+                        error: string;
+                    }, {
+                        context: WorkflowContext;
+                        stepNode: StepNode;
+                    }, xstate.EventObject>;
+                    id: string | undefined;
+                } extends infer T ? T extends {
+                    src: "conditionCheck";
+                    logic: xstate.PromiseActorLogic<{
+                        type: "CONDITIONS_MET";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITIONS_SKIP_TO_COMPLETED";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITIONS_LIMBO";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITIONS_SKIPPED";
+                        error?: undefined;
+                    } | {
+                        type: "CONDITION_FAILED";
+                        error: string;
+                    }, {
+                        context: WorkflowContext;
+                        stepNode: StepNode;
+                    }, xstate.EventObject>;
+                    id: string | undefined;
+                } ? T extends {
+                    src: TSrc;
+                } ? xstate.ConditionalRequired<[options?: ({
+                    id?: T["id"] | undefined;
+                    systemId?: string;
+                    input?: xstate.InputFrom<T["logic"]> | undefined;
+                    syncSnapshot?: boolean;
+                } & { [K in xstate.RequiredActorOptions<T>]: unknown; }) | undefined], xstate.IsNotNever<xstate.RequiredActorOptions<T>>> : never : never : never) | ({
+                    src: "resolverFunction";
+                    logic: xstate.PromiseActorLogic<{
+                        type: "STEP_FAILED";
+                        error: string;
+                        stepId: any;
+                        result?: undefined;
+                    } | {
+                        type: "STEP_WAITING";
+                        stepId: any;
+                        error?: undefined;
+                        result?: undefined;
+                    } | {
+                        type: "STEP_SUCCESS";
+                        result: any;
+                        stepId: any;
+                        error?: undefined;
+                    }, ResolverFunctionInput, xstate.EventObject>;
+                    id: string | undefined;
+                } extends infer T_1 ? T_1 extends {
+                    src: "resolverFunction";
+                    logic: xstate.PromiseActorLogic<{
+                        type: "STEP_FAILED";
+                        error: string;
+                        stepId: any;
+                        result?: undefined;
+                    } | {
+                        type: "STEP_WAITING";
+                        stepId: any;
+                        error?: undefined;
+                        result?: undefined;
+                    } | {
+                        type: "STEP_SUCCESS";
+                        result: any;
+                        stepId: any;
+                        error?: undefined;
+                    }, ResolverFunctionInput, xstate.EventObject>;
+                    id: string | undefined;
+                } ? T_1 extends {
+                    src: TSrc;
+                } ? xstate.ConditionalRequired<[options?: ({
+                    id?: T_1["id"] | undefined;
+                    systemId?: string;
+                    input?: xstate.InputFrom<T_1["logic"]> | undefined;
+                    syncSnapshot?: boolean;
+                } & { [K_1 in xstate.RequiredActorOptions<T_1>]: unknown; }) | undefined], xstate.IsNotNever<xstate.RequiredActorOptions<T_1>>> : never : never : never) | ({
+                    src: "spawnSubscriberFunction";
+                    logic: xstate.PromiseActorLogic<{
+                        steps: {};
+                    }, {
+                        parentStepId: string;
+                        context: WorkflowContext;
+                    }, xstate.EventObject>;
+                    id: string | undefined;
+                } extends infer T_2 ? T_2 extends {
+                    src: "spawnSubscriberFunction";
+                    logic: xstate.PromiseActorLogic<{
+                        steps: {};
+                    }, {
+                        parentStepId: string;
+                        context: WorkflowContext;
+                    }, xstate.EventObject>;
+                    id: string | undefined;
+                } ? T_2 extends {
+                    src: TSrc;
+                } ? xstate.ConditionalRequired<[options?: ({
+                    id?: T_2["id"] | undefined;
+                    systemId?: string;
+                    input?: xstate.InputFrom<T_2["logic"]> | undefined;
+                    syncSnapshot?: boolean;
+                } & { [K_2 in xstate.RequiredActorOptions<T_2>]: unknown; }) | undefined], xstate.IsNotNever<xstate.RequiredActorOptions<T_2>>> : never : never : never)): xstate.ActorRefFromLogic<xstate.GetConcreteByKey<xstate.Values<{
+                    conditionCheck: {
+                        src: "conditionCheck";
+                        logic: xstate.PromiseActorLogic<{
+                            type: "CONDITIONS_MET";
+                            error?: undefined;
+                        } | {
+                            type: "CONDITIONS_SKIP_TO_COMPLETED";
+                            error?: undefined;
+                        } | {
+                            type: "CONDITIONS_LIMBO";
+                            error?: undefined;
+                        } | {
+                            type: "CONDITIONS_SKIPPED";
+                            error?: undefined;
+                        } | {
+                            type: "CONDITION_FAILED";
+                            error: string;
+                        }, {
+                            context: WorkflowContext;
+                            stepNode: StepNode;
+                        }, xstate.EventObject>;
+                        id: string | undefined;
+                    };
+                    resolverFunction: {
+                        src: "resolverFunction";
+                        logic: xstate.PromiseActorLogic<{
+                            type: "STEP_FAILED";
+                            error: string;
+                            stepId: any;
+                            result?: undefined;
+                        } | {
+                            type: "STEP_WAITING";
+                            stepId: any;
+                            error?: undefined;
+                            result?: undefined;
+                        } | {
+                            type: "STEP_SUCCESS";
+                            result: any;
+                            stepId: any;
+                            error?: undefined;
+                        }, ResolverFunctionInput, xstate.EventObject>;
+                        id: string | undefined;
+                    };
+                    spawnSubscriberFunction: {
+                        src: "spawnSubscriberFunction";
+                        logic: xstate.PromiseActorLogic<{
+                            steps: {};
+                        }, {
+                            parentStepId: string;
+                            context: WorkflowContext;
+                        }, xstate.EventObject>;
+                        id: string | undefined;
+                    };
+                }>, "src", TSrc>["logic"]>;
+                <TLogic extends xstate.AnyActorLogic>(src: TLogic, ...[options]: xstate.ConditionalRequired<[options?: ({
+                    id?: never;
+                    systemId?: string;
+                    input?: xstate.InputFrom<TLogic> | undefined;
+                    syncSnapshot?: boolean;
+                } & { [K in xstate.RequiredLogicInput<TLogic>]: unknown; }) | undefined], xstate.IsNotNever<xstate.RequiredLogicInput<TLogic>>>): xstate.ActorRefFromLogic<TLogic>;
+            };
+            input: Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">;
+            self: xstate.ActorRef<xstate.MachineSnapshot<Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
+                type: "RESET_TO_PENDING";
+                stepId: string;
+            } | {
+                type: "CONDITIONS_MET";
+                stepId: string;
+            } | {
+                type: "CONDITION_FAILED";
+                stepId: string;
+                error: string;
+            } | {
+                type: "SUSPENDED";
+                stepId: string;
+                suspendPayload?: any;
+            } | {
+                type: "WAITING";
+                stepId: string;
+            } | {
+                type: `xstate.error.actor.${string}`;
+                error: Error;
+            } | {
+                type: `xstate.done.actor.${string}`;
+                output: ResolverFunctionOutput;
+            }, Record<string, xstate.AnyActorRef | undefined>, xstate.StateValue, string, unknown, any, any>, {
+                type: "RESET_TO_PENDING";
+                stepId: string;
+            } | {
+                type: "CONDITIONS_MET";
+                stepId: string;
+            } | {
+                type: "CONDITION_FAILED";
+                stepId: string;
+                error: string;
+            } | {
+                type: "SUSPENDED";
+                stepId: string;
+                suspendPayload?: any;
+            } | {
+                type: "WAITING";
+                stepId: string;
+            } | {
+                type: `xstate.error.actor.${string}`;
+                error: Error;
+            } | {
+                type: `xstate.done.actor.${string}`;
+                output: ResolverFunctionOutput;
+            }, xstate.AnyEventObject>;
+        }) => {
+            mastra?: MastraUnion | undefined;
+            steps: {
+                [x: string]: {
+                    status: "failed";
+                    error: string;
+                } | {
+                    status: "suspended";
+                    suspendPayload?: any;
+                } | {
+                    status: "waiting";
+                } | {
+                    status: "skipped";
+                } | {
+                    status: "success";
+                    output: unknown;
+                } | {
+                    status: "success";
+                    output: any;
+                };
+            };
+            triggerData: any;
+            inputData: Record<string, any>;
+            attempts: Record<string, number>;
+        };
+        readonly states: any;
+    }> | undefined;
+}
+
 interface WorkflowResultReturn<T extends z.ZodType<any>, TSteps extends Step<any, any, any>[]> {
     runId: string;
     start: (props?: {
         triggerData?: z.infer<T>;
     } | undefined) => Promise<WorkflowRunResult<T, TSteps>>;
+    watch: (onTransition: (state: WorkflowRunState) => void) => () => void;
+    resume: (props: {
+        stepId: string;
+        context?: Record<string, any>;
+    }) => Promise<Omit<WorkflowRunResult<T, TSteps>, 'runId'> | undefined>;
+    resumeWithEvent: (eventName: string, data: any) => Promise<Omit<WorkflowRunResult<T, TSteps>, 'runId'> | undefined>;
+}
+declare class WorkflowInstance<TSteps extends Step<any, any, any>[] = any, TTriggerSchema extends z.ZodObject<any> = any> implements WorkflowResultReturn<TTriggerSchema, TSteps> {
+    #private;
+    name: string;
+    logger: Logger;
+    events?: Record<string, {
+        schema: z.ZodObject<any>;
+    }>;
+    constructor({ name, logger, steps, runId, retryConfig, mastra, stepGraph, stepSubscriberGraph, onFinish, onStepTransition, events, }: {
+        name: string;
+        logger: Logger;
+        steps: Record<string, StepAction<any, any, any, any>>;
+        mastra?: Mastra;
+        retryConfig?: RetryConfig;
+        runId?: string;
+        stepGraph: StepGraph;
+        stepSubscriberGraph: Record<string, StepGraph>;
+        onFinish?: () => void;
+        onStepTransition?: Set<(state: WorkflowRunState) => void | Promise<void>>;
+        events?: Record<string, {
+            schema: z.ZodObject<any>;
+        }>;
+    });
+    setState(state: any): void;
+    get runId(): string;
+    get executionSpan(): Span | undefined;
+    watch(onTransition: (state: WorkflowRunState) => void): () => void;
+    start({ triggerData }?: {
+        triggerData?: z.infer<TTriggerSchema>;
+    }): Promise<{
+        runId: string;
+        triggerData?: z.TypeOf<TTriggerSchema> | undefined;
+        results: { [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]["outputSchema"] extends undefined ? StepResult<unknown> : StepResult<z.TypeOf<NonNullable<StepsRecord<TSteps>[K]["outputSchema"]>>>; };
+        activePaths: Map<TSteps[number]["id"], {
+            status: string;
+            suspendPayload?: any;
+        }>;
+    }>;
+    private isCompoundDependencyMet;
+    execute({ triggerData, snapshot, stepId, resumeData, }?: {
+        stepId?: string;
+        triggerData?: z.infer<TTriggerSchema>;
+        snapshot?: Snapshot<any>;
+        resumeData?: any;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, 'runId'>>;
+    hasSubscribers(stepId: string): boolean;
+    runMachine(parentStepId: string, input: any): Promise<(Pick<WorkflowRunResult<any, any>, "results" | "activePaths"> | undefined)[]>;
+    suspend(stepId: string, machine: Machine<TSteps, TTriggerSchema>): Promise<void>;
+    /**
+     * Persists the workflow state to the database
+     */
+    persistWorkflowSnapshot(): Promise<void>;
+    getState(): Promise<WorkflowRunState | null>;
+    resumeWithEvent(eventName: string, data: any): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
+    resume({ stepId, context: resumeContext }: {
+        stepId: string;
+        context?: Record<string, any>;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
+    _resume({ stepId, context: resumeContext }: {
+        stepId: string;
+        context?: Record<string, any>;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
 }
 
 declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TTriggerSchema extends z.ZodObject<any> = any> extends MastraBase {
@@ -561,7 +1006,18 @@ declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, an
      * @returns Promise resolving to workflow results or rejecting with error
      * @throws Error if trigger schema validation fails
      */
-    createRun(): WorkflowResultReturn<TTriggerSchema, TSteps>;
+    createRun({ runId, events, }?: {
+        runId?: string;
+        events?: Record<string, {
+            schema: z.ZodObject<any>;
+        }>;
+    }): WorkflowResultReturn<TTriggerSchema, TSteps>;
+    /**
+     * Gets a workflow run instance by ID
+     * @param runId - ID of the run to retrieve
+     * @returns The workflow run instance if found, undefined otherwise
+     */
+    getRun(runId: string): WorkflowInstance<TSteps, TTriggerSchema> | undefined;
     /**
      * Rebuilds the machine with the current steps configuration and validates the workflow
      *
@@ -573,22 +1029,19 @@ declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, an
     commit(): this;
     getExecutionSpan(runId: string): Span | undefined;
     getState(runId: string): Promise<WorkflowRunState | null>;
-    watch(onTransition: (state: WorkflowRunState) => void): () => void;
     resume({ runId, stepId, context: resumeContext, }: {
         runId: string;
         stepId: string;
         context?: Record<string, any>;
     }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
-    _resume({ runId, stepId, context: resumeContext, }: {
-        runId: string;
-        stepId: string;
-        context?: Record<string, any>;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
+    watch(onTransition: (state: WorkflowRunState) => void): () => void;
     resumeWithEvent(runId: string, eventName: string, data: any): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
     __registerMastra(mastra: Mastra): void;
     __registerPrimitives(p: MastraPrimitives): void;
     get stepGraph(): StepGraph;
     get stepSubscriberGraph(): Record<string, StepGraph>;
+    get serializedStepGraph(): StepGraph;
+    get serializedStepSubscriberGraph(): Record<string, StepGraph>;
     get steps(): Record<string, StepAction<any, any, any, any>>;
 }