@mastra/core 0.4.2 → 0.4.3-alpha.1

package/dist/{chunk-XVS6QFTX.js → chunk-B3M27AMP.js}

@@ -1,8 +1,10 @@
 import { MastraBase } from './chunk-OZ4XVJ6F.js';
+import { setTimeout } from 'node:timers/promises';
 import { context, trace } from '@opentelemetry/api';
+import EventEmitter from 'node:events';
 import { get } from 'radash';
 import sift from 'sift';
-import { setup, createActor, assign, fromPromise } from 'xstate';
+import { createActor, assign, fromPromise, setup } from 'xstate';
 
 // src/workflows/utils.ts
 function isErrorEvent(stateEvent) {
@@ -18,185 +20,144 @@ function getStepResult(result) {
   if (result?.status === "success") return result.output;
   return void 0;
 }
-
-// src/workflows/workflow.ts
-var Workflow = class extends MastraBase {
-  name;
-  triggerSchema;
-  /** XState machine instance that orchestrates the workflow execution */
-  #machine;
-  /** XState actor instance that manages the workflow execution */
-  #actor = null;
-  #runId;
-  #retryConfig;
-  #mastra;
-  // registers stepIds on `after` calls
-  #afterStepStack = [];
-  #lastStepStack = [];
-  #stepGraph = { initial: [] };
-  #stepSubscriberGraph = {};
-  #steps = {};
-  #onStepTransition = /* @__PURE__ */ new Set();
-  #executionSpan;
-  /**
-   * Creates a new Workflow instance
-   * @param name - Identifier for the workflow (not necessarily unique)
-   * @param logger - Optional logger instance
-   */
-  constructor({ name, triggerSchema, retryConfig, mastra }) {
-    super({ component: "WORKFLOW", name });
-    this.name = name;
-    this.#retryConfig = retryConfig;
-    this.triggerSchema = triggerSchema;
-    this.#runId = crypto.randomUUID();
-    this.#mastra = mastra;
-    if (mastra?.logger) {
-      this.logger = mastra?.logger;
+function getSuspendedPaths({
+  value,
+  path,
+  suspendedPaths
+}) {
+  if (typeof value === "string") {
+    if (value === "suspended") {
+      suspendedPaths.add(path);
     }
-    this.initializeMachine();
+  } else {
+    Object.keys(value).forEach(
+      (key) => getSuspendedPaths({ value: value[key], path: path ? `${path}.${key}` : key, suspendedPaths })
+    );
   }
-  /**
-   * Initializes the XState machine for the workflow
-   *
-   * Registers the machine's types, actions, actors, initial context, entry actions, initial state, and states
-   * @returns The initialized machine
-   */
-  initializeMachine() {
-    const machine = setup({
-      types: {},
-      delays: this.#makeDelayMap(),
-      actions: this.#getDefaultActions(),
-      actors: this.#getDefaultActors()
-    }).createMachine({
-      id: this.name,
-      type: "parallel",
-      context: ({ input }) => ({
-        ...input
-      }),
-      states: this.#buildStateHierarchy(this.#stepGraph)
-    });
-    this.#machine = machine;
-    return machine;
+}
+function isFinalState(status) {
+  return ["completed", "failed"].includes(status);
+}
+function recursivelyCheckForFinalState({
+  value,
+  suspendedPaths,
+  path
+}) {
+  if (typeof value === "string") {
+    return isFinalState(value) || suspendedPaths.has(path);
   }
-  step(step, config) {
-    const { variables = {} } = config || {};
-    const requiredData = {};
-    for (const [key, variable] of Object.entries(variables)) {
-      if (variable && isVariableReference(variable)) {
-        requiredData[key] = variable;
-      }
-    }
-    const stepKey = this.#makeStepKey(step);
-    const graphEntry = {
-      step,
-      config: {
-        ...this.#makeStepDef(stepKey),
-        ...config,
-        data: requiredData
-      }
-    };
-    this.#steps[stepKey] = step;
-    const parentStepKey = this.#afterStepStack[this.#afterStepStack.length - 1];
-    const stepGraph = this.#stepSubscriberGraph[parentStepKey || ""];
-    if (parentStepKey && stepGraph) {
-      if (!stepGraph.initial.some((step2) => step2.step.id === stepKey)) {
-        stepGraph.initial.push(graphEntry);
+  return Object.keys(value).every(
+    (key) => recursivelyCheckForFinalState({ value: value[key], suspendedPaths, path: path ? `${path}.${key}` : key })
+  );
+}
+function getActivePathsAndStatus(value) {
+  const paths = [];
+  const traverse = (current, path = []) => {
+    for (const [key, value2] of Object.entries(current)) {
+      const currentPath = [...path, key];
+      if (typeof value2 === "string") {
+        paths.push({
+          stepPath: currentPath,
+          stepId: key,
+          status: value2
+        });
+      } else if (typeof value2 === "object" && value2 !== null) {
+        traverse(value2, currentPath);
       }
-      stepGraph[stepKey] = [];
-    } else {
-      if (!this.#stepGraph[stepKey]) this.#stepGraph[stepKey] = [];
-      this.#stepGraph.initial.push(graphEntry);
     }
-    this.#lastStepStack.push(stepKey);
-    return this;
-  }
-  then(step, config) {
-    const { variables = {} } = config || {};
-    const requiredData = {};
-    for (const [key, variable] of Object.entries(variables)) {
-      if (variable && isVariableReference(variable)) {
-        requiredData[key] = variable;
+  };
+  traverse(value);
+  return paths;
+}
+function mergeChildValue(startStepId, parent, child) {
+  const traverse = (current) => {
+    const obj = {};
+    for (const [key, value] of Object.entries(current)) {
+      if (key === startStepId) {
+        obj[key] = { ...child };
+      } else if (typeof value === "string") {
+        obj[key] = value;
+      } else if (typeof value === "object" && value !== null) {
+        obj[key] = traverse(value);
       }
     }
-    const lastStepKey = this.#lastStepStack[this.#lastStepStack.length - 1];
-    const stepKey = this.#makeStepKey(step);
-    const graphEntry = {
-      step,
-      config: {
-        ...this.#makeStepDef(stepKey),
-        ...config,
-        data: requiredData
-      }
-    };
-    this.#steps[stepKey] = step;
-    if (!lastStepKey) return this;
-    const parentStepKey = this.#afterStepStack[this.#afterStepStack.length - 1];
-    const stepGraph = this.#stepSubscriberGraph[parentStepKey || ""];
-    if (parentStepKey && stepGraph && stepGraph[lastStepKey]) {
-      stepGraph[lastStepKey].push(graphEntry);
+    return obj;
+  };
+  return traverse(parent);
+}
+var updateStepInHierarchy = (value, targetStepId) => {
+  const result = {};
+  for (const key of Object.keys(value)) {
+    const currentValue = value[key];
+    if (key === targetStepId) {
+      result[key] = "pending";
+    } else if (typeof currentValue === "object" && currentValue !== null) {
+      result[key] = updateStepInHierarchy(currentValue, targetStepId);
     } else {
-      if (!this.#stepGraph[lastStepKey]) this.#stepGraph[lastStepKey] = [];
-      this.#stepGraph[lastStepKey].push(graphEntry);
+      result[key] = currentValue;
     }
-    return this;
-  }
-  after(step) {
-    const stepKey = this.#makeStepKey(step);
-    this.#afterStepStack.push(stepKey);
-    if (!this.#stepSubscriberGraph[stepKey]) {
-      this.#stepSubscriberGraph[stepKey] = { initial: [] };
-    }
-    return this;
   }
-  /**
-   * Executes the workflow with the given trigger data
-   * @param triggerData - Initial data to start the workflow with
-   * @returns Promise resolving to workflow results or rejecting with error
-   * @throws Error if trigger schema validation fails
-   */
-  createRun() {
-    const runId = crypto.randomUUID();
+  return result;
+};
+var Machine = class extends EventEmitter {
+  logger;
+  #mastra;
+  #workflowInstance;
+  #executionSpan;
+  #stepGraph;
+  #machine;
+  #runId;
+  #startStepId;
+  name;
+  #actor = null;
+  #steps = {};
+  #retryConfig;
+  constructor({
+    logger,
+    mastra,
+    workflowInstance,
+    executionSpan,
+    name,
+    runId,
+    steps,
+    stepGraph,
+    retryConfig,
+    startStepId
+  }) {
+    super();
+    this.#mastra = mastra;
+    this.#workflowInstance = workflowInstance;
+    this.#executionSpan = executionSpan;
+    this.logger = logger;
     this.#runId = runId;
-    return {
-      runId,
-      start: async ({ triggerData } = {}) => this.execute({ triggerData })
-    };
+    this.#startStepId = startStepId;
+    this.name = name;
+    this.#stepGraph = stepGraph;
+    this.#steps = steps;
+    this.#retryConfig = retryConfig;
+    this.initializeMachine();
+  }
+  get startStepId() {
+    return this.#startStepId;
   }
   async execute({
-    triggerData,
-    snapshot,
-    runId,
-    stepId
+    stepId,
+    input,
+    snapshot
   } = {}) {
-    if (runId) {
-      this.#runId = runId;
+    if (snapshot) {
       this.logger.debug(`Workflow snapshot received`, { runId: this.#runId, snapshot });
     }
-    this.#executionSpan = this.#mastra?.telemetry?.tracer.startSpan(`workflow.${this.name}.execute`, {
-      attributes: { componentName: this.name, runId: this.#runId }
-    });
-    const machineInput = snapshot ? snapshot.context : {
-      // Maintain the original step results and their output
-      steps: {},
-      triggerData: triggerData || {},
-      attempts: Object.keys(this.#steps).reduce(
-        (acc, stepKey) => {
-          acc[stepKey] = this.#steps[stepKey]?.retryConfig?.attempts || this.#retryConfig?.attempts || 3;
-          return acc;
-        },
-        {}
-      )
-    };
-    this.logger.debug(`Machine input prepared`, { runId: this.#runId, machineInput });
+    this.logger.debug(`Machine input prepared`, { runId: this.#runId, input });
     const actorSnapshot = snapshot ? {
       ...snapshot,
-      context: machineInput
+      context: input
     } : void 0;
     this.logger.debug(`Creating actor with configuration`, {
-      machineInput,
+      input,
       actorSnapshot,
-      machineStates: this.#machine.config.states,
-      runId: this.#runId
+      runId: this.#runId,
+      machineStates: this.#machine.config.states
     });
     this.#actor = createActor(this.#machine, {
       inspect: (inspectionEvent) => {
@@ -206,7 +167,7 @@ var Workflow = class extends MastraBase {
           runId: this.#runId
         });
       },
-      input: machineInput,
+      input,
       snapshot: actorSnapshot
     });
     this.#actor.start();
@@ -224,25 +185,14 @@ var Workflow = class extends MastraBase {
       }
       const suspendedPaths = /* @__PURE__ */ new Set();
       this.#actor.subscribe(async (state) => {
-        if (this.#onStepTransition) {
-          this.#onStepTransition.forEach((onTransition) => {
-            onTransition({
-              runId: this.#runId,
-              value: state.value,
-              context: state.context,
-              activePaths: this.#getActivePathsAndStatus(state.value),
-              timestamp: Date.now()
-            })?.catch(() => {
-            });
-          });
-        }
-        this.#getSuspendedPaths({
+        this.emit("state-update", this.#startStepId, state.value, state.context);
+        getSuspendedPaths({
           value: state.value,
           path: "",
           suspendedPaths
         });
         const allStatesValue = state.value;
-        const allStatesComplete = this.#recursivelyCheckForFinalState({
+        const allStatesComplete = recursivelyCheckForFinalState({
           value: allStatesValue,
           suspendedPaths,
           path: ""
@@ -254,86 +204,298 @@ var Workflow = class extends MastraBase {
         });
         if (!allStatesComplete) return;
         try {
-          await this.#persistWorkflowSnapshot();
+          await this.#workflowInstance.persistWorkflowSnapshot();
           this.#cleanup();
           this.#executionSpan?.end();
           resolve({
-            triggerData,
-            results: state.context.steps,
-            runId: this.#runId
+            results: state.context.steps
           });
         } catch (error) {
           this.logger.debug("Failed to persist final snapshot", { error });
           this.#cleanup();
           this.#executionSpan?.end();
           resolve({
-            triggerData,
-            results: state.context.steps,
-            runId: this.#runId
+            results: state.context.steps
           });
         }
       });
     });
   }
-  /**
-   * Rebuilds the machine with the current steps configuration and validates the workflow
-   *
-   * This is the last step of a workflow builder method chain
-   * @throws Error if validation fails
-   *
-   * @returns this instance for method chaining
-   */
-  commit() {
-    this.initializeMachine();
-    return this;
-  }
-  // record all object paths that leads to a suspended state
-  #getSuspendedPaths({
-    value,
-    path,
-    suspendedPaths
-  }) {
-    if (typeof value === "string") {
-      if (value === "suspended") {
-        suspendedPaths.add(path);
-      }
-    } else {
-      Object.keys(value).forEach(
-        (key) => this.#getSuspendedPaths({ value: value[key], path: path ? `${path}.${key}` : key, suspendedPaths })
-      );
+  #cleanup() {
+    if (this.#actor) {
+      this.#actor.stop();
+      this.#actor = null;
     }
+    this.removeAllListeners();
   }
-  #isFinalState(status) {
-    return ["completed", "failed"].includes(status);
-  }
-  #recursivelyCheckForFinalState({
-    value,
-    suspendedPaths,
-    path
-  }) {
-    if (typeof value === "string") {
-      return this.#isFinalState(value) || suspendedPaths.has(path);
-    }
-    return Object.keys(value).every(
-      (key) => this.#recursivelyCheckForFinalState({ value: value[key], suspendedPaths, path: path ? `${path}.${key}` : key })
-    );
+  #makeDelayMap() {
+    const delayMap = {};
+    Object.keys(this.#steps).forEach((stepId) => {
+      delayMap[stepId] = this.#steps[stepId]?.retryConfig?.delay || this.#retryConfig?.delay || 1e3;
+    });
+    return delayMap;
   }
-  #buildBaseState(stepNode, nextSteps = []) {
-    const nextStep = nextSteps.shift();
+  #getDefaultActions() {
     return {
-      initial: "pending",
-      on: {
-        RESET_TO_PENDING: {
-          target: ".pending"
-          // Note the dot to target child state
+      updateStepResult: assign({
+        steps: ({ context, event }) => {
+          if (!isTransitionEvent(event)) return context.steps;
+          const { stepId, result } = event.output;
+          return {
+            ...context.steps,
+            [stepId]: {
+              status: "success",
+              output: result
+            }
+          };
+        }
+      }),
+      setStepError: assign({
+        steps: ({ context, event }, params) => {
+          if (!isErrorEvent(event)) return context.steps;
+          const { stepId } = params;
+          if (!stepId) return context.steps;
+          return {
+            ...context.steps,
+            [stepId]: {
+              status: "failed",
+              error: event.error.message
+            }
+          };
         }
+      }),
+      notifyStepCompletion: async (_, params) => {
+        const { stepId } = params;
+        this.logger.debug(`Step ${stepId} completed`);
       },
-      states: {
-        pending: {
-          entry: () => {
-            this.logger.debug(`Step ${stepNode.step.id} pending`, {
-              stepId: stepNode.step.id,
-              runId: this.#runId
+      snapshotStep: assign({
+        _snapshot: ({}, params) => {
+          const { stepId } = params;
+          return { stepId };
+        }
+      }),
+      persistSnapshot: async ({ context }) => {
+        if (context._snapshot) {
+          await this.#workflowInstance.persistWorkflowSnapshot();
+        }
+        return;
+      },
+      decrementAttemptCount: assign({
+        attempts: ({ context, event }, params) => {
+          if (!isTransitionEvent(event)) return context.attempts;
+          const { stepId } = params;
+          const attemptCount = context.attempts[stepId];
+          if (attemptCount === void 0) return context.attempts;
+          return { ...context.attempts, [stepId]: attemptCount - 1 };
+        }
+      })
+    };
+  }
+  #getDefaultActors() {
+    return {
+      resolverFunction: fromPromise(async ({ input }) => {
+        const { stepNode, context } = input;
+        const resolvedData = this.#resolveVariables({
+          stepConfig: stepNode.config,
+          context,
+          stepId: stepNode.step.id
+        });
+        this.logger.debug(`Resolved variables for ${stepNode.step.id}`, {
+          resolvedData,
+          runId: this.#runId
+        });
+        const result = await stepNode.config.handler({
+          context: resolvedData,
+          suspend: async () => {
+            await this.#workflowInstance.suspend(stepNode.step.id, this);
+            if (this.#actor) {
+              context.steps[stepNode.step.id] = {
+                status: "suspended"
+              };
+              this.logger.debug(`Sending SUSPENDED event for step ${stepNode.step.id}`);
+              this.#actor?.send({ type: "SUSPENDED", stepId: stepNode.step.id });
+            } else {
+              this.logger.debug(`Actor not available for step ${stepNode.step.id}`);
+            }
+          },
+          runId: this.#runId,
+          mastra: this.#mastra
+        });
+        this.logger.debug(`Step ${stepNode.step.id} result`, {
+          stepId: stepNode.step.id,
+          result,
+          runId: this.#runId
+        });
+        return {
+          stepId: stepNode.step.id,
+          result
+        };
+      }),
+      conditionCheck: fromPromise(async ({ input }) => {
+        const { context, stepNode } = input;
+        const stepConfig = stepNode.config;
+        const attemptCount = context.attempts[stepNode.step.id];
+        this.logger.debug(`Checking conditions for step ${stepNode.step.id}`, {
+          stepId: stepNode.step.id,
+          runId: this.#runId
+        });
+        this.logger.debug(`Attempt count for step ${stepNode.step.id}`, {
+          attemptCount,
+          attempts: context.attempts,
+          runId: this.#runId,
+          stepId: stepNode.step.id
+        });
+        if (!attemptCount || attemptCount < 0) {
+          if (stepConfig?.snapshotOnTimeout) {
+            return { type: "SUSPENDED", stepId: stepNode.step.id };
+          }
+          return { type: "CONDITION_FAILED", error: `Step:${stepNode.step.id} condition check failed` };
+        }
+        if (!stepConfig?.when) {
+          return { type: "CONDITIONS_MET" };
+        }
+        this.logger.debug(`Checking conditions for step ${stepNode.step.id}`, {
+          stepId: stepNode.step.id,
+          runId: this.#runId
+        });
+        if (typeof stepConfig?.when === "function") {
+          const conditionMet = await stepConfig.when({
+            context: {
+              ...context,
+              getStepResult: (stepId) => {
+                if (stepId === "trigger") {
+                  return context.triggerData;
+                }
+                const result = context.steps[stepId];
+                if (result && result.status === "success") {
+                  return result.output;
+                }
+                return void 0;
+              }
+            },
+            mastra: this.#mastra
+          });
+          if (conditionMet) {
+            this.logger.debug(`Condition met for step ${stepNode.step.id}`, {
+              stepId: stepNode.step.id,
+              runId: this.#runId
+            });
+            return { type: "CONDITIONS_MET" };
+          }
+          if (!attemptCount || attemptCount < 0) {
+            return { type: "CONDITION_FAILED", error: `Step:${stepNode.step.id} condition check failed` };
+          }
+          return { type: "WAITING", stepId: stepNode.step.id };
+        } else {
+          const conditionMet = this.#evaluateCondition(stepConfig.when, context);
+          if (!conditionMet) {
+            return {
+              type: "CONDITION_FAILED",
+              error: `Step:${stepNode.step.id} condition check failed`
+            };
+          }
+        }
+        return { type: "CONDITIONS_MET" };
+      }),
+      spawnSubscriberFunction: fromPromise(
+        async ({
+          input
+        }) => {
+          const { parentStepId, context } = input;
+          const result = await this.#workflowInstance.runMachine(parentStepId, context);
+          return Promise.resolve({ steps: result?.results });
+        }
+      )
+    };
+  }
+  #resolveVariables({
+    stepConfig,
+    context,
+    stepId
+  }) {
+    this.logger.debug(`Resolving variables for step ${stepId}`, {
+      stepId,
+      runId: this.#runId
+    });
+    const resolvedData = {
+      ...context,
+      getStepResult: (stepId2) => {
+        if (stepId2 === "trigger") {
+          return context.triggerData;
+        }
+        const result = context.steps[stepId2];
+        if (result && result.status === "success") {
+          return result.output;
+        }
+        return void 0;
+      }
+    };
+    for (const [key, variable] of Object.entries(stepConfig.data)) {
+      const sourceData = variable.step === "trigger" ? context.triggerData : getStepResult(context.steps[variable.step.id]);
+      this.logger.debug(
+        `Got source data for ${key} variable from ${variable.step === "trigger" ? "trigger" : variable.step.id}`,
+        {
+          sourceData,
+          path: variable.path,
+          runId: this.#runId
+        }
+      );
+      if (!sourceData && variable.step !== "trigger") {
+        resolvedData[key] = void 0;
+        continue;
+      }
+      const value = variable.path === "" || variable.path === "." ? sourceData : get(sourceData, variable.path);
+      this.logger.debug(`Resolved variable ${key}`, {
+        value,
+        runId: this.#runId
+      });
+      resolvedData[key] = value;
+    }
+    return resolvedData;
+  }
+  initializeMachine() {
+    const machine = setup({
+      types: {},
+      delays: this.#makeDelayMap(),
+      actions: this.#getDefaultActions(),
+      actors: this.#getDefaultActors()
+    }).createMachine({
+      id: this.name,
+      type: "parallel",
+      context: ({ input }) => ({
+        ...input
+      }),
+      states: this.#buildStateHierarchy(this.#stepGraph)
+    });
+    this.#machine = machine;
+    return machine;
+  }
+  #buildStateHierarchy(stepGraph) {
+    const states = {};
+    stepGraph.initial.forEach((stepNode) => {
+      const nextSteps = [...stepGraph[stepNode.step.id] || []];
+      states[stepNode.step.id] = {
+        ...this.#buildBaseState(stepNode, nextSteps)
+      };
+    });
+    return states;
+  }
+  #buildBaseState(stepNode, nextSteps = []) {
+    const nextStep = nextSteps.shift();
+    return {
+      initial: "pending",
+      on: {
+        RESET_TO_PENDING: {
+          target: ".pending"
+          // Note the dot to target child state
+        }
+      },
+      states: {
+        pending: {
+          entry: () => {
+            this.logger.debug(`Step ${stepNode.step.id} pending`, {
+              stepId: stepNode.step.id,
+              runId: this.#runId
             });
           },
           exit: () => {
@@ -466,30 +628,6 @@ var Workflow = class extends MastraBase {
               })
             })
           ]
-          // after: {
-          //   [stepNode.step.id]: {
-          //     target: 'pending',
-          //     actions: [
-          //       assign({
-          //         attempts: ({ context }: { context: WorkflowContext }) => ({
-          //           ...context.attempts,
-          //           [stepNode.step.id]: this.#steps[stepNode.step.id]?.retryConfig?.attempts || 3,
-          //         }),
-          //       }),
-          //     ],
-          //   }
-          // },
-          // entry: () => {
-          //   this.logger.debug(`Step ${stepNode.step.id} suspended ${new Date().toISOString()}`);
-          // },
-          // exit: () => {
-          //   this.logger.debug(`Step ${stepNode.step.id} finished suspended ${new Date().toISOString()}`);
-          // },
-          // after: {
-          //   [stepNode.step.id]: {
-          //     target: 'suspended',
-          //   },
-          // },
         },
         executing: {
           entry: () => {
@@ -600,400 +738,530 @@ var Workflow = class extends MastraBase {
       }
     };
   }
-  #makeStepKey(step) {
-    return `${step.id}`;
-  }
-  /**
-   * Builds the state hierarchy for the workflow
-   * @returns Object representing the state hierarchy
-   */
-  #buildStateHierarchy(stepGraph) {
-    const states = {};
-    stepGraph.initial.forEach((stepNode) => {
-      const nextSteps = [...stepGraph[stepNode.step.id] || []];
-      states[stepNode.step.id] = {
-        ...this.#buildBaseState(stepNode, nextSteps)
-      };
-    });
-    return states;
-  }
-  #getDefaultActions() {
-    return {
-      updateStepResult: assign({
-        steps: ({ context, event }) => {
-          if (!isTransitionEvent(event)) return context.steps;
-          const { stepId, result } = event.output;
-          return {
-            ...context.steps,
-            [stepId]: {
-              status: "success",
-              output: result
-            }
-          };
-        }
-      }),
-      setStepError: assign({
-        steps: ({ context, event }, params) => {
-          if (!isErrorEvent(event)) return context.steps;
-          const { stepId } = params;
-          if (!stepId) return context.steps;
-          return {
-            ...context.steps,
-            [stepId]: {
-              status: "failed",
-              error: event.error.message
-            }
-          };
-        }
-      }),
-      notifyStepCompletion: async (_, params) => {
-        const { stepId } = params;
-        this.logger.debug(`Step ${stepId} completed`);
-      },
-      snapshotStep: assign({
-        _snapshot: ({}, params) => {
-          const { stepId } = params;
-          return { stepId };
-        }
-      }),
-      persistSnapshot: async ({ context }) => {
-        if (context._snapshot) {
-          return await this.#persistWorkflowSnapshot();
-        }
-        return;
-      },
-      decrementAttemptCount: assign({
-        attempts: ({ context, event }, params) => {
-          if (!isTransitionEvent(event)) return context.attempts;
-          const { stepId } = params;
-          const attemptCount = context.attempts[stepId];
-          if (attemptCount === void 0) return context.attempts;
-          return { ...context.attempts, [stepId]: attemptCount - 1 };
-        }
-      })
-    };
+  #evaluateCondition(condition, context) {
+    let andBranchResult = true;
+    let baseResult = true;
+    let orBranchResult = true;
+    const simpleCondition = Object.entries(condition).find(([key]) => key.includes("."));
+    if (simpleCondition) {
+      const [key, queryValue] = simpleCondition;
+      const [stepId, ...pathParts] = key.split(".");
+      const path = pathParts.join(".");
+      const sourceData = stepId === "trigger" ? context.triggerData : getStepResult(context.steps[stepId]);
+      this.logger.debug(`Got condition data from step ${stepId}`, {
+        stepId,
+        sourceData,
+        runId: this.#runId
+      });
+      if (!sourceData) {
+        return false;
+      }
+      let value = get(sourceData, path);
+      if (stepId !== "trigger" && path === "status" && !value) {
+        value = "success";
+      }
+      if (typeof queryValue === "object" && queryValue !== null) {
+        baseResult = sift(queryValue)(value);
+      } else {
+        baseResult = value === queryValue;
+      }
+    }
+    if ("ref" in condition) {
+      const { ref, query } = condition;
+      const sourceData = ref.step === "trigger" ? context.triggerData : getStepResult(context.steps[ref.step.id]);
+      this.logger.debug(`Got condition data from ${ref.step === "trigger" ? "trigger" : ref.step.id}`, {
+        sourceData,
+        runId: this.#runId
+      });
+      if (!sourceData) {
+        return false;
+      }
+      let value = get(sourceData, ref.path);
+      if (ref.step !== "trigger" && ref.path === "status" && !value) {
+        value = "success";
+      }
+      baseResult = sift(query)(value);
+    }
+    if ("and" in condition) {
+      andBranchResult = condition.and.every((cond) => this.#evaluateCondition(cond, context));
+      this.logger.debug(`Evaluated AND condition`, {
+        andBranchResult,
+        runId: this.#runId
+      });
+    }
+    if ("or" in condition) {
+      orBranchResult = condition.or.some((cond) => this.#evaluateCondition(cond, context));
+      this.logger.debug(`Evaluated OR condition`, {
+        orBranchResult,
+        runId: this.#runId
+      });
+    }
+    const finalResult = baseResult && andBranchResult && orBranchResult;
+    this.logger.debug(`Evaluated condition`, {
+      finalResult,
+      runId: this.#runId
+    });
+    return finalResult;
+  }
+  getSnapshot() {
+    const snapshot = this.#actor?.getSnapshot();
+    return snapshot;
   }
-  #getInjectables() {
+};
+
+// src/workflows/workflow-instance.ts
+var WorkflowInstance = class {
+  name;
+  #mastra;
+  #machines = {};
+  logger;
+  #steps = {};
+  #stepGraph;
+  #stepSubscriberGraph = {};
+  #retryConfig;
+  #runId;
+  #state = null;
+  #executionSpan;
+  #onStepTransition = /* @__PURE__ */ new Set();
+  #onFinish;
+  // indexed by stepId
+  #suspendedMachines = {};
+  constructor({
+    name,
+    logger,
+    steps,
+    runId,
+    retryConfig,
+    mastra,
+    stepGraph,
+    stepSubscriberGraph,
+    onStepTransition,
+    onFinish
+  }) {
+    this.name = name;
+    this.logger = logger;
+    this.#steps = steps;
+    this.#stepGraph = stepGraph;
+    this.#stepSubscriberGraph = stepSubscriberGraph;
+    this.#retryConfig = retryConfig;
+    this.#mastra = mastra;
+    this.#runId = runId ?? crypto.randomUUID();
+    this.#onStepTransition = onStepTransition;
+    this.#onFinish = onFinish;
+  }
+  setState(state) {
+    this.#state = state;
+  }
+  get runId() {
+    return this.#runId;
+  }
+  get executionSpan() {
+    return this.#executionSpan;
+  }
+  async start({ triggerData } = {}) {
+    const results = await this.execute({ triggerData });
+    if (this.#onFinish) {
+      this.#onFinish();
+    }
     return {
-      runId: this.#runId,
-      mastra: this.#mastra
+      ...results,
+      runId: this.runId
     };
   }
-  #getDefaultActors() {
-    return {
-      resolverFunction: fromPromise(async ({ input }) => {
-        const { stepNode, context } = input;
-        const injectables = this.#getInjectables();
-        const resolvedData = this.#resolveVariables({
-          stepConfig: stepNode.config,
-          context,
-          stepId: stepNode.step.id
-        });
-        this.logger.debug(`Resolved variables for ${stepNode.step.id}`, {
-          resolvedData,
-          runId: this.#runId
-        });
-        const result = await stepNode.config.handler({
-          context: resolvedData,
-          suspend: async () => {
-            if (this.#actor) {
-              context.steps[stepNode.step.id] = {
-                status: "suspended"
-              };
-              await this.#persistWorkflowSnapshot();
-              this.logger.debug(`Sending SUSPENDED event for step ${stepNode.step.id}`);
-              this.#actor?.send({ type: "SUSPENDED", stepId: stepNode.step.id });
-            } else {
-              this.logger.debug(`Actor not available for step ${stepNode.step.id}`);
-            }
-          },
-          ...injectables
-        });
-        this.logger.debug(`Step ${stepNode.step.id} result`, {
-          stepId: stepNode.step.id,
-          result,
-          runId: this.#runId
-        });
-        return {
-          stepId: stepNode.step.id,
-          result
-        };
-      }),
-      conditionCheck: fromPromise(async ({ input }) => {
-        const { context, stepNode } = input;
-        const stepConfig = stepNode.config;
-        const attemptCount = context.attempts[stepNode.step.id];
-        this.logger.debug(`Checking conditions for step ${stepNode.step.id}`, {
-          stepId: stepNode.step.id,
-          runId: this.#runId
-        });
-        this.logger.debug(`Attempt count for step ${stepNode.step.id}`, {
-          attemptCount,
-          attempts: context.attempts,
-          runId: this.#runId,
-          stepId: stepNode.step.id
-        });
-        if (!attemptCount || attemptCount < 0) {
-          if (stepConfig?.snapshotOnTimeout) {
-            return { type: "SUSPENDED", stepId: stepNode.step.id };
-          }
-          return { type: "CONDITION_FAILED", error: `Step:${stepNode.step.id} condition check failed` };
-        }
-        if (!stepConfig?.when) {
-          return { type: "CONDITIONS_MET" };
-        }
-        this.logger.debug(`Checking conditions for step ${stepNode.step.id}`, {
-          stepId: stepNode.step.id,
-          runId: this.#runId
-        });
-        if (typeof stepConfig?.when === "function") {
-          const conditionMet = await stepConfig.when({
-            context: {
-              ...context,
-              getStepResult: (stepId) => {
-                if (stepId === "trigger") {
-                  return context.triggerData;
-                }
-                const result = context.steps[stepId];
-                if (result && result.status === "success") {
-                  return result.output;
-                }
-                return void 0;
-              }
-            },
-            ...this.#getInjectables()
-          });
-          if (conditionMet) {
-            this.logger.debug(`Condition met for step ${stepNode.step.id}`, {
-              stepId: stepNode.step.id,
-              runId: this.#runId
-            });
-            return { type: "CONDITIONS_MET" };
-          }
-          if (!attemptCount || attemptCount < 0) {
-            return { type: "CONDITION_FAILED", error: `Step:${stepNode.step.id} condition check failed` };
-          }
-          return { type: "WAITING", stepId: stepNode.step.id };
-        } else {
-          const conditionMet = this.#evaluateCondition(stepConfig.when, context);
-          if (!conditionMet) {
-            return {
-              type: "CONDITION_FAILED",
-              error: `Step:${stepNode.step.id} condition check failed`
-            };
-          }
-        }
-        return { type: "CONDITIONS_MET" };
-      }),
-      spawnSubscriberFunction: fromPromise(
-        async ({
-          input
-        }) => {
-          const { parentStepId, context } = input;
-          const stepGraph = this.#stepSubscriberGraph[parentStepId];
-          if (!stepGraph) {
-            return {
-              steps: {}
-            };
-          }
-          const subscriberMachine = setup({
-            types: {},
-            delays: this.#makeDelayMap(),
-            actions: this.#getDefaultActions(),
-            actors: this.#getDefaultActors()
-          }).createMachine({
-            id: `${this.name}-subscriber-${parentStepId}`,
+  async execute({
+    triggerData,
+    snapshot,
+    stepId
+  } = {}) {
+    this.#executionSpan = this.#mastra?.telemetry?.tracer.startSpan(`workflow.${this.name}.execute`, {
+      attributes: { componentName: this.name, runId: this.runId }
+    });
+    let machineInput = {
+      // Maintain the original step results and their output
+      steps: {},
+      triggerData: triggerData || {},
+      attempts: Object.keys(this.#steps).reduce(
+        (acc, stepKey) => {
+          acc[stepKey] = this.#steps[stepKey]?.retryConfig?.attempts || this.#retryConfig?.attempts || 3;
+          return acc;
+        },
+        {}
+      )
+    };
+    let stepGraph = this.#stepGraph;
+    let startStepId = "trigger";
+    if (snapshot) {
+      const runState = snapshot;
+      machineInput = runState.context;
+      if (stepId && runState?.suspendedSteps?.[stepId]) {
+        startStepId = runState.suspendedSteps[stepId];
+        stepGraph = this.#stepSubscriberGraph[startStepId] ?? this.#stepGraph;
+      }
+    }
+    const defaultMachine = new Machine({
+      logger: this.logger,
+      mastra: this.#mastra,
+      workflowInstance: this,
+      name: this.name,
+      runId: this.runId,
+      steps: this.#steps,
+      stepGraph,
+      executionSpan: this.#executionSpan,
+      startStepId
+    });
+    this.#machines[startStepId] = defaultMachine;
+    const stateUpdateHandler = (startStepId2, state, context) => {
+      if (startStepId2 === "trigger") {
+        this.#state = state;
+      } else {
+        this.#state = mergeChildValue(startStepId2, this.#state, state);
+      }
+      const now = Date.now();
+      if (this.#onStepTransition) {
+        this.#onStepTransition.forEach((onTransition) => {
+          void onTransition({
+            runId: this.#runId,
+            value: this.#state,
             context,
-            type: "parallel",
-            states: this.#buildStateHierarchy(stepGraph)
+            activePaths: getActivePathsAndStatus(this.#state),
+            timestamp: now
           });
-          const actor = createActor(subscriberMachine, { input: context });
-          actor.start();
-          return new Promise((resolve) => {
-            const suspendedPaths = /* @__PURE__ */ new Set();
-            actor.subscribe((state) => {
-              this.#getSuspendedPaths({
-                value: state.value,
-                path: "",
-                suspendedPaths
-              });
-              const allStatesValue = state.value;
-              const allStatesComplete = this.#recursivelyCheckForFinalState({
-                value: allStatesValue,
-                suspendedPaths,
-                path: ""
-              });
-              if (allStatesComplete) {
-                actor.stop();
-                resolve({
-                  steps: state.context.steps
-                });
-              }
-            });
+        });
+      }
+    };
+    defaultMachine.on("state-update", stateUpdateHandler);
+    const { results } = await defaultMachine.execute({ snapshot, stepId, input: machineInput });
+    await this.persistWorkflowSnapshot();
+    return { results };
+  }
+  async runMachine(parentStepId, input) {
+    if (!this.#stepSubscriberGraph[parentStepId]) {
+      return;
+    }
+    const stateUpdateHandler = (startStepId, state, context) => {
+      if (startStepId === "trigger") {
+        this.#state = state;
+      } else {
+        this.#state = mergeChildValue(startStepId, this.#state, state);
+      }
+      const now = Date.now();
+      if (this.#onStepTransition) {
+        this.#onStepTransition.forEach((onTransition) => {
+          void onTransition({
+            runId: this.#runId,
+            value: this.#state,
+            context,
+            activePaths: getActivePathsAndStatus(this.#state),
+            timestamp: now
           });
-        }
+        });
+      }
+    };
+    const machine = new Machine({
+      logger: this.logger,
+      mastra: this.#mastra,
+      workflowInstance: this,
+      name: parentStepId === "trigger" ? this.name : `${this.name}-${parentStepId}`,
+      runId: this.runId,
+      steps: this.#steps,
+      stepGraph: this.#stepSubscriberGraph[parentStepId],
+      executionSpan: this.#executionSpan,
+      startStepId: parentStepId
+    });
+    machine.on("state-update", stateUpdateHandler);
+    this.#machines[parentStepId] = machine;
+    return await machine.execute({ input });
+  }
+  async suspend(stepId, machine) {
+    this.#suspendedMachines[stepId] = machine;
+  }
+  /**
+   * Persists the workflow state to the database
+   */
+  async persistWorkflowSnapshot() {
+    const existingSnapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+      workflowName: this.name,
+      runId: this.#runId
+    });
+    const machineSnapshots = {};
+    for (const [stepId, machine] of Object.entries(this.#machines)) {
+      const machineSnapshot = machine?.getSnapshot();
+      if (machineSnapshot) {
+        machineSnapshots[stepId] = { ...machineSnapshot };
+      }
+    }
+    let snapshot = machineSnapshots["trigger"];
+    delete machineSnapshots["trigger"];
+    const suspendedSteps = Object.entries(this.#suspendedMachines).reduce(
+      (acc, [stepId, machine]) => {
+        acc[stepId] = machine.startStepId;
+        return acc;
+      },
+      {}
+    );
+    if (!snapshot && existingSnapshot) {
+      existingSnapshot.childStates = { ...existingSnapshot.childStates, ...machineSnapshots };
+      existingSnapshot.suspendedSteps = { ...existingSnapshot.suspendedSteps, ...suspendedSteps };
+      await this.#mastra?.storage?.persistWorkflowSnapshot({
+        workflowName: this.name,
+        runId: this.#runId,
+        snapshot: existingSnapshot
+      });
+      return;
+    } else if (snapshot && !existingSnapshot) {
+      snapshot.suspendedSteps = suspendedSteps;
+      snapshot.childStates = { ...machineSnapshots };
+      await this.#mastra?.storage?.persistWorkflowSnapshot({
+        workflowName: this.name,
+        runId: this.#runId,
+        snapshot
+      });
+      return;
+    } else if (!snapshot) {
+      this.logger.debug("Snapshot cannot be persisted. No snapshot received.", { runId: this.#runId });
+      return;
+    }
+    snapshot.suspendedSteps = { ...existingSnapshot.suspendedSteps, ...suspendedSteps };
+    if (!existingSnapshot || snapshot === existingSnapshot) {
+      await this.#mastra?.storage?.persistWorkflowSnapshot({
+        workflowName: this.name,
+        runId: this.#runId,
+        snapshot
+      });
+      return;
+    }
+    if (existingSnapshot?.childStates) {
+      snapshot.childStates = { ...existingSnapshot.childStates, ...machineSnapshots };
+    } else {
+      snapshot.childStates = machineSnapshots;
+    }
+    await this.#mastra?.storage?.persistWorkflowSnapshot({
+      workflowName: this.name,
+      runId: this.#runId,
+      snapshot
+    });
+  }
+  async getState() {
+    const storedSnapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+      workflowName: this.name,
+      runId: this.runId
+    });
+    const prevSnapshot = storedSnapshot ? {
+      trigger: storedSnapshot,
+      ...Object.entries(storedSnapshot?.childStates ?? {}).reduce(
+        (acc, [stepId, snapshot2]) => ({ ...acc, [stepId]: snapshot2 }),
+        {}
       )
+    } : {};
+    const currentSnapshot = Object.entries(this.#machines).reduce(
+      (acc, [stepId, machine]) => {
+        const snapshot2 = machine.getSnapshot();
+        if (!snapshot2) {
+          return acc;
+        }
+        return {
+          ...acc,
+          [stepId]: snapshot2
+        };
+      },
+      {}
+    );
+    Object.assign(prevSnapshot, currentSnapshot);
+    const trigger = prevSnapshot.trigger;
+    delete prevSnapshot.trigger;
+    const snapshot = { ...trigger};
+    const m = getActivePathsAndStatus(prevSnapshot.value);
+    return {
+      runId: this.runId,
+      value: snapshot.value,
+      context: snapshot.context,
+      activePaths: m,
+      timestamp: Date.now()
+    };
+  }
+};
+
+// src/workflows/workflow.ts
+var Workflow = class extends MastraBase {
+  name;
+  triggerSchema;
+  #retryConfig;
+  #mastra;
+  #runs = /* @__PURE__ */ new Map();
+  // registers stepIds on `after` calls
+  #afterStepStack = [];
+  #lastStepStack = [];
+  #stepGraph = { initial: [] };
+  #stepSubscriberGraph = {};
+  #steps = {};
+  #onStepTransition = /* @__PURE__ */ new Set();
+  /**
+   * Creates a new Workflow instance
+   * @param name - Identifier for the workflow (not necessarily unique)
+   * @param logger - Optional logger instance
+   */
+  constructor({ name, triggerSchema, retryConfig, mastra }) {
+    super({ component: "WORKFLOW", name });
+    this.name = name;
+    this.#retryConfig = retryConfig;
+    this.triggerSchema = triggerSchema;
+    this.#mastra = mastra;
+    if (mastra?.logger) {
+      this.logger = mastra?.logger;
+    }
+  }
+  step(step, config) {
+    const { variables = {} } = config || {};
+    const requiredData = {};
+    for (const [key, variable] of Object.entries(variables)) {
+      if (variable && isVariableReference(variable)) {
+        requiredData[key] = variable;
+      }
+    }
+    const stepKey = this.#makeStepKey(step);
+    const graphEntry = {
+      step,
+      config: {
+        ...this.#makeStepDef(stepKey),
+        ...config,
+        data: requiredData
+      }
     };
-  }
-  /**
-   * Persists the workflow state to the database
-   */
-  async #persistWorkflowSnapshot() {
-    const snapshotFromActor = this.#actor?.getPersistedSnapshot();
-    if (!this.#mastra?.storage) {
-      this.logger.debug("Snapshot cannot be persisted. Mastra engine is not initialized", {
-        runId: this.#runId
-      });
-      return;
+    this.#steps[stepKey] = step;
+    const parentStepKey = this.#afterStepStack[this.#afterStepStack.length - 1];
+    const stepGraph = this.#stepSubscriberGraph[parentStepKey || ""];
+    if (parentStepKey && stepGraph) {
+      if (!stepGraph.initial.some((step2) => step2.step.id === stepKey)) {
+        stepGraph.initial.push(graphEntry);
+      }
+      stepGraph[stepKey] = [];
+    } else {
+      if (!this.#stepGraph[stepKey]) this.#stepGraph[stepKey] = [];
+      this.#stepGraph.initial.push(graphEntry);
     }
-    if (!snapshotFromActor) {
-      this.logger.debug("Snapshot cannot be persisted. No snapshot received.", { runId: this.#runId });
-      return;
+    this.#lastStepStack.push(stepKey);
+    return this;
+  }
+  #makeStepKey(step) {
+    return `${step.id}`;
+  }
+  then(step, config) {
+    const { variables = {} } = config || {};
+    const requiredData = {};
+    for (const [key, variable] of Object.entries(variables)) {
+      if (variable && isVariableReference(variable)) {
+        requiredData[key] = variable;
+      }
     }
-    if (this.#mastra?.storage) {
-      await this.#mastra.storage.persistWorkflowSnapshot({
-        workflowName: this.name,
-        runId: this.#runId,
-        snapshot: snapshotFromActor
-      });
+    const lastStepKey = this.#lastStepStack[this.#lastStepStack.length - 1];
+    const stepKey = this.#makeStepKey(step);
+    const graphEntry = {
+      step,
+      config: {
+        ...this.#makeStepDef(stepKey),
+        ...config,
+        data: requiredData
+      }
+    };
+    this.#steps[stepKey] = step;
+    if (!lastStepKey) return this;
+    const parentStepKey = this.#afterStepStack[this.#afterStepStack.length - 1];
+    const stepGraph = this.#stepSubscriberGraph[parentStepKey || ""];
+    if (parentStepKey && stepGraph && stepGraph[lastStepKey]) {
+      stepGraph[lastStepKey].push(graphEntry);
+    } else {
+      if (!this.#stepGraph[lastStepKey]) this.#stepGraph[lastStepKey] = [];
+      this.#stepGraph[lastStepKey].push(graphEntry);
     }
-    return this.#runId;
+    return this;
   }
-  async #loadWorkflowSnapshot(runId) {
-    if (!this.#mastra?.storage) {
-      this.logger.debug("Snapshot cannot be loaded. Mastra engine is not initialized", { runId });
-      return;
+  after(step) {
+    const stepKey = this.#makeStepKey(step);
+    this.#afterStepStack.push(stepKey);
+    if (!this.#stepSubscriberGraph[stepKey]) {
+      this.#stepSubscriberGraph[stepKey] = { initial: [] };
     }
-    return this.#mastra.storage.loadWorkflowSnapshot({ runId, workflowName: this.name });
+    return this;
   }
   /**
-   * Resolves variables for a step from trigger data or previous step results
-   * @param stepConfig - Configuration of the step needing variable resolution
-   * @param context - Current workflow context containing results and trigger data
-   * @returns Object containing resolved variable values
+   * Executes the workflow with the given trigger data
+   * @param triggerData - Initial data to start the workflow with
+   * @returns Promise resolving to workflow results or rejecting with error
+   * @throws Error if trigger schema validation fails
    */
-  #resolveVariables({
-    stepConfig,
-    context,
-    stepId
-  }) {
-    this.logger.debug(`Resolving variables for step ${stepId}`, {
-      stepId,
-      runId: this.#runId
-    });
-    const resolvedData = {
-      ...context,
-      getStepResult: (stepId2) => {
-        if (stepId2 === "trigger") {
-          return context.triggerData;
-        }
-        const result = context.steps[stepId2];
-        if (result && result.status === "success") {
-          return result.output;
-        }
-        return void 0;
+  createRun() {
+    const run = new WorkflowInstance({
+      logger: this.logger,
+      name: this.name,
+      mastra: this.#mastra,
+      retryConfig: this.#retryConfig,
+      steps: this.#steps,
+      stepGraph: this.#stepGraph,
+      stepSubscriberGraph: this.#stepSubscriberGraph,
+      onStepTransition: this.#onStepTransition,
+      onFinish: () => {
+        this.#runs.delete(run.runId);
       }
+    });
+    this.#runs.set(run.runId, run);
+    return {
+      start: run.start.bind(run),
+      runId: run.runId
     };
-    for (const [key, variable] of Object.entries(stepConfig.data)) {
-      const sourceData = variable.step === "trigger" ? context.triggerData : getStepResult(context.steps[variable.step.id]);
-      this.logger.debug(
-        `Got source data for ${key} variable from ${variable.step === "trigger" ? "trigger" : variable.step.id}`,
-        {
-          sourceData,
-          path: variable.path,
-          runId: this.#runId
-        }
-      );
-      if (!sourceData && variable.step !== "trigger") {
-        resolvedData[key] = void 0;
-        continue;
-      }
-      const value = variable.path === "" || variable.path === "." ? sourceData : get(sourceData, variable.path);
-      this.logger.debug(`Resolved variable ${key}`, {
-        value,
-        runId: this.#runId
-      });
-      resolvedData[key] = value;
-    }
-    return resolvedData;
   }
   /**
-   * Evaluates a single condition against workflow context
+   * Rebuilds the machine with the current steps configuration and validates the workflow
+   *
+   * This is the last step of a workflow builder method chain
+   * @throws Error if validation fails
+   *
+   * @returns this instance for method chaining
    */
-  #evaluateCondition(condition, context) {
-    let andBranchResult = true;
-    let baseResult = true;
-    let orBranchResult = true;
-    const simpleCondition = Object.entries(condition).find(([key]) => key.includes("."));
-    if (simpleCondition) {
-      const [key, queryValue] = simpleCondition;
-      const [stepId, ...pathParts] = key.split(".");
-      const path = pathParts.join(".");
-      const sourceData = stepId === "trigger" ? context.triggerData : getStepResult(context.steps[stepId]);
-      this.logger.debug(`Got condition data from step ${stepId}`, {
-        stepId,
-        sourceData,
-        runId: this.#runId
-      });
-      if (!sourceData) {
-        return false;
-      }
-      let value = get(sourceData, path);
-      if (stepId !== "trigger" && path === "status" && !value) {
-        value = "success";
-      }
-      if (typeof queryValue === "object" && queryValue !== null) {
-        baseResult = sift(queryValue)(value);
-      } else {
-        baseResult = value === queryValue;
-      }
-    }
-    if ("ref" in condition) {
-      const { ref, query } = condition;
-      const sourceData = ref.step === "trigger" ? context.triggerData : getStepResult(context.steps[ref.step.id]);
-      this.logger.debug(`Got condition data from ${ref.step === "trigger" ? "trigger" : ref.step.id}`, {
-        sourceData,
-        runId: this.#runId
-      });
-      if (!sourceData) {
-        return false;
-      }
-      let value = get(sourceData, ref.path);
-      if (ref.step !== "trigger" && ref.path === "status" && !value) {
-        value = "success";
+  commit() {
+    return this;
+  }
+  // record all object paths that leads to a suspended state
+  #getSuspendedPaths({
+    value,
+    path,
+    suspendedPaths
+  }) {
+    if (typeof value === "string") {
+      if (value === "suspended") {
+        suspendedPaths.add(path);
       }
-      baseResult = sift(query)(value);
+    } else {
+      Object.keys(value).forEach(
+        (key) => this.#getSuspendedPaths({ value: value[key], path: path ? `${path}.${key}` : key, suspendedPaths })
+      );
     }
-    if ("and" in condition) {
-      andBranchResult = condition.and.every((cond) => this.#evaluateCondition(cond, context));
-      this.logger.debug(`Evaluated AND condition`, {
-        andBranchResult,
-        runId: this.#runId
-      });
+  }
+  async #loadWorkflowSnapshot(runId) {
+    if (!this.#mastra?.storage) {
+      this.logger.debug("Snapshot cannot be loaded. Mastra engine is not initialized", { runId });
+      return;
     }
-    if ("or" in condition) {
-      orBranchResult = condition.or.some((cond) => this.#evaluateCondition(cond, context));
-      this.logger.debug(`Evaluated OR condition`, {
-        orBranchResult,
-        runId: this.#runId
-      });
+    const activeRun = this.#runs.get(runId);
+    if (activeRun) {
+      await activeRun.persistWorkflowSnapshot();
     }
-    const finalResult = baseResult && andBranchResult && orBranchResult;
-    this.logger.debug(`Evaluated condition`, {
-      finalResult,
-      runId: this.#runId
-    });
-    return finalResult;
+    return this.#mastra.storage.loadWorkflowSnapshot({ runId, workflowName: this.name });
+  }
+  getExecutionSpan(runId) {
+    return this.#runs.get(runId)?.executionSpan;
   }
   #makeStepDef(stepId) {
     const executeStep = (handler2, spanName, attributes) => {
       return async (data) => {
-        return await context.with(trace.setSpan(context.active(), this.#executionSpan), async () => {
-          return this.#mastra.telemetry.traceMethod(handler2, {
-            spanName,
-            attributes
-          })(data);
-        });
+        return await context.with(
+          trace.setSpan(context.active(), this.getExecutionSpan(attributes?.runId ?? data?.runId)),
+          async () => {
+            return this.#mastra.telemetry.traceMethod(handler2, {
+              spanName,
+              attributes
+            })(data);
+          }
+        );
       };
     };
     const handler = async ({ context, ...rest }) => {
@@ -1007,15 +1275,15 @@ var Workflow = class extends MastraBase {
       };
       const finalAction = this.#mastra?.telemetry ? executeStep(execute, `workflow.${this.name}.action.${stepId}`, {
         componentName: this.name,
-        runId: context.runId ?? this.#runId
+        runId: rest.runId
       }) : execute;
       return finalAction ? await finalAction({ context: mergedData, ...rest }) : {};
     };
     const finalHandler = ({ context, ...rest }) => {
-      if (this.#executionSpan) {
+      if (this.getExecutionSpan(rest?.runId)) {
         return executeStep(handler, `workflow.${this.name}.step.${stepId}`, {
           componentName: this.name,
-          runId: context.runId ?? this.#runId
+          runId: rest?.runId
         })({ context, ...rest });
       }
       return handler({ context, ...rest });
@@ -1025,26 +1293,6 @@ var Workflow = class extends MastraBase {
       data: {}
     };
   }
-  /**
-   * Creates a map of step IDs to their respective delay values
-   * @returns Object mapping step IDs to delay values
-   */
-  #makeDelayMap() {
-    const delayMap = {};
-    Object.keys(this.#steps).forEach((stepId) => {
-      delayMap[stepId] = this.#steps[stepId]?.retryConfig?.delay || this.#retryConfig?.delay || 1e3;
-    });
-    return delayMap;
-  }
-  /**
-   * Cleans up the actor instance
-   */
-  #cleanup() {
-    if (this.#actor) {
-      this.#actor.stop();
-      this.#actor = null;
-    }
-  }
   #getActivePathsAndStatus(value) {
     const paths = [];
     const traverse = (current, path = []) => {
@@ -1065,16 +1313,9 @@ var Workflow = class extends MastraBase {
     return paths;
   }
   async getState(runId) {
-    if (this.#runId === runId && this.#actor) {
-      const snapshot = this.#actor.getSnapshot();
-      const m = this.#getActivePathsAndStatus(snapshot.value);
-      return {
-        runId,
-        value: snapshot.value,
-        context: snapshot.context,
-        activePaths: m,
-        timestamp: Date.now()
-      };
+    const run = this.#runs.get(runId);
+    if (run) {
+      return run.getState();
     }
     const storedSnapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
       runId,
@@ -1103,6 +1344,14 @@ var Workflow = class extends MastraBase {
     runId,
     stepId,
     context: resumeContext
+  }) {
+    await setTimeout(0);
+    return this._resume({ runId, stepId, context: resumeContext });
+  }
+  async _resume({
+    runId,
+    stepId,
+    context: resumeContext
   }) {
     const snapshot = await this.#loadWorkflowSnapshot(runId);
     if (!snapshot) {
@@ -1115,6 +1364,15 @@ var Workflow = class extends MastraBase {
       this.logger.debug("Failed to parse workflow snapshot for resume", { error, runId });
       throw new Error("Failed to parse workflow snapshot");
     }
+    const origSnapshot = parsedSnapshot;
+    const startStepId = parsedSnapshot.suspendedSteps?.[stepId];
+    if (!startStepId) {
+      return;
+    }
+    parsedSnapshot = startStepId === "trigger" ? parsedSnapshot : { ...parsedSnapshot?.childStates?.[startStepId], ...{ suspendedSteps: parsedSnapshot.suspendedSteps } };
+    if (!parsedSnapshot) {
+      throw new Error(`No snapshot found for step: ${stepId} starting at ${startStepId}`);
+    }
     if (resumeContext) {
       parsedSnapshot.context.steps[stepId] = {
         status: "success",
@@ -1136,20 +1394,6 @@ var Workflow = class extends MastraBase {
         }
       });
     }
-    const updateStepInHierarchy = (value, targetStepId) => {
-      const result = {};
-      for (const key of Object.keys(value)) {
-        const currentValue = value[key];
-        if (key === targetStepId) {
-          result[key] = "pending";
-        } else if (typeof currentValue === "object" && currentValue !== null) {
-          result[key] = updateStepInHierarchy(currentValue, targetStepId);
-        } else {
-          result[key] = currentValue;
-        }
-      }
-      return result;
-    };
     parsedSnapshot.value = updateStepInHierarchy(parsedSnapshot.value, stepId);
     if (parsedSnapshot.context?.attempts) {
       parsedSnapshot.context.attempts[stepId] = this.#steps[stepId]?.retryConfig?.attempts || this.#retryConfig?.attempts || 3;
@@ -1159,9 +1403,24 @@ var Workflow = class extends MastraBase {
       runId,
       stepId
     });
-    return this.execute({
-      snapshot: parsedSnapshot,
+    const run = this.#runs.get(runId) ?? new WorkflowInstance({
+      logger: this.logger,
+      name: this.name,
+      mastra: this.#mastra,
+      retryConfig: this.#retryConfig,
+      steps: this.#steps,
+      stepGraph: this.#stepGraph,
+      stepSubscriberGraph: this.#stepSubscriberGraph,
+      onStepTransition: this.#onStepTransition,
       runId,
+      onFinish: () => {
+        this.#runs.delete(run.runId);
+      }
+    });
+    run.setState(origSnapshot?.value);
+    this.#runs.set(run.runId, run);
+    return run?.execute({
+      snapshot: parsedSnapshot,
       stepId
     });
   }
@@ -1217,4 +1476,4 @@ function createStep(opts) {
   return new Step(opts);
 }
 
-export { Step, Workflow, createStep, getStepResult, isErrorEvent, isTransitionEvent, isVariableReference };
+export { Step, Workflow, createStep, getActivePathsAndStatus, getStepResult, getSuspendedPaths, isErrorEvent, isFinalState, isTransitionEvent, isVariableReference, mergeChildValue, recursivelyCheckForFinalState, updateStepInHierarchy };