@mastra/core 0.2.0-alpha.99 → 0.2.0

package/dist/chunk-MDM2JS2U.js

@@ -1,1288 +0,0 @@
-import { MastraBase } from './chunk-G4MCO7XF.js';
-import { __name, __privateAdd, __publicField, __privateSet, __privateMethod, __privateGet } from './chunk-AJJZUHB4.js';
-import { get } from 'radash';
-import sift from 'sift';
-import { setup, createActor, assign, fromPromise } from 'xstate';
-
-// src/workflows/utils.ts
-function isErrorEvent(stateEvent) {
-  return stateEvent.type.startsWith("xstate.error.actor.");
-}
-__name(isErrorEvent, "isErrorEvent");
-function isTransitionEvent(stateEvent) {
-  return stateEvent.type.startsWith("xstate.done.actor.");
-}
-__name(isTransitionEvent, "isTransitionEvent");
-function isVariableReference(value) {
-  return typeof value === "object" && "step" in value && "path" in value;
-}
-__name(isVariableReference, "isVariableReference");
-function getStepResult(result) {
-  if (result?.status === "success") return result.output;
-  return undefined;
-}
-__name(getStepResult, "getStepResult");
-
-// src/workflows/workflow.ts
-var _machine, _actor, _runId, _retryConfig, _mastra, _afterStepStack, _lastStepStack, _stepGraph, _stepSubscriberGraph, _steps, _Workflow_instances, getSuspendedPaths_fn, isFinalState_fn, recursivelyCheckForFinalState_fn, buildBaseState_fn, makeStepKey_fn, buildStateHierarchy_fn, getDefaultActions_fn, getInjectables_fn, getDefaultActors_fn, persistWorkflowSnapshot_fn, loadWorkflowSnapshot_fn, resolveVariables_fn, evaluateCondition_fn, makeStepDef_fn, makeDelayMap_fn, cleanup_fn, getActivePathsAndStatus_fn, hasStateChanged_fn, getDeepestState_fn;
-var _Workflow = class _Workflow extends MastraBase {
-  /**
-  * 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
-    });
-    __privateAdd(this, _Workflow_instances);
-    __publicField(this, "name");
-    __publicField(this, "triggerSchema");
-    /** XState machine instance that orchestrates the workflow execution */
-    __privateAdd(this, _machine);
-    /** XState actor instance that manages the workflow execution */
-    __privateAdd(this, _actor, null);
-    __privateAdd(this, _runId);
-    __privateAdd(this, _retryConfig);
-    __privateAdd(this, _mastra);
-    // registers stepIds on `after` calls
-    __privateAdd(this, _afterStepStack, []);
-    __privateAdd(this, _lastStepStack, []);
-    __privateAdd(this, _stepGraph, {
-      initial: []
-    });
-    __privateAdd(this, _stepSubscriberGraph, {});
-    __privateAdd(this, _steps, {});
-    this.name = name;
-    __privateSet(this, _retryConfig, retryConfig);
-    this.triggerSchema = triggerSchema;
-    __privateSet(this, _runId, crypto.randomUUID());
-    __privateSet(this, _mastra, mastra);
-    if (mastra?.logger) {
-      this.logger = mastra?.logger;
-    }
-    this.initializeMachine();
-  }
-  /**
-  * 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: __privateMethod(this, _Workflow_instances, makeDelayMap_fn).call(this),
-      actions: __privateMethod(this, _Workflow_instances, getDefaultActions_fn).call(this),
-      actors: __privateMethod(this, _Workflow_instances, getDefaultActors_fn).call(this)
-    }).createMachine({
-      id: this.name,
-      type: "parallel",
-      context: /* @__PURE__ */ __name(({ input }) => ({
-        ...input
-      }), "context"),
-      states: __privateMethod(this, _Workflow_instances, buildStateHierarchy_fn).call(this, __privateGet(this, _stepGraph))
-    });
-    __privateSet(this, _machine, machine);
-    return machine;
-  }
-  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 = __privateMethod(this, _Workflow_instances, makeStepKey_fn).call(this, step);
-    const graphEntry = {
-      step,
-      config: {
-        ...__privateMethod(this, _Workflow_instances, makeStepDef_fn).call(this, stepKey),
-        ...config,
-        data: requiredData
-      }
-    };
-    __privateGet(this, _steps)[stepKey] = step;
-    const parentStepKey = __privateGet(this, _afterStepStack)[__privateGet(this, _afterStepStack).length - 1];
-    const stepGraph = __privateGet(this, _stepSubscriberGraph)[parentStepKey || ""];
-    if (parentStepKey && stepGraph) {
-      if (!stepGraph.initial.some((step2) => step2.step.id === stepKey)) {
-        stepGraph.initial.push(graphEntry);
-      }
-      stepGraph[stepKey] = [];
-    } else {
-      if (!__privateGet(this, _stepGraph)[stepKey]) __privateGet(this, _stepGraph)[stepKey] = [];
-      __privateGet(this, _stepGraph).initial.push(graphEntry);
-    }
-    __privateGet(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;
-      }
-    }
-    const lastStepKey = __privateGet(this, _lastStepStack)[__privateGet(this, _lastStepStack).length - 1];
-    const stepKey = __privateMethod(this, _Workflow_instances, makeStepKey_fn).call(this, step);
-    const graphEntry = {
-      step,
-      config: {
-        ...__privateMethod(this, _Workflow_instances, makeStepDef_fn).call(this, stepKey),
-        ...config,
-        data: requiredData
-      }
-    };
-    __privateGet(this, _steps)[stepKey] = step;
-    if (!lastStepKey) return this;
-    const parentStepKey = __privateGet(this, _afterStepStack)[__privateGet(this, _afterStepStack).length - 1];
-    const stepGraph = __privateGet(this, _stepSubscriberGraph)[parentStepKey || ""];
-    if (parentStepKey && stepGraph && stepGraph[lastStepKey]) {
-      stepGraph[lastStepKey].push(graphEntry);
-    } else {
-      if (!__privateGet(this, _stepGraph)[lastStepKey]) __privateGet(this, _stepGraph)[lastStepKey] = [];
-      __privateGet(this, _stepGraph)[lastStepKey].push(graphEntry);
-    }
-    return this;
-  }
-  after(step) {
-    const stepKey = __privateMethod(this, _Workflow_instances, makeStepKey_fn).call(this, step);
-    __privateGet(this, _afterStepStack).push(stepKey);
-    if (!__privateGet(this, _stepSubscriberGraph)[stepKey]) {
-      __privateGet(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();
-    __privateSet(this, _runId, runId);
-    return {
-      runId,
-      start: /* @__PURE__ */ __name(async ({ triggerData } = {}) => this.execute({
-        triggerData
-      }), "start")
-    };
-  }
-  async execute({ triggerData, snapshot, runId, stepId } = {}) {
-    if (runId) {
-      __privateSet(this, _runId, runId);
-      this.logger.debug("Incoming snapshot", {
-        snapshot,
-        runId: __privateGet(this, _runId)
-      });
-    }
-    const machineInput = snapshot ? snapshot.context : {
-      // Maintain the original step results and their output
-      steps: {},
-      triggerData: triggerData || {},
-      attempts: Object.keys(__privateGet(this, _steps)).reduce((acc, stepKey) => {
-        acc[stepKey] = __privateGet(this, _steps)[stepKey]?.retryConfig?.attempts || __privateGet(this, _retryConfig)?.attempts || 3;
-        return acc;
-      }, {})
-    };
-    this.logger.debug("Machine input prepared", {
-      machineInput,
-      runId: __privateGet(this, _runId)
-    });
-    const actorSnapshot = snapshot ? {
-      ...snapshot,
-      context: machineInput
-    } : undefined;
-    this.logger.debug("Creating actor with configuration", {
-      machineInput,
-      actorSnapshot,
-      machineStates: __privateGet(this, _machine).config.states,
-      runId: __privateGet(this, _runId)
-    });
-    __privateSet(this, _actor, createActor(__privateGet(this, _machine), {
-      inspect: /* @__PURE__ */ __name((inspectionEvent) => {
-        this.logger.debug("XState inspection event", {
-          type: inspectionEvent.type,
-          event: inspectionEvent.event,
-          runId: __privateGet(this, _runId)
-        });
-      }, "inspect"),
-      input: machineInput,
-      snapshot: actorSnapshot
-    }));
-    __privateGet(this, _actor).start();
-    if (stepId) {
-      __privateGet(this, _actor).send({
-        type: "RESET_TO_PENDING",
-        stepId
-      });
-    }
-    this.logger.debug("Actor started", {
-      runId: __privateGet(this, _runId)
-    });
-    return new Promise((resolve, reject) => {
-      if (!__privateGet(this, _actor)) {
-        reject(new Error("Actor not initialized"));
-        return;
-      }
-      const suspendedPaths = /* @__PURE__ */ new Set();
-      __privateGet(this, _actor).subscribe(async (state) => {
-        __privateMethod(this, _Workflow_instances, getSuspendedPaths_fn).call(this, {
-          value: state.value,
-          path: "",
-          suspendedPaths
-        });
-        const allStatesValue = state.value;
-        const allStatesComplete = __privateMethod(this, _Workflow_instances, recursivelyCheckForFinalState_fn).call(this, {
-          value: allStatesValue,
-          suspendedPaths,
-          path: ""
-        });
-        this.logger.debug("State completion check", {
-          allStatesComplete,
-          suspendedPaths: Array.from(suspendedPaths),
-          runId: __privateGet(this, _runId)
-        });
-        if (!allStatesComplete) return;
-        try {
-          await __privateMethod(this, _Workflow_instances, persistWorkflowSnapshot_fn).call(this);
-          __privateMethod(this, _Workflow_instances, cleanup_fn).call(this);
-          resolve({
-            triggerData,
-            results: state.context.steps,
-            runId: __privateGet(this, _runId)
-          });
-        } catch (error) {
-          this.logger.debug("Failed to persist final snapshot", {
-            error
-          });
-          __privateMethod(this, _Workflow_instances, cleanup_fn).call(this);
-          resolve({
-            triggerData,
-            results: state.context.steps,
-            runId: __privateGet(this, _runId)
-          });
-        }
-      });
-    });
-  }
-  /**
-  * 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;
-  }
-  async getState(runId) {
-    if (__privateGet(this, _runId) === runId && __privateGet(this, _actor)) {
-      const snapshot = __privateGet(this, _actor).getSnapshot();
-      const m = __privateMethod(this, _Workflow_instances, getActivePathsAndStatus_fn).call(this, snapshot.value);
-      return {
-        runId,
-        value: snapshot.value,
-        context: snapshot.context,
-        activePaths: m,
-        timestamp: Date.now()
-      };
-    }
-    const storedSnapshot = await __privateGet(this, _mastra)?.storage?.loadWorkflowSnapshot({
-      runId,
-      workflowName: this.name
-    });
-    if (storedSnapshot) {
-      const parsed = storedSnapshot;
-      const m = __privateMethod(this, _Workflow_instances, getActivePathsAndStatus_fn).call(this, parsed.value);
-      return {
-        runId,
-        value: parsed.value,
-        context: parsed.context,
-        activePaths: m,
-        timestamp: Date.now()
-      };
-    }
-    return null;
-  }
-  async watch(runId, options = {}) {
-    const { onTransition, pollInterval = 1e3 } = options;
-    return new Promise((resolve, reject) => {
-      let timeoutId;
-      let previousState = null;
-      const poll = /* @__PURE__ */ __name(async () => {
-        try {
-          const currentState = await this.getState(runId);
-          if (!currentState) {
-            reject(new Error(`No workflow found for runId: ${runId}`));
-            return;
-          }
-          if (onTransition && __privateMethod(this, _Workflow_instances, hasStateChanged_fn).call(this, previousState, currentState)) {
-            await onTransition(currentState);
-          }
-          previousState = currentState;
-          const deepState = __privateMethod(this, _Workflow_instances, getDeepestState_fn).call(this, currentState.value);
-          if (__privateMethod(this, _Workflow_instances, isFinalState_fn).call(this, deepState.status)) {
-            resolve(currentState);
-            return;
-          }
-          timeoutId = setTimeout(poll, pollInterval);
-        } catch (error) {
-          reject(error);
-        }
-      }, "poll");
-      poll();
-      return () => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-      };
-    });
-  }
-  async resume({ runId, stepId, context: resumeContext }) {
-    const snapshot = await __privateMethod(this, _Workflow_instances, loadWorkflowSnapshot_fn).call(this, runId);
-    if (!snapshot) {
-      throw new Error(`No snapshot found for workflow run ${runId}`);
-    }
-    let parsedSnapshot;
-    try {
-      parsedSnapshot = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
-    } catch (error) {
-      this.logger.debug("Failed to parse workflow snapshot for resume", {
-        error,
-        runId
-      });
-      throw new Error("Failed to parse workflow snapshot");
-    }
-    if (resumeContext) {
-      parsedSnapshot.context.steps[stepId] = {
-        status: "success",
-        output: {
-          ...parsedSnapshot?.context?.steps?.[stepId]?.output || {},
-          ...resumeContext
-        }
-      };
-    }
-    if (parsedSnapshot.children) {
-      Object.entries(parsedSnapshot.children).forEach(([_childId, child]) => {
-        if (child.snapshot?.input?.stepNode) {
-          const stepDef = __privateMethod(this, _Workflow_instances, makeStepDef_fn).call(this, child.snapshot.input.stepNode.step.id);
-          child.snapshot.input.stepNode.config = {
-            ...child.snapshot.input.stepNode.config,
-            ...stepDef
-          };
-          child.snapshot.input.context = parsedSnapshot.context;
-        }
-      });
-    }
-    const updateStepInHierarchy = /* @__PURE__ */ __name((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;
-    }, "updateStepInHierarchy");
-    parsedSnapshot.value = updateStepInHierarchy(parsedSnapshot.value, stepId);
-    if (parsedSnapshot.context?.attempts) {
-      parsedSnapshot.context.attempts[stepId] = __privateGet(this, _steps)[stepId]?.retryConfig?.attempts || __privateGet(this, _retryConfig)?.attempts || 3;
-    }
-    this.logger.debug("Resuming workflow with updated snapshot", {
-      updatedSnapshot: parsedSnapshot,
-      runId,
-      stepId
-    });
-    return this.execute({
-      snapshot: parsedSnapshot,
-      runId,
-      stepId
-    });
-  }
-  __registerPrimitives(p) {
-    if (p.telemetry) {
-      this.__setTelemetry(p.telemetry);
-    }
-    if (p.logger) {
-      this.__setLogger(p.logger);
-    }
-    __privateSet(this, _mastra, p);
-  }
-  get stepGraph() {
-    return __privateGet(this, _stepGraph);
-  }
-  get stepSubscriberGraph() {
-    return __privateGet(this, _stepSubscriberGraph);
-  }
-  get steps() {
-    return __privateGet(this, _steps);
-  }
-};
-_machine = new WeakMap();
-_actor = new WeakMap();
-_runId = new WeakMap();
-_retryConfig = new WeakMap();
-_mastra = new WeakMap();
-_afterStepStack = new WeakMap();
-_lastStepStack = new WeakMap();
-_stepGraph = new WeakMap();
-_stepSubscriberGraph = new WeakMap();
-_steps = new WeakMap();
-_Workflow_instances = new WeakSet();
-// record all object paths that leads to a suspended state
-getSuspendedPaths_fn = /* @__PURE__ */ __name(function({ value, path, suspendedPaths }) {
-  if (typeof value === "string") {
-    if (value === "suspended") {
-      suspendedPaths.add(path);
-    }
-  } else {
-    Object.keys(value).forEach((key) => __privateMethod(this, _Workflow_instances, getSuspendedPaths_fn).call(this, {
-      value: value[key],
-      path: path ? `${path}.${key}` : key,
-      suspendedPaths
-    }));
-  }
-}, "#getSuspendedPaths");
-isFinalState_fn = /* @__PURE__ */ __name(function(status) {
-  return [
-    "completed",
-    "failed"
-  ].includes(status);
-}, "#isFinalState");
-recursivelyCheckForFinalState_fn = /* @__PURE__ */ __name(function({ value, suspendedPaths, path }) {
-  if (typeof value === "string") {
-    return __privateMethod(this, _Workflow_instances, isFinalState_fn).call(this, value) || suspendedPaths.has(path);
-  }
-  return Object.keys(value).every((key) => __privateMethod(this, _Workflow_instances, recursivelyCheckForFinalState_fn).call(this, {
-    value: value[key],
-    suspendedPaths,
-    path: path ? `${path}.${key}` : key
-  }));
-}, "#recursivelyCheckForFinalState");
-buildBaseState_fn = /* @__PURE__ */ __name(function(stepNode, nextSteps = []) {
-  const nextStep = nextSteps.shift();
-  return {
-    initial: "pending",
-    on: {
-      RESET_TO_PENDING: {
-        target: ".pending"
-      }
-    },
-    states: {
-      pending: {
-        entry: /* @__PURE__ */ __name(() => {
-          this.logger.debug(`Step ${stepNode.step.id} pending`);
-        }, "entry"),
-        exit: /* @__PURE__ */ __name(() => {
-          this.logger.debug(`Step ${stepNode.step.id} finished pending`);
-        }, "exit"),
-        invoke: {
-          src: "conditionCheck",
-          input: /* @__PURE__ */ __name(({ context }) => {
-            return {
-              context,
-              stepNode
-            };
-          }, "input"),
-          onDone: [
-            {
-              guard: /* @__PURE__ */ __name(({ event }) => {
-                return event.output.type === "SUSPENDED";
-              }, "guard"),
-              target: "suspended",
-              actions: [
-                assign({
-                  steps: /* @__PURE__ */ __name(({ context, event }) => {
-                    if (event.output.type !== "SUSPENDED") return context.steps;
-                    return {
-                      ...context.steps,
-                      [stepNode.step.id]: {
-                        status: "suspended",
-                        ...context.steps?.[stepNode.step.id] || {}
-                      }
-                    };
-                  }, "steps"),
-                  attempts: /* @__PURE__ */ __name(({ context, event }) => {
-                    if (event.output.type !== "SUSPENDED") return context.attempts;
-                    return {
-                      ...context.attempts,
-                      [stepNode.step.id]: stepNode.step.retryConfig?.attempts || 3
-                    };
-                  }, "attempts")
-                })
-              ]
-            },
-            {
-              guard: /* @__PURE__ */ __name(({ event }) => {
-                return event.output.type === "WAITING";
-              }, "guard"),
-              target: "waiting",
-              actions: [
-                {
-                  type: "decrementAttemptCount",
-                  params: {
-                    stepId: stepNode.step.id
-                  }
-                },
-                assign({
-                  steps: /* @__PURE__ */ __name(({ context, event }) => {
-                    if (event.output.type !== "WAITING") return context.steps;
-                    return {
-                      ...context.steps,
-                      [stepNode.step.id]: {
-                        status: "waiting"
-                      }
-                    };
-                  }, "steps")
-                })
-              ]
-            },
-            {
-              guard: /* @__PURE__ */ __name(({ event }) => {
-                return event.output.type === "CONDITIONS_MET";
-              }, "guard"),
-              target: "executing"
-            },
-            {
-              guard: /* @__PURE__ */ __name(({ event }) => {
-                return event.output.type === "CONDITION_FAILED";
-              }, "guard"),
-              target: "failed",
-              actions: assign({
-                steps: /* @__PURE__ */ __name(({ context, event }) => {
-                  if (event.output.type !== "CONDITION_FAILED") return context.steps;
-                  this.logger.debug(`workflow condition check failed`, {
-                    error: event.output.error,
-                    stepId: stepNode.step.id
-                  });
-                  return {
-                    ...context.steps,
-                    [stepNode.step.id]: {
-                      status: "failed",
-                      error: event.output.error
-                    }
-                  };
-                }, "steps")
-              })
-            }
-          ]
-        }
-      },
-      waiting: {
-        entry: /* @__PURE__ */ __name(() => {
-          this.logger.debug(`Step ${stepNode.step.id} waiting ${(/* @__PURE__ */ new Date()).toISOString()}`);
-        }, "entry"),
-        exit: /* @__PURE__ */ __name(() => {
-          this.logger.debug(`Step ${stepNode.step.id} finished waiting ${(/* @__PURE__ */ new Date()).toISOString()}`);
-        }, "exit"),
-        after: {
-          [stepNode.step.id]: {
-            target: "pending"
-          }
-        }
-      },
-      suspended: {
-        type: "final",
-        entry: [
-          () => {
-            this.logger.debug(`Step ${stepNode.step.id} suspended`);
-          },
-          assign({
-            steps: /* @__PURE__ */ __name(({ context }) => ({
-              ...context.steps,
-              [stepNode.step.id]: {
-                ...context?.steps?.[stepNode.step.id] || {},
-                status: "suspended"
-              }
-            }), "steps")
-          })
-        ]
-      },
-      executing: {
-        entry: /* @__PURE__ */ __name(() => {
-          this.logger.debug(`Step ${stepNode.step.id} executing`);
-        }, "entry"),
-        on: {
-          SUSPENDED: {
-            target: "suspended",
-            actions: [
-              assign({
-                steps: /* @__PURE__ */ __name(({ context }) => ({
-                  ...context.steps,
-                  [stepNode.step.id]: {
-                    status: "suspended"
-                  }
-                }), "steps")
-              })
-            ]
-          }
-        },
-        invoke: {
-          src: "resolverFunction",
-          input: /* @__PURE__ */ __name(({ context }) => ({
-            context,
-            stepNode
-          }), "input"),
-          onDone: {
-            target: "runningSubscribers",
-            actions: [
-              ({ event }) => this.logger.debug(`Step ${stepNode.step.id} finished executing`, {
-                output: event.output
-              }),
-              {
-                type: "updateStepResult",
-                params: {
-                  stepId: stepNode.step.id
-                }
-              },
-              {
-                type: "spawnSubscribers",
-                params: {
-                  stepId: stepNode.step.id
-                }
-              }
-            ]
-          },
-          onError: {
-            target: "failed",
-            actions: [
-              {
-                type: "setStepError",
-                params: {
-                  stepId: stepNode.step.id
-                }
-              }
-            ]
-          }
-        }
-      },
-      runningSubscribers: {
-        entry: /* @__PURE__ */ __name(() => {
-          this.logger.debug(`Step ${stepNode.step.id} running subscribers`);
-        }, "entry"),
-        exit: /* @__PURE__ */ __name(() => {
-          this.logger.debug(`Step ${stepNode.step.id} finished running subscribers`);
-        }, "exit"),
-        invoke: {
-          src: "spawnSubscriberFunction",
-          input: /* @__PURE__ */ __name(({ context }) => ({
-            parentStepId: stepNode.step.id,
-            context
-          }), "input"),
-          onDone: {
-            target: nextStep ? nextStep.step.id : "completed",
-            actions: [
-              assign({
-                steps: /* @__PURE__ */ __name(({ context, event }) => ({
-                  ...context.steps,
-                  ...event.output.steps
-                }), "steps")
-              }),
-              () => this.logger.debug(`Subscriber execution completed`, {
-                stepId: stepNode.step.id
-              })
-            ]
-          },
-          onError: {
-            target: nextStep ? nextStep.step.id : "completed",
-            actions: /* @__PURE__ */ __name(({ event }) => {
-              this.logger.debug(`Subscriber execution failed`, {
-                error: event.error,
-                stepId: stepNode.step.id
-              });
-            }, "actions")
-          }
-        }
-      },
-      completed: {
-        type: "final",
-        entry: [
-          {
-            type: "notifyStepCompletion",
-            params: {
-              stepId: stepNode.step.id
-            }
-          },
-          {
-            type: "snapshotStep",
-            params: {
-              stepId: stepNode.step.id
-            }
-          },
-          {
-            type: "persistSnapshot"
-          }
-        ]
-      },
-      failed: {
-        type: "final",
-        entry: [
-          {
-            type: "notifyStepCompletion",
-            params: {
-              stepId: stepNode.step.id
-            }
-          },
-          {
-            type: "snapshotStep",
-            params: {
-              stepId: stepNode.step.id
-            }
-          },
-          {
-            type: "persistSnapshot"
-          }
-        ]
-      },
-      // build chain of next steps recursively
-      ...nextStep ? {
-        [nextStep.step.id]: {
-          ...__privateMethod(this, _Workflow_instances, buildBaseState_fn).call(this, nextStep, nextSteps)
-        }
-      } : {}
-    }
-  };
-}, "#buildBaseState");
-makeStepKey_fn = /* @__PURE__ */ __name(function(step) {
-  return `${step.id}`;
-}, "#makeStepKey");
-/**
-* Builds the state hierarchy for the workflow
-* @returns Object representing the state hierarchy
-*/
-buildStateHierarchy_fn = /* @__PURE__ */ __name(function(stepGraph) {
-  const states = {};
-  stepGraph.initial.forEach((stepNode) => {
-    const nextSteps = [
-      ...stepGraph[stepNode.step.id] || []
-    ];
-    states[stepNode.step.id] = {
-      ...__privateMethod(this, _Workflow_instances, buildBaseState_fn).call(this, stepNode, nextSteps)
-    };
-  });
-  return states;
-}, "#buildStateHierarchy");
-getDefaultActions_fn = /* @__PURE__ */ __name(function() {
-  return {
-    updateStepResult: assign({
-      steps: /* @__PURE__ */ __name(({ context, event }) => {
-        if (!isTransitionEvent(event)) return context.steps;
-        const { stepId, result } = event.output;
-        return {
-          ...context.steps,
-          [stepId]: {
-            status: "success",
-            output: result
-          }
-        };
-      }, "steps")
-    }),
-    setStepError: assign({
-      steps: /* @__PURE__ */ __name(({ 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
-          }
-        };
-      }, "steps")
-    }),
-    notifyStepCompletion: /* @__PURE__ */ __name(async (_, params) => {
-      const { stepId } = params;
-      this.logger.debug(`Step ${stepId} completed`);
-    }, "notifyStepCompletion"),
-    snapshotStep: assign({
-      _snapshot: /* @__PURE__ */ __name(({}, params) => {
-        const { stepId } = params;
-        return {
-          stepId
-        };
-      }, "_snapshot")
-    }),
-    persistSnapshot: /* @__PURE__ */ __name(async ({ context }) => {
-      if (context._snapshot) {
-        return await __privateMethod(this, _Workflow_instances, persistWorkflowSnapshot_fn).call(this);
-      }
-      return;
-    }, "persistSnapshot"),
-    decrementAttemptCount: assign({
-      attempts: /* @__PURE__ */ __name(({ context, event }, params) => {
-        if (!isTransitionEvent(event)) return context.attempts;
-        const { stepId } = params;
-        const attemptCount = context.attempts[stepId];
-        if (attemptCount === undefined) return context.attempts;
-        return {
-          ...context.attempts,
-          [stepId]: attemptCount - 1
-        };
-      }, "attempts")
-    })
-  };
-}, "#getDefaultActions");
-getInjectables_fn = /* @__PURE__ */ __name(function() {
-  return {
-    runId: __privateGet(this, _runId),
-    mastra: __privateGet(this, _mastra)
-  };
-}, "#getInjectables");
-getDefaultActors_fn = /* @__PURE__ */ __name(function() {
-  return {
-    resolverFunction: fromPromise(async ({ input }) => {
-      const { stepNode, context } = input;
-      const injectables = __privateMethod(this, _Workflow_instances, getInjectables_fn).call(this);
-      const resolvedData = __privateMethod(this, _Workflow_instances, resolveVariables_fn).call(this, {
-        stepConfig: stepNode.config,
-        context,
-        stepId: stepNode.step.id
-      });
-      this.logger.debug(`Resolved variables for ${stepNode.step.id}`, {
-        resolvedData,
-        runId: __privateGet(this, _runId)
-      });
-      const result = await stepNode.config.handler({
-        context: resolvedData,
-        suspend: /* @__PURE__ */ __name(async () => {
-          if (__privateGet(this, _actor)) {
-            context.steps[stepNode.step.id] = {
-              status: "suspended"
-            };
-            await __privateMethod(this, _Workflow_instances, persistWorkflowSnapshot_fn).call(this);
-            this.logger.debug(`Sending SUSPENDED event for step ${stepNode.step.id}`);
-            __privateGet(this, _actor)?.send({
-              type: "SUSPENDED",
-              stepId: stepNode.step.id
-            });
-          } else {
-            this.logger.debug(`Actor not available for step ${stepNode.step.id}`);
-          }
-        }, "suspend"),
-        ...injectables
-      });
-      this.logger.debug(`Step ${stepNode.step.id} result`, {
-        result,
-        runId: __privateGet(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 ${stepNode.step.id}`, {
-        stepId: stepNode.step.id,
-        runId: __privateGet(this, _runId)
-      });
-      this.logger.debug(`Attempt count for ${stepNode.step.id}`, {
-        attemptCount,
-        attempts: context.attempts,
-        runId: __privateGet(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 ${stepNode.step.id}`);
-      if (typeof stepConfig?.when === "function") {
-        const conditionMet = await stepConfig.when({
-          context
-        });
-        if (conditionMet) {
-          this.logger.debug(`Condition met for ${stepNode.step.id}`);
-          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 = __privateMethod(this, _Workflow_instances, evaluateCondition_fn).call(this, 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 = __privateGet(this, _stepSubscriberGraph)[parentStepId];
-      if (!stepGraph) {
-        return {
-          steps: {}
-        };
-      }
-      const subscriberMachine = setup({
-        types: {},
-        delays: __privateMethod(this, _Workflow_instances, makeDelayMap_fn).call(this),
-        actions: __privateMethod(this, _Workflow_instances, getDefaultActions_fn).call(this),
-        actors: __privateMethod(this, _Workflow_instances, getDefaultActors_fn).call(this)
-      }).createMachine({
-        id: `${this.name}-subscriber-${parentStepId}`,
-        context,
-        type: "parallel",
-        states: __privateMethod(this, _Workflow_instances, buildStateHierarchy_fn).call(this, stepGraph)
-      });
-      const actor = createActor(subscriberMachine, {
-        input: context
-      });
-      actor.start();
-      return new Promise((resolve) => {
-        const suspendedPaths = /* @__PURE__ */ new Set();
-        actor.subscribe((state) => {
-          __privateMethod(this, _Workflow_instances, getSuspendedPaths_fn).call(this, {
-            value: state.value,
-            path: "",
-            suspendedPaths
-          });
-          const allStatesValue = state.value;
-          const allStatesComplete = __privateMethod(this, _Workflow_instances, recursivelyCheckForFinalState_fn).call(this, {
-            value: allStatesValue,
-            suspendedPaths,
-            path: ""
-          });
-          if (allStatesComplete) {
-            actor.stop();
-            resolve({
-              steps: state.context.steps
-            });
-          }
-        });
-      });
-    })
-  };
-}, "#getDefaultActors");
-persistWorkflowSnapshot_fn = /* @__PURE__ */ __name(async function() {
-  const snapshotFromActor = __privateGet(this, _actor)?.getPersistedSnapshot();
-  if (!__privateGet(this, _mastra)?.storage) {
-    this.logger.debug("Snapshot cannot be persisted. Mastra engine is not initialized", {
-      runId: __privateGet(this, _runId)
-    });
-    return;
-  }
-  if (!snapshotFromActor) {
-    this.logger.debug("Snapshot cannot be persisted. No snapshot received.", {
-      runId: __privateGet(this, _runId)
-    });
-    return;
-  }
-  if (__privateGet(this, _mastra)?.storage) {
-    await __privateGet(this, _mastra).storage.persistWorkflowSnapshot({
-      workflowName: this.name,
-      runId: __privateGet(this, _runId),
-      snapshot: snapshotFromActor
-    });
-  }
-  return __privateGet(this, _runId);
-}, "#persistWorkflowSnapshot");
-loadWorkflowSnapshot_fn = /* @__PURE__ */ __name(async function(runId) {
-  if (!__privateGet(this, _mastra)?.storage) {
-    this.logger.debug("Snapshot cannot be loaded. Mastra engine is not initialized", {
-      runId
-    });
-    return;
-  }
-  return __privateGet(this, _mastra).storage.loadWorkflowSnapshot({
-    runId,
-    workflowName: this.name
-  });
-}, "#loadWorkflowSnapshot");
-/**
-* 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
-*/
-resolveVariables_fn = /* @__PURE__ */ __name(function({ stepConfig, context, stepId }) {
-  this.logger.debug(`Resolving variables for ${stepId}`, {
-    runId: __privateGet(this, _runId)
-  });
-  const resolvedData = {
-    ...context,
-    getStepPayload: /* @__PURE__ */ __name((stepId2) => {
-      if (stepId2 === "trigger") {
-        return context.triggerData;
-      }
-      const result = context.steps[stepId2];
-      if (result && result.status === "success") {
-        return result.output;
-      }
-      return undefined;
-    }, "getStepPayload")
-  };
-  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: __privateGet(this, _runId)
-    });
-    if (!sourceData && variable.step !== "trigger") {
-      resolvedData[key] = undefined;
-      continue;
-    }
-    const value = variable.path === "" || variable.path === "." ? sourceData : get(sourceData, variable.path);
-    this.logger.debug(`Resolved variable ${key}`, {
-      value,
-      runId: __privateGet(this, _runId)
-    });
-    resolvedData[key] = value;
-  }
-  return resolvedData;
-}, "#resolveVariables");
-/**
-* Evaluates a single condition against workflow context
-*/
-evaluateCondition_fn = /* @__PURE__ */ __name(function(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 ${stepId}`, {
-      sourceData,
-      runId: __privateGet(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: __privateGet(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) => __privateMethod(this, _Workflow_instances, evaluateCondition_fn).call(this, cond, context));
-    this.logger.debug(`Evaluated AND condition`, {
-      andBranchResult,
-      runId: __privateGet(this, _runId)
-    });
-  }
-  if ("or" in condition) {
-    orBranchResult = condition.or.some((cond) => __privateMethod(this, _Workflow_instances, evaluateCondition_fn).call(this, cond, context));
-    this.logger.debug(`Evaluated OR condition`, {
-      orBranchResult,
-      runId: __privateGet(this, _runId)
-    });
-  }
-  const finalResult = baseResult && andBranchResult && orBranchResult;
-  this.logger.debug(`Evaluated condition`, {
-    finalResult,
-    runId: __privateGet(this, _runId)
-  });
-  return finalResult;
-}, "#evaluateCondition");
-makeStepDef_fn = /* @__PURE__ */ __name(function(stepId) {
-  const telemetry = __privateGet(this, _mastra)?.telemetry;
-  const handler = /* @__PURE__ */ __name(async ({ context, ...rest }) => {
-    const targetStep = __privateGet(this, _steps)[stepId];
-    if (!targetStep) throw new Error(`Step not found`);
-    const { payload = {}, execute } = targetStep;
-    const mergedData = {
-      ...payload,
-      ...context
-    };
-    const finalAction = telemetry ? telemetry.traceMethod(execute, {
-      spanName: `workflow.${this.name}.action.${stepId}`
-    }) : execute;
-    return finalAction ? await finalAction({
-      context: mergedData,
-      ...rest
-    }) : {};
-  }, "handler");
-  const finalHandler = telemetry ? telemetry.traceMethod(handler, {
-    spanName: `workflow.${this.name}.step.${stepId}`
-  }) : handler;
-  return {
-    handler: finalHandler,
-    data: {}
-  };
-}, "#makeStepDef");
-/**
-* Creates a map of step IDs to their respective delay values
-* @returns Object mapping step IDs to delay values
-*/
-makeDelayMap_fn = /* @__PURE__ */ __name(function() {
-  const delayMap = {};
-  Object.keys(__privateGet(this, _steps)).forEach((stepId) => {
-    delayMap[stepId] = __privateGet(this, _steps)[stepId]?.retryConfig?.delay || __privateGet(this, _retryConfig)?.delay || 1e3;
-  });
-  return delayMap;
-}, "#makeDelayMap");
-/**
-* Cleans up the actor instance
-*/
-cleanup_fn = /* @__PURE__ */ __name(function() {
-  if (__privateGet(this, _actor)) {
-    __privateGet(this, _actor).stop();
-    __privateSet(this, _actor, null);
-  }
-}, "#cleanup");
-getActivePathsAndStatus_fn = /* @__PURE__ */ __name(function(value) {
-  const paths = [];
-  const traverse = /* @__PURE__ */ __name((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);
-      }
-    }
-  }, "traverse");
-  traverse(value);
-  return paths;
-}, "#getActivePathsAndStatus");
-hasStateChanged_fn = /* @__PURE__ */ __name(function(previous, current) {
-  if (!previous) return true;
-  const previousPaths = previous.activePaths;
-  const currentPaths = current.activePaths;
-  if (previousPaths.length !== currentPaths.length) return true;
-  for (let i = 0; i < currentPaths.length; i++) {
-    const prevPath = previousPaths[i];
-    const currPath = currentPaths[i];
-    if (JSON.stringify(prevPath?.stepPath) !== JSON.stringify(currPath?.stepPath)) return true;
-    if (prevPath?.status !== currPath?.status) return true;
-  }
-  if (JSON.stringify(previous.context.steps) !== JSON.stringify(current.context.steps)) return true;
-  return false;
-}, "#hasStateChanged");
-getDeepestState_fn = /* @__PURE__ */ __name(function(value) {
-  let deepestBranch = null;
-  const traverse = /* @__PURE__ */ __name((obj, path = []) => {
-    for (const [key, value2] of Object.entries(obj)) {
-      if (typeof value2 === "string") {
-        const depth = path.length;
-        if (!deepestBranch || depth > deepestBranch.depth) {
-          deepestBranch = {
-            stepId: key,
-            status: value2,
-            depth
-          };
-        }
-      } else if (typeof value2 === "object" && value2 !== null) {
-        traverse(value2, [
-          ...path,
-          key
-        ]);
-      }
-    }
-  }, "traverse");
-  traverse(value);
-  if (!deepestBranch) {
-    throw new Error("No valid state found");
-  }
-  return {
-    stepId: deepestBranch?.stepId,
-    status: deepestBranch?.status
-  };
-}, "#getDeepestState");
-__name(_Workflow, "Workflow");
-var Workflow = _Workflow;
-
-// src/workflows/step.ts
-var _Step = class _Step {
-  constructor({ id, description, execute, payload, outputSchema, inputSchema, retryConfig }) {
-    __publicField(this, "id");
-    __publicField(this, "description");
-    __publicField(this, "inputSchema");
-    __publicField(this, "outputSchema");
-    __publicField(this, "payload");
-    __publicField(this, "execute");
-    __publicField(this, "retryConfig");
-    __publicField(this, "mastra");
-    this.id = id;
-    this.description = description ?? "";
-    this.inputSchema = inputSchema;
-    this.payload = payload;
-    this.outputSchema = outputSchema;
-    this.execute = execute;
-    this.retryConfig = retryConfig;
-  }
-};
-__name(_Step, "Step");
-var Step = _Step;
-function createStep(opts) {
-  return new Step(opts);
-}
-__name(createStep, "createStep");
-
-export { Step, Workflow, createStep, getStepResult, isErrorEvent, isTransitionEvent, isVariableReference };