@mastra/core 0.1.27-alpha.30 → 0.1.27-alpha.32

package/dist/core.cjs.development.js

@@ -3957,6 +3957,18 @@ exports.Mastra = (_workflows = /*#__PURE__*/_classPrivateFieldLooseKey("workflow
     }
     return agent;
   };
+  _proto.getAgents = function getAgents() {
+    return Array.from(this.agents.entries()).map(function (_ref3) {
+      var name = _ref3[0],
+        agent = _ref3[1];
+      return {
+        name: name,
+        instructions: agent.instructions,
+        modelProvider: agent.model.provider,
+        modelName: agent.model.name
+      };
+    });
+  };
   _proto.getWorkflow = function getWorkflow(name) {
     var workflow = _classPrivateFieldLooseBase(this, _workflows)[_workflows].get(name);
     if (!workflow) {
@@ -3980,7 +3992,7 @@ exports.Mastra = (_workflows = /*#__PURE__*/_classPrivateFieldLooseKey("workflow
       throw new Error("Tool with name " + String(name) + " not found");
     }
     var hydratedExecutor = /*#__PURE__*/function () {
-      var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(params, runId) {
+      var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(params, runId) {
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -4006,7 +4018,7 @@ exports.Mastra = (_workflows = /*#__PURE__*/_classPrivateFieldLooseKey("workflow
         }, _callee2);
       }));
       return function hydratedExecutor(_x4, _x5) {
-        return _ref3.apply(this, arguments);
+        return _ref4.apply(this, arguments);
       };
     }();
     return _extends({}, tool, {
@@ -4019,9 +4031,9 @@ exports.Mastra = (_workflows = /*#__PURE__*/_classPrivateFieldLooseKey("workflow
     });
   };
   _proto.availableIntegrations = function availableIntegrations() {
-    return Array.from(this.integrations.entries()).map(function (_ref4) {
-      var name = _ref4[0],
-        integration = _ref4[1];
+    return Array.from(this.integrations.entries()).map(function (_ref5) {
+      var name = _ref5[0],
+        integration = _ref5[1];
       return {
         name: name,
         integration: integration
@@ -4031,8 +4043,8 @@ exports.Mastra = (_workflows = /*#__PURE__*/_classPrivateFieldLooseKey("workflow
   _proto.getTools = function getTools() {
     return this.tools;
   };
-  _proto.setLogger = function setLogger(_ref5) {
-    var logger = _ref5.logger;
+  _proto.setLogger = function setLogger(_ref6) {
+    var logger = _ref6.logger;
     this.logger = logger;
   };
   _proto.getLogger = function getLogger() {
@@ -4092,13 +4104,17 @@ var _engine = /*#__PURE__*/_classPrivateFieldLooseKey("engine");
 var _connectionId = /*#__PURE__*/_classPrivateFieldLooseKey("connectionId");
 var _entityName = /*#__PURE__*/_classPrivateFieldLooseKey("entityName");
 var _telemetry = /*#__PURE__*/_classPrivateFieldLooseKey("telemetry");
+var _afterStepStack = /*#__PURE__*/_classPrivateFieldLooseKey("afterStepStack");
 var _lastStepStack = /*#__PURE__*/_classPrivateFieldLooseKey("lastStepStack");
 var _stepGraph = /*#__PURE__*/_classPrivateFieldLooseKey("stepGraph");
+var _stepSubscriberGraph = /*#__PURE__*/_classPrivateFieldLooseKey("stepSubscriberGraph");
 var _steps = /*#__PURE__*/_classPrivateFieldLooseKey("steps");
 var _recursivelyCheckForFinalState = /*#__PURE__*/_classPrivateFieldLooseKey("recursivelyCheckForFinalState");
 var _buildBaseState = /*#__PURE__*/_classPrivateFieldLooseKey("buildBaseState");
 var _makeStepKey = /*#__PURE__*/_classPrivateFieldLooseKey("makeStepKey");
 var _buildStateHierarchy = /*#__PURE__*/_classPrivateFieldLooseKey("buildStateHierarchy");
+var _getDefaultActions = /*#__PURE__*/_classPrivateFieldLooseKey("getDefaultActions");
+var _getDefaultActors = /*#__PURE__*/_classPrivateFieldLooseKey("getDefaultActors");
 var _persistWorkflowSnapshot = /*#__PURE__*/_classPrivateFieldLooseKey("persistWorkflowSnapshot");
 var _loadWorkflowSnapshot = /*#__PURE__*/_classPrivateFieldLooseKey("loadWorkflowSnapshot");
 var _resolveVariables = /*#__PURE__*/_classPrivateFieldLooseKey("resolveVariables");
@@ -4170,6 +4186,12 @@ var Workflow = /*#__PURE__*/function () {
     Object.defineProperty(this, _persistWorkflowSnapshot, {
       value: _persistWorkflowSnapshot2
     });
+    Object.defineProperty(this, _getDefaultActors, {
+      value: _getDefaultActors2
+    });
+    Object.defineProperty(this, _getDefaultActions, {
+      value: _getDefaultActions2
+    });
     /**
      * Builds the state hierarchy for the workflow
      * @returns Object representing the state hierarchy
@@ -4230,7 +4252,10 @@ var Workflow = /*#__PURE__*/function () {
       value: void 0
     });
     // registers stepIds on `after` calls
-    // #afterStepStack: string[] = [];
+    Object.defineProperty(this, _afterStepStack, {
+      writable: true,
+      value: []
+    });
     Object.defineProperty(this, _lastStepStack, {
       writable: true,
       value: []
@@ -4241,6 +4266,10 @@ var Workflow = /*#__PURE__*/function () {
         initial: []
       }
     });
+    Object.defineProperty(this, _stepSubscriberGraph, {
+      writable: true,
+      value: {}
+    });
     // #delimiter = '-([-]::[-])-';
     Object.defineProperty(this, _steps, {
       writable: true,
@@ -4266,191 +4295,27 @@ var Workflow = /*#__PURE__*/function () {
    */
   var _proto = Workflow.prototype;
   _proto.initializeMachine = function initializeMachine() {
-    var _this = this;
     var machine = xstate.setup({
       types: {},
       delays: _classPrivateFieldLooseBase(this, _makeDelayMap)[_makeDelayMap](),
-      actions: {
-        updateStepResult: xstate.assign({
-          stepResults: function stepResults(_ref2) {
-            var _extends2;
-            var context = _ref2.context,
-              event = _ref2.event;
-            if (!isTransitionEvent(event)) return context.stepResults;
-            var _event$output = event.output,
-              stepId = _event$output.stepId,
-              result = _event$output.result;
-            return _extends({}, context.stepResults, (_extends2 = {}, _extends2[stepId] = {
-              status: 'success',
-              payload: result
-            }, _extends2));
-          }
-        }),
-        setStepError: xstate.assign({
-          stepResults: function stepResults(_ref3, params) {
-            var _extends3;
-            var context = _ref3.context,
-              event = _ref3.event;
-            if (!isErrorEvent(event)) return context.stepResults;
-            var stepId = params.stepId;
-            if (!stepId) return context.stepResults;
-            return _extends({}, context.stepResults, (_extends3 = {}, _extends3[stepId] = {
-              status: 'failed',
-              error: event.error.message
-            }, _extends3));
-          }
-        }),
-        notifyStepCompletion: function notifyStepCompletion(_, params) {
-          var stepId = params.stepId;
-          _classPrivateFieldLooseBase(_this, _log)[_log](LogLevel.INFO, "Step " + stepId + " completed");
-        },
-        decrementAttemptCount: xstate.assign({
-          attempts: function attempts(_ref4, params) {
-            var _extends4;
-            var context = _ref4.context,
-              event = _ref4.event;
-            if (!isTransitionEvent(event)) return context.attempts;
-            var stepId = params.stepId;
-            var attemptCount = context.attempts[stepId];
-            if (attemptCount === undefined) return context.attempts;
-            return _extends({}, context.attempts, (_extends4 = {}, _extends4[stepId] = attemptCount - 1, _extends4));
-          }
-        })
-      },
-      actors: {
-        resolverFunction: xstate.fromPromise(/*#__PURE__*/function () {
-          var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref5) {
-            var input, stepNode, context, resolvedData, result;
-            return _regeneratorRuntime().wrap(function _callee$(_context) {
-              while (1) switch (_context.prev = _context.next) {
-                case 0:
-                  input = _ref5.input;
-                  stepNode = input.stepNode, context = input.context;
-                  resolvedData = _classPrivateFieldLooseBase(_this, _resolveVariables)[_resolveVariables]({
-                    stepConfig: stepNode.config,
-                    context: context
-                  });
-                  _context.next = 5;
-                  return stepNode.config.handler({
-                    context: _extends({
-                      stepResults: context.stepResults
-                    }, resolvedData),
-                    runId: _classPrivateFieldLooseBase(_this, _runId)[_runId]
-                  });
-                case 5:
-                  result = _context.sent;
-                  return _context.abrupt("return", {
-                    stepId: stepNode.step.id,
-                    result: result
-                  });
-                case 7:
-                case "end":
-                  return _context.stop();
-              }
-            }, _callee);
-          }));
-          return function (_x) {
-            return _ref6.apply(this, arguments);
-          };
-        }()),
-        dependencyCheck: xstate.fromPromise(/*#__PURE__*/function () {
-          var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref7) {
-            var input, context, stepNode, stepConfig, attemptCount, conditionMet, _conditionMet;
-            return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-              while (1) switch (_context2.prev = _context2.next) {
-                case 0:
-                  input = _ref7.input;
-                  context = input.context, stepNode = input.stepNode;
-                  stepConfig = stepNode.config; // TODO: Need a way to create unique ids for steps
-                  attemptCount = context.attempts[stepNode.step.id];
-                  if (!(!attemptCount || attemptCount < 0)) {
-                    _context2.next = 8;
-                    break;
-                  }
-                  if (!(stepConfig != null && stepConfig.snapshotOnTimeout)) {
-                    _context2.next = 7;
-                    break;
-                  }
-                  return _context2.abrupt("return", {
-                    type: 'SUSPENDED',
-                    stepId: stepNode.step.id
-                  });
-                case 7:
-                  return _context2.abrupt("return", {
-                    type: 'TIMED_OUT',
-                    error: "Step:" + stepNode.step.id + " timed out"
-                  });
-                case 8:
-                  if (stepConfig != null && stepConfig.when) {
-                    _context2.next = 10;
-                    break;
-                  }
-                  return _context2.abrupt("return", {
-                    type: 'DEPENDENCIES_MET'
-                  });
-                case 10:
-                  if (!(typeof (stepConfig == null ? void 0 : stepConfig.when) === 'function')) {
-                    _context2.next = 18;
-                    break;
-                  }
-                  _context2.next = 13;
-                  return stepConfig.when({
-                    context: context
-                  });
-                case 13:
-                  conditionMet = _context2.sent;
-                  if (conditionMet) {
-                    _context2.next = 16;
-                    break;
-                  }
-                  return _context2.abrupt("return", {
-                    type: 'CONDITION_FAILED',
-                    error: "Step:" + stepNode.step.id + " condition function check failed"
-                  });
-                case 16:
-                  _context2.next = 21;
-                  break;
-                case 18:
-                  _conditionMet = _classPrivateFieldLooseBase(_this, _evaluateCondition)[_evaluateCondition](stepConfig.when, context);
-                  if (_conditionMet) {
-                    _context2.next = 21;
-                    break;
-                  }
-                  return _context2.abrupt("return", {
-                    type: 'CONDITION_FAILED',
-                    error: "Step:" + stepNode.step.id + " condition check failed"
-                  });
-                case 21:
-                  return _context2.abrupt("return", {
-                    type: 'DEPENDENCIES_MET'
-                  });
-                case 22:
-                case "end":
-                  return _context2.stop();
-              }
-            }, _callee2);
-          }));
-          return function (_x2) {
-            return _ref8.apply(this, arguments);
-          };
-        }())
-      }
+      actions: _classPrivateFieldLooseBase(this, _getDefaultActions)[_getDefaultActions](),
+      actors: _classPrivateFieldLooseBase(this, _getDefaultActors)[_getDefaultActors]()
     }).createMachine({
       id: this.name,
       type: 'parallel',
-      context: function context(_ref9) {
-        var input = _ref9.input;
+      context: function context(_ref2) {
+        var input = _ref2.input;
         return _extends({}, input);
       },
-      states: _classPrivateFieldLooseBase(this, _buildStateHierarchy)[_buildStateHierarchy]()
+      states: _classPrivateFieldLooseBase(this, _buildStateHierarchy)[_buildStateHierarchy](_classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph])
     });
     _classPrivateFieldLooseBase(this, _machine)[_machine] = machine;
     return machine;
   };
   _proto.step = function step(_step, config) {
-    var _ref10 = config || {},
-      _ref10$variables = _ref10.variables,
-      variables = _ref10$variables === void 0 ? {} : _ref10$variables;
+    var _ref3 = config || {},
+      _ref3$variables = _ref3.variables,
+      variables = _ref3$variables === void 0 ? {} : _ref3$variables;
     var requiredData = {};
     // Add valid variables to requiredData
     for (var _i = 0, _Object$entries = Object.entries(variables); _i < _Object$entries.length; _i++) {
@@ -4469,15 +4334,30 @@ var Workflow = /*#__PURE__*/function () {
       })
     };
     _classPrivateFieldLooseBase(this, _steps)[_steps][stepKey] = _step;
-    if (!_classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][stepKey]) _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][stepKey] = [];
-    _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph].initial.push(graphEntry);
+    var parentStepKey = _classPrivateFieldLooseBase(this, _afterStepStack)[_afterStepStack][_classPrivateFieldLooseBase(this, _afterStepStack)[_afterStepStack].length - 1];
+    var stepGraph = _classPrivateFieldLooseBase(this, _stepSubscriberGraph)[_stepSubscriberGraph][parentStepKey || ''];
+    // if we are in an after chain and we have a stepGraph
+    if (parentStepKey && stepGraph) {
+      // if the stepGraph has an initial, but it doesn't contain the current step, add it to the initial
+      if (!stepGraph.initial.some(function (step) {
+        return step.step.id === stepKey;
+      })) {
+        stepGraph.initial.push(graphEntry);
+      }
+      // add the current step to the stepGraph
+      stepGraph[stepKey] = [];
+    } else {
+      // Normal step addition to main graph
+      if (!_classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][stepKey]) _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][stepKey] = [];
+      _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph].initial.push(graphEntry);
+    }
     _classPrivateFieldLooseBase(this, _lastStepStack)[_lastStepStack].push(stepKey);
     return this;
   };
   _proto.then = function then(step, config) {
-    var _ref11 = config || {},
-      _ref11$variables = _ref11.variables,
-      variables = _ref11$variables === void 0 ? {} : _ref11$variables;
+    var _ref4 = config || {},
+      _ref4$variables = _ref4.variables,
+      variables = _ref4$variables === void 0 ? {} : _ref4$variables;
     var requiredData = {};
     // Add valid variables to requiredData
     for (var _i2 = 0, _Object$entries2 = Object.entries(variables); _i2 < _Object$entries2.length; _i2++) {
@@ -4499,10 +4379,27 @@ var Workflow = /*#__PURE__*/function () {
     _classPrivateFieldLooseBase(this, _steps)[_steps][stepKey] = step;
     // if then is called without a step, we are done
     if (!lastStepKey) return this;
-    // add the step to the graph if not already there.. it should be there though, unless magic
-    if (!_classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey]) _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey] = [];
-    // add the step to the graph
-    _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey].push(graphEntry);
+    var parentStepKey = _classPrivateFieldLooseBase(this, _afterStepStack)[_afterStepStack][_classPrivateFieldLooseBase(this, _afterStepStack)[_afterStepStack].length - 1];
+    var stepGraph = _classPrivateFieldLooseBase(this, _stepSubscriberGraph)[_stepSubscriberGraph][parentStepKey || ''];
+    if (parentStepKey && stepGraph && stepGraph[lastStepKey]) {
+      stepGraph[lastStepKey].push(graphEntry);
+    } else {
+      // add the step to the graph if not already there.. it should be there though, unless magic
+      if (!_classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey]) _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey] = [];
+      // add the step to the graph
+      _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey].push(graphEntry);
+    }
+    return this;
+  };
+  _proto.after = function after(step) {
+    var stepKey = _classPrivateFieldLooseBase(this, _makeStepKey)[_makeStepKey](step);
+    _classPrivateFieldLooseBase(this, _afterStepStack)[_afterStepStack].push(stepKey);
+    // Initialize subscriber array for this step if it doesn't exist
+    if (!_classPrivateFieldLooseBase(this, _stepSubscriberGraph)[_stepSubscriberGraph][stepKey]) {
+      _classPrivateFieldLooseBase(this, _stepSubscriberGraph)[_stepSubscriberGraph][stepKey] = {
+        initial: []
+      };
+    }
     return this;
   }
   /**
@@ -4514,22 +4411,22 @@ var Workflow = /*#__PURE__*/function () {
   _proto.execute =
   /*#__PURE__*/
   function () {
-    var _execute = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_temp) {
-      var _this2 = this;
-      var _ref12, triggerData, loadSnapshot, snapshot;
-      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-        while (1) switch (_context3.prev = _context3.next) {
+    var _execute = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_temp) {
+      var _this = this;
+      var _ref5, triggerData, loadSnapshot, snapshot;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
           case 0:
-            _ref12 = _temp === void 0 ? {} : _temp, triggerData = _ref12.triggerData, loadSnapshot = _ref12.loadSnapshot;
+            _ref5 = _temp === void 0 ? {} : _temp, triggerData = _ref5.triggerData, loadSnapshot = _ref5.loadSnapshot;
             if (!(loadSnapshot && loadSnapshot.runId)) {
-              _context3.next = 7;
+              _context.next = 7;
               break;
             }
-            _context3.next = 4;
+            _context.next = 4;
             return _classPrivateFieldLooseBase(this, _loadWorkflowSnapshot)[_loadWorkflowSnapshot](loadSnapshot.runId);
           case 4:
-            snapshot = _context3.sent;
-            _context3.next = 8;
+            snapshot = _context.sent;
+            _context.next = 8;
             break;
           case 7:
             _classPrivateFieldLooseBase(this, _runId)[_runId] = crypto.randomUUID();
@@ -4537,54 +4434,56 @@ var Workflow = /*#__PURE__*/function () {
             if (snapshot) {
               snapshot = JSON.parse(snapshot);
             }
-            _context3.next = 11;
+            _context.next = 11;
             return _classPrivateFieldLooseBase(this, _log)[_log](LogLevel.INFO, 'Executing workflow', {
               triggerData: triggerData
             });
           case 11:
             if (!_classPrivateFieldLooseBase(this, _triggerSchema)[_triggerSchema]) {
-              _context3.next = 23;
+              _context.next = 23;
               break;
             }
-            _context3.prev = 12;
+            _context.prev = 12;
             _classPrivateFieldLooseBase(this, _triggerSchema)[_triggerSchema].parse(triggerData);
-            _context3.next = 16;
+            _context.next = 16;
             return _classPrivateFieldLooseBase(this, _log)[_log](LogLevel.DEBUG, 'Trigger schema validation passed');
           case 16:
-            _context3.next = 23;
+            _context.next = 23;
             break;
           case 18:
-            _context3.prev = 18;
-            _context3.t0 = _context3["catch"](12);
-            _context3.next = 22;
+            _context.prev = 18;
+            _context.t0 = _context["catch"](12);
+            _context.next = 22;
             return _classPrivateFieldLooseBase(this, _log)[_log](LogLevel.ERROR, 'Trigger schema validation failed', {
-              error: _context3.t0
+              error: _context.t0
             });
           case 22:
-            throw _context3.t0;
+            throw _context.t0;
           case 23:
             _classPrivateFieldLooseBase(this, _actor)[_actor] = xstate.createActor(_classPrivateFieldLooseBase(this, _machine)[_machine], {
               input: {
                 stepResults: {},
+                spawnedActors: [],
+                completedActors: [],
                 triggerData: triggerData || {},
                 attempts: Object.keys(_classPrivateFieldLooseBase(this, _steps)[_steps]).reduce(function (acc, stepKey) {
                   var _classPrivateFieldLoo, _classPrivateFieldLoo2;
-                  acc[stepKey] = ((_classPrivateFieldLoo = _classPrivateFieldLooseBase(_this2, _steps)[_steps][stepKey]) == null || (_classPrivateFieldLoo = _classPrivateFieldLoo.retryConfig) == null ? void 0 : _classPrivateFieldLoo.attempts) || ((_classPrivateFieldLoo2 = _classPrivateFieldLooseBase(_this2, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo2.attempts) || 3;
+                  acc[stepKey] = ((_classPrivateFieldLoo = _classPrivateFieldLooseBase(_this, _steps)[_steps][stepKey]) == null || (_classPrivateFieldLoo = _classPrivateFieldLoo.retryConfig) == null ? void 0 : _classPrivateFieldLoo.attempts) || ((_classPrivateFieldLoo2 = _classPrivateFieldLooseBase(_this, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo2.attempts) || 3;
                   return acc;
                 }, {})
               },
               snapshot: snapshot
             });
             _classPrivateFieldLooseBase(this, _actor)[_actor].start();
-            return _context3.abrupt("return", new Promise(function (resolve, reject) {
-              if (!_classPrivateFieldLooseBase(_this2, _actor)[_actor]) {
+            return _context.abrupt("return", new Promise(function (resolve, reject) {
+              if (!_classPrivateFieldLooseBase(_this, _actor)[_actor]) {
                 reject(new Error('Actor not initialized'));
                 return;
               }
-              _classPrivateFieldLooseBase(_this2, _actor)[_actor].subscribe(function (state) {
+              _classPrivateFieldLooseBase(_this, _actor)[_actor].subscribe(function (state) {
                 // Check if all parallel states are in a final state
                 var allStatesValue = state.value;
-                var allStatesComplete = _classPrivateFieldLooseBase(_this2, _recursivelyCheckForFinalState)[_recursivelyCheckForFinalState](allStatesValue);
+                var allStatesComplete = _classPrivateFieldLooseBase(_this, _recursivelyCheckForFinalState)[_recursivelyCheckForFinalState](allStatesValue);
                 if (allStatesComplete) {
                   // Check if any steps failed
                   var hasFailures = Object.values(state.context.stepResults).some(function (result) {
@@ -4594,27 +4493,27 @@ var Workflow = /*#__PURE__*/function () {
                     return result.status === 'suspended';
                   });
                   if (hasSuspended) {
-                    _classPrivateFieldLooseBase(_this2, _persistWorkflowSnapshot)[_persistWorkflowSnapshot]();
+                    _classPrivateFieldLooseBase(_this, _persistWorkflowSnapshot)[_persistWorkflowSnapshot]();
                   }
                   if (hasFailures) {
-                    _classPrivateFieldLooseBase(_this2, _log)[_log](LogLevel.ERROR, 'Workflow failed', {
+                    _classPrivateFieldLooseBase(_this, _log)[_log](LogLevel.ERROR, 'Workflow failed', {
                       results: state.context.stepResults
                     });
-                    _classPrivateFieldLooseBase(_this2, _cleanup)[_cleanup]();
+                    _classPrivateFieldLooseBase(_this, _cleanup)[_cleanup]();
                     resolve({
                       triggerData: triggerData,
                       results: state.context.stepResults,
-                      runId: _classPrivateFieldLooseBase(_this2, _runId)[_runId]
+                      runId: _classPrivateFieldLooseBase(_this, _runId)[_runId]
                     });
                   } else {
-                    _classPrivateFieldLooseBase(_this2, _log)[_log](LogLevel.INFO, 'Workflow completed', {
+                    _classPrivateFieldLooseBase(_this, _log)[_log](LogLevel.INFO, 'Workflow completed', {
                       results: state.context.stepResults
                     });
-                    _classPrivateFieldLooseBase(_this2, _cleanup)[_cleanup]();
+                    _classPrivateFieldLooseBase(_this, _cleanup)[_cleanup]();
                     resolve({
                       triggerData: triggerData,
                       results: state.context.stepResults,
-                      runId: _classPrivateFieldLooseBase(_this2, _runId)[_runId]
+                      runId: _classPrivateFieldLooseBase(_this, _runId)[_runId]
                     });
                   }
                 }
@@ -4622,11 +4521,11 @@ var Workflow = /*#__PURE__*/function () {
             }));
           case 26:
           case "end":
-            return _context3.stop();
+            return _context.stop();
         }
-      }, _callee3, this, [[12, 18]]);
+      }, _callee, this, [[12, 18]]);
     }));
-    function execute(_x3) {
+    function execute(_x) {
       return _execute.apply(this, arguments);
     }
     return execute;
@@ -4662,18 +4561,18 @@ var Workflow = /*#__PURE__*/function () {
   }]);
 }();
 function _recursivelyCheckForFinalState2(value) {
-  var _this3 = this;
+  var _this2 = this;
   if (typeof value === 'string') {
     return ['completed', 'failed', 'suspended'].includes(value);
   }
   return Object.values(value).every(function (val) {
-    return _classPrivateFieldLooseBase(_this3, _recursivelyCheckForFinalState)[_recursivelyCheckForFinalState](val);
+    return _classPrivateFieldLooseBase(_this2, _recursivelyCheckForFinalState)[_recursivelyCheckForFinalState](val);
   });
 }
 function _buildBaseState2(stepNode, nextSteps) {
-  var _this4 = this,
+  var _this3 = this,
     _after,
-    _ref25;
+    _ref19;
   if (nextSteps === void 0) {
     nextSteps = [];
   }
@@ -4681,57 +4580,43 @@ function _buildBaseState2(stepNode, nextSteps) {
   var nextStep = nextSteps.shift();
   return {
     initial: 'pending',
-    entry: function entry(_ref13) {
-      var context = _ref13.context;
-      console.log({
-        stepNode: stepNode,
-        context: context
-      }, 'entry pending =============================');
-    },
-    exit: function exit(_ref14) {
-      var context = _ref14.context;
-      console.log({
-        stepNode: stepNode,
-        context: context
-      }, 'exit pending =============================');
-    },
     states: _extends({
       pending: {
         invoke: {
           src: 'dependencyCheck',
-          input: function input(_ref15) {
-            var context = _ref15.context;
+          input: function input(_ref6) {
+            var context = _ref6.context;
             return {
               context: context,
               stepNode: stepNode
             };
           },
           onDone: [{
-            guard: function guard(_ref16) {
-              var event = _ref16.event;
+            guard: function guard(_ref7) {
+              var event = _ref7.event;
               return event.output.type === 'SUSPENDED';
             },
             target: 'suspended',
             actions: xstate.assign({
-              stepResults: function stepResults(_ref17) {
-                var _extends5;
-                var context = _ref17.context,
-                  event = _ref17.event;
+              stepResults: function stepResults(_ref8) {
+                var _extends2;
+                var context = _ref8.context,
+                  event = _ref8.event;
                 if (event.output.type !== 'SUSPENDED') return context.stepResults;
-                return _extends({}, context.stepResults, (_extends5 = {}, _extends5[stepNode.step.id] = {
+                return _extends({}, context.stepResults, (_extends2 = {}, _extends2[stepNode.step.id] = {
                   status: 'suspended'
-                }, _extends5));
+                }, _extends2));
               }
             })
           }, {
-            guard: function guard(_ref18) {
-              var event = _ref18.event;
+            guard: function guard(_ref9) {
+              var event = _ref9.event;
               return event.output.type === 'DEPENDENCIES_MET';
             },
             target: 'executing'
           }, {
-            guard: function guard(_ref19) {
-              var event = _ref19.event;
+            guard: function guard(_ref10) {
+              var event = _ref10.event;
               return event.output.type === 'DEPENDENCIES_NOT_MET';
             },
             target: 'waiting',
@@ -4742,46 +4627,46 @@ function _buildBaseState2(stepNode, nextSteps) {
               }
             }]
           }, {
-            guard: function guard(_ref20) {
-              var event = _ref20.event;
+            guard: function guard(_ref11) {
+              var event = _ref11.event;
               return event.output.type === 'TIMED_OUT';
             },
             target: 'failed',
             actions: xstate.assign({
-              stepResults: function stepResults(_ref21) {
-                var _extends6;
-                var context = _ref21.context,
-                  event = _ref21.event;
+              stepResults: function stepResults(_ref12) {
+                var _extends3;
+                var context = _ref12.context,
+                  event = _ref12.event;
                 if (event.output.type !== 'TIMED_OUT') return context.stepResults;
-                _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.ERROR, "Step:" + stepNode.step.id + " timed out", {
+                _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.ERROR, "Step:" + stepNode.step.id + " timed out", {
                   error: event.output.error
                 });
-                return _extends({}, context.stepResults, (_extends6 = {}, _extends6[stepNode.step.id] = {
+                return _extends({}, context.stepResults, (_extends3 = {}, _extends3[stepNode.step.id] = {
                   status: 'failed',
                   error: event.output.error
-                }, _extends6));
+                }, _extends3));
               }
             })
           }, {
-            guard: function guard(_ref22) {
-              var event = _ref22.event;
+            guard: function guard(_ref13) {
+              var event = _ref13.event;
               return event.output.type === 'CONDITION_FAILED';
             },
             target: 'failed',
             actions: xstate.assign({
-              stepResults: function stepResults(_ref23) {
-                var _extends7;
-                var context = _ref23.context,
-                  event = _ref23.event;
+              stepResults: function stepResults(_ref14) {
+                var _extends4;
+                var context = _ref14.context,
+                  event = _ref14.event;
                 if (event.output.type !== 'CONDITION_FAILED') return context.stepResults;
-                _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.ERROR, "workflow condition check failed", {
+                _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.ERROR, "workflow condition check failed", {
                   error: event.output.error,
                   stepId: stepNode.step.id
                 });
-                return _extends({}, context.stepResults, (_extends7 = {}, _extends7[stepNode.step.id] = {
+                return _extends({}, context.stepResults, (_extends4 = {}, _extends4[stepNode.step.id] = {
                   status: 'failed',
                   error: event.output.error
-                }, _extends7));
+                }, _extends4));
               }
             })
           }]
@@ -4789,32 +4674,43 @@ function _buildBaseState2(stepNode, nextSteps) {
       },
       waiting: {
         entry: function entry() {
-          _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " waiting " + new Date().toISOString());
+          _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " waiting " + new Date().toISOString());
         },
         exit: function exit() {
-          _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " finished waiting " + new Date().toISOString());
+          _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " finished waiting " + new Date().toISOString());
         },
         after: (_after = {}, _after[stepNode.step.id] = {
           target: 'pending'
         }, _after)
       },
       executing: {
+        entry: function entry() {
+          _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " executing");
+        },
+        exit: function exit() {
+          _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " finished executing");
+        },
         invoke: {
           src: 'resolverFunction',
-          input: function input(_ref24) {
-            var context = _ref24.context;
+          input: function input(_ref15) {
+            var context = _ref15.context;
             return {
               context: context,
               stepNode: stepNode
             };
           },
           onDone: {
-            target: nextStep ? nextStep.step.id : 'completed',
+            target: 'runningSubscribers',
             actions: [{
               type: 'updateStepResult',
               params: {
                 stepId: stepNode.step.id
               }
+            }, {
+              type: 'spawnSubscribers',
+              params: {
+                stepId: stepNode.step.id
+              }
             }]
           },
           onError: {
@@ -4828,6 +4724,48 @@ function _buildBaseState2(stepNode, nextSteps) {
           }
         }
       },
+      runningSubscribers: {
+        entry: function entry() {
+          _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " running subscribers");
+        },
+        exit: function exit() {
+          _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " finished running subscribers");
+        },
+        invoke: {
+          src: 'spawnSubscriberFunction',
+          input: function input(_ref16) {
+            var context = _ref16.context;
+            return {
+              parentStepId: stepNode.step.id,
+              context: context
+            };
+          },
+          onDone: {
+            target: nextStep ? nextStep.step.id : 'completed',
+            actions: [xstate.assign({
+              stepResults: function stepResults(_ref17) {
+                var context = _ref17.context,
+                  event = _ref17.event;
+                return _extends({}, context.stepResults, event.output.stepResults);
+              }
+            }), function () {
+              return _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.DEBUG, "Subscriber execution completed", {
+                stepId: stepNode.step.id
+              });
+            }]
+          },
+          onError: {
+            target: nextStep ? nextStep.step.id : 'completed',
+            actions: function actions(_ref18) {
+              var event = _ref18.event;
+              _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.ERROR, "Subscriber execution failed", {
+                error: event.error,
+                stepId: stepNode.step.id
+              });
+            }
+          }
+        }
+      },
       completed: {
         type: 'final',
         entry: [{
@@ -4854,46 +4792,272 @@ function _buildBaseState2(stepNode, nextSteps) {
           }
         }]
       }
-    }, nextStep ? (_ref25 = {}, _ref25[nextStep.step.id] = _extends({}, _classPrivateFieldLooseBase(this, _buildBaseState)[_buildBaseState](nextStep, nextSteps)), _ref25) : {})
+    }, nextStep ? (_ref19 = {}, _ref19[nextStep.step.id] = _extends({}, _classPrivateFieldLooseBase(this, _buildBaseState)[_buildBaseState](nextStep, nextSteps)), _ref19) : {})
   };
 }
 function _makeStepKey2(step) {
   // return `${step.id}${this.#delimiter}${Object.keys(this.#steps2).length}`;
   return "" + step.id;
 }
-function _buildStateHierarchy2() {
-  var _this5 = this;
+function _buildStateHierarchy2(stepGraph) {
+  var _this4 = this;
   var states = {};
-  _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph].initial.forEach(function (stepNode) {
+  stepGraph.initial.forEach(function (stepNode) {
     // TODO: For identical steps, use index to create unique key
-    states[stepNode.step.id] = _extends({}, _classPrivateFieldLooseBase(_this5, _buildBaseState)[_buildBaseState](stepNode, _classPrivateFieldLooseBase(_this5, _stepGraph)[_stepGraph][stepNode.step.id]));
+    states[stepNode.step.id] = _extends({}, _classPrivateFieldLooseBase(_this4, _buildBaseState)[_buildBaseState](stepNode, stepGraph[stepNode.step.id]));
   });
   return states;
 }
+function _getDefaultActions2() {
+  var _this5 = this;
+  return {
+    updateStepResult: xstate.assign({
+      stepResults: function stepResults(_ref20) {
+        var _extends5;
+        var context = _ref20.context,
+          event = _ref20.event;
+        if (!isTransitionEvent(event)) return context.stepResults;
+        var _event$output = event.output,
+          stepId = _event$output.stepId,
+          result = _event$output.result;
+        return _extends({}, context.stepResults, (_extends5 = {}, _extends5[stepId] = {
+          status: 'success',
+          payload: result
+        }, _extends5));
+      }
+    }),
+    setStepError: xstate.assign({
+      stepResults: function stepResults(_ref21, params) {
+        var _extends6;
+        var context = _ref21.context,
+          event = _ref21.event;
+        if (!isErrorEvent(event)) return context.stepResults;
+        var stepId = params.stepId;
+        if (!stepId) return context.stepResults;
+        return _extends({}, context.stepResults, (_extends6 = {}, _extends6[stepId] = {
+          status: 'failed',
+          error: event.error.message
+        }, _extends6));
+      }
+    }),
+    notifyStepCompletion: function notifyStepCompletion(_, params) {
+      var stepId = params.stepId;
+      _classPrivateFieldLooseBase(_this5, _log)[_log](LogLevel.INFO, "Step " + stepId + " completed");
+    },
+    decrementAttemptCount: xstate.assign({
+      attempts: function attempts(_ref22, params) {
+        var _extends7;
+        var context = _ref22.context,
+          event = _ref22.event;
+        if (!isTransitionEvent(event)) return context.attempts;
+        var stepId = params.stepId;
+        var attemptCount = context.attempts[stepId];
+        if (attemptCount === undefined) return context.attempts;
+        return _extends({}, context.attempts, (_extends7 = {}, _extends7[stepId] = attemptCount - 1, _extends7));
+      }
+    })
+  };
+}
+function _getDefaultActors2() {
+  var _this6 = this;
+  return {
+    resolverFunction: xstate.fromPromise(/*#__PURE__*/function () {
+      var _ref24 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref23) {
+        var input, stepNode, context, resolvedData, result;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              input = _ref23.input;
+              stepNode = input.stepNode, context = input.context;
+              resolvedData = _classPrivateFieldLooseBase(_this6, _resolveVariables)[_resolveVariables]({
+                stepConfig: stepNode.config,
+                context: context
+              });
+              _context2.next = 5;
+              return stepNode.config.handler({
+                context: _extends({
+                  stepResults: context.stepResults
+                }, resolvedData),
+                runId: _classPrivateFieldLooseBase(_this6, _runId)[_runId]
+              });
+            case 5:
+              result = _context2.sent;
+              return _context2.abrupt("return", {
+                stepId: stepNode.step.id,
+                result: result
+              });
+            case 7:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      return function (_x2) {
+        return _ref24.apply(this, arguments);
+      };
+    }()),
+    dependencyCheck: xstate.fromPromise(/*#__PURE__*/function () {
+      var _ref26 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref25) {
+        var input, context, stepNode, stepConfig, attemptCount, conditionMet, _conditionMet;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              input = _ref25.input;
+              context = input.context, stepNode = input.stepNode;
+              stepConfig = stepNode.config; // TODO: Need a way to create unique ids for steps
+              attemptCount = context.attempts[stepNode.step.id];
+              if (!(!attemptCount || attemptCount < 0)) {
+                _context3.next = 8;
+                break;
+              }
+              if (!(stepConfig != null && stepConfig.snapshotOnTimeout)) {
+                _context3.next = 7;
+                break;
+              }
+              return _context3.abrupt("return", {
+                type: 'SUSPENDED',
+                stepId: stepNode.step.id
+              });
+            case 7:
+              return _context3.abrupt("return", {
+                type: 'TIMED_OUT',
+                error: "Step:" + stepNode.step.id + " timed out"
+              });
+            case 8:
+              if (stepConfig != null && stepConfig.when) {
+                _context3.next = 10;
+                break;
+              }
+              return _context3.abrupt("return", {
+                type: 'DEPENDENCIES_MET'
+              });
+            case 10:
+              if (!(typeof (stepConfig == null ? void 0 : stepConfig.when) === 'function')) {
+                _context3.next = 18;
+                break;
+              }
+              _context3.next = 13;
+              return stepConfig.when({
+                context: context
+              });
+            case 13:
+              conditionMet = _context3.sent;
+              if (conditionMet) {
+                _context3.next = 16;
+                break;
+              }
+              return _context3.abrupt("return", {
+                type: 'CONDITION_FAILED',
+                error: "Step:" + stepNode.step.id + " condition function check failed"
+              });
+            case 16:
+              _context3.next = 21;
+              break;
+            case 18:
+              _conditionMet = _classPrivateFieldLooseBase(_this6, _evaluateCondition)[_evaluateCondition](stepConfig.when, context);
+              if (_conditionMet) {
+                _context3.next = 21;
+                break;
+              }
+              return _context3.abrupt("return", {
+                type: 'CONDITION_FAILED',
+                error: "Step:" + stepNode.step.id + " condition check failed"
+              });
+            case 21:
+              return _context3.abrupt("return", {
+                type: 'DEPENDENCIES_MET'
+              });
+            case 22:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      return function (_x3) {
+        return _ref26.apply(this, arguments);
+      };
+    }()),
+    spawnSubscriberFunction: xstate.fromPromise(/*#__PURE__*/function () {
+      var _ref28 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref27) {
+        var input, parentStepId, context, stepGraph, subscriberMachine, actor;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              input = _ref27.input;
+              parentStepId = input.parentStepId, context = input.context;
+              stepGraph = _classPrivateFieldLooseBase(_this6, _stepSubscriberGraph)[_stepSubscriberGraph][parentStepId];
+              if (stepGraph) {
+                _context4.next = 5;
+                break;
+              }
+              return _context4.abrupt("return", {
+                stepResults: {}
+              });
+            case 5:
+              subscriberMachine = xstate.setup({
+                types: {},
+                delays: _classPrivateFieldLooseBase(_this6, _makeDelayMap)[_makeDelayMap](),
+                actions: _classPrivateFieldLooseBase(_this6, _getDefaultActions)[_getDefaultActions](),
+                actors: _classPrivateFieldLooseBase(_this6, _getDefaultActors)[_getDefaultActors]()
+              }).createMachine({
+                id: _this6.name + "-subscriber-" + parentStepId,
+                context: context,
+                type: 'parallel',
+                states: _classPrivateFieldLooseBase(_this6, _buildStateHierarchy)[_buildStateHierarchy](stepGraph)
+              });
+              actor = xstate.createActor(subscriberMachine, {
+                input: context
+              });
+              actor.start();
+              // Create a promise that resolves when all states are final
+              return _context4.abrupt("return", new Promise(function (resolve) {
+                actor.subscribe(function (state) {
+                  var allStatesValue = state.value;
+                  var allStatesComplete = _classPrivateFieldLooseBase(_this6, _recursivelyCheckForFinalState)[_recursivelyCheckForFinalState](allStatesValue);
+                  if (allStatesComplete) {
+                    actor.stop();
+                    resolve({
+                      stepResults: state.context.stepResults
+                    });
+                  }
+                });
+              }));
+            case 9:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      return function (_x4) {
+        return _ref28.apply(this, arguments);
+      };
+    }())
+  };
+}
 function _persistWorkflowSnapshot2() {
   return _persistWorkflowSnapshot3.apply(this, arguments);
 }
 function _persistWorkflowSnapshot3() {
-  _persistWorkflowSnapshot3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+  _persistWorkflowSnapshot3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
     var _classPrivateFieldLoo5;
     var snapshot;
-    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-      while (1) switch (_context5.prev = _context5.next) {
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
         case 0:
           if (_classPrivateFieldLooseBase(this, _engine)[_engine]) {
-            _context5.next = 2;
+            _context6.next = 2;
             break;
           }
-          return _context5.abrupt("return");
+          return _context6.abrupt("return");
         case 2:
           snapshot = (_classPrivateFieldLoo5 = _classPrivateFieldLooseBase(this, _actor)[_actor]) == null ? void 0 : _classPrivateFieldLoo5.getPersistedSnapshot();
           if (snapshot) {
-            _context5.next = 5;
+            _context6.next = 5;
             break;
           }
-          return _context5.abrupt("return");
+          return _context6.abrupt("return");
         case 5:
-          _context5.next = 7;
+          _context6.next = 7;
           return _classPrivateFieldLooseBase(this, _engine)[_engine].syncRecords({
             name: _classPrivateFieldLooseBase(this, _entityName)[_entityName],
             connectionId: _classPrivateFieldLooseBase(this, _connectionId)[_connectionId],
@@ -4905,32 +5069,32 @@ function _persistWorkflowSnapshot3() {
             }]
           });
         case 7:
-          return _context5.abrupt("return", _classPrivateFieldLooseBase(this, _runId)[_runId]);
+          return _context6.abrupt("return", _classPrivateFieldLooseBase(this, _runId)[_runId]);
         case 8:
         case "end":
-          return _context5.stop();
+          return _context6.stop();
       }
-    }, _callee5, this);
+    }, _callee6, this);
   }));
   return _persistWorkflowSnapshot3.apply(this, arguments);
 }
-function _loadWorkflowSnapshot2(_x4) {
+function _loadWorkflowSnapshot2(_x5) {
   return _loadWorkflowSnapshot3.apply(this, arguments);
 }
 function _loadWorkflowSnapshot3() {
-  _loadWorkflowSnapshot3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(runId) {
+  _loadWorkflowSnapshot3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(runId) {
     var _state$;
     var state;
-    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-      while (1) switch (_context6.prev = _context6.next) {
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
         case 0:
           if (_classPrivateFieldLooseBase(this, _engine)[_engine]) {
-            _context6.next = 2;
+            _context7.next = 2;
             break;
           }
-          return _context6.abrupt("return");
+          return _context7.abrupt("return");
         case 2:
-          _context6.next = 4;
+          _context7.next = 4;
           return _classPrivateFieldLooseBase(this, _engine)[_engine].getRecords({
             entityName: _classPrivateFieldLooseBase(this, _entityName)[_entityName],
             connectionId: _classPrivateFieldLooseBase(this, _connectionId)[_connectionId],
@@ -4943,19 +5107,19 @@ function _loadWorkflowSnapshot3() {
             }
           });
         case 4:
-          state = _context6.sent;
-          return _context6.abrupt("return", (_state$ = state[0]) == null ? void 0 : _state$.data.snapshot);
+          state = _context7.sent;
+          return _context7.abrupt("return", (_state$ = state[0]) == null ? void 0 : _state$.data.snapshot);
         case 6:
         case "end":
-          return _context6.stop();
+          return _context7.stop();
       }
-    }, _callee6, this);
+    }, _callee7, this);
   }));
   return _loadWorkflowSnapshot3.apply(this, arguments);
 }
-function _resolveVariables2(_ref26) {
-  var stepConfig = _ref26.stepConfig,
-    context = _ref26.context;
+function _resolveVariables2(_ref29) {
+  var stepConfig = _ref29.stepConfig,
+    context = _ref29.context;
   var resolvedData = {};
   for (var _i3 = 0, _Object$entries3 = Object.entries(stepConfig.data); _i3 < _Object$entries3.length; _i3++) {
     var _Object$entries3$_i = _Object$entries3[_i3],
@@ -4974,7 +5138,7 @@ function _resolveVariables2(_ref26) {
   return resolvedData;
 }
 function _evaluateCondition2(condition, context) {
-  var _this6 = this;
+  var _this7 = this;
   var andBranchResult = true;
   var baseResult = true;
   var orBranchResult = true;
@@ -4992,33 +5156,33 @@ function _evaluateCondition2(condition, context) {
   // AND condition
   if ('and' in condition) {
     andBranchResult = condition.and.every(function (cond) {
-      return _classPrivateFieldLooseBase(_this6, _evaluateCondition)[_evaluateCondition](cond, context);
+      return _classPrivateFieldLooseBase(_this7, _evaluateCondition)[_evaluateCondition](cond, context);
     });
   }
   // OR condition
   if ('or' in condition) {
     orBranchResult = condition.or.some(function (cond) {
-      return _classPrivateFieldLooseBase(_this6, _evaluateCondition)[_evaluateCondition](cond, context);
+      return _classPrivateFieldLooseBase(_this7, _evaluateCondition)[_evaluateCondition](cond, context);
     });
   }
   var finalResult = baseResult && andBranchResult && orBranchResult;
   return finalResult;
 }
-function _log2(_x5, _x6, _x7, _x8) {
+function _log2(_x6, _x7, _x8, _x9) {
   return _log3.apply(this, arguments);
 }
 function _log3() {
-  _log3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(level, message, data, stepId) {
+  _log3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(level, message, data, stepId) {
     var _classPrivateFieldLoo6, _classPrivateFieldLoo7;
     var logMessage, logMethod;
-    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
-      while (1) switch (_context7.prev = _context7.next) {
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
         case 0:
           if (_classPrivateFieldLooseBase(this, _logger)[_logger]) {
-            _context7.next = 2;
+            _context8.next = 2;
             break;
           }
-          return _context7.abrupt("return");
+          return _context8.abrupt("return");
         case 2:
           logMessage = {
             type: RegisteredLogger.WORKFLOW,
@@ -5030,28 +5194,28 @@ function _log3() {
             runId: _classPrivateFieldLooseBase(this, _runId)[_runId]
           };
           logMethod = level.toLowerCase();
-          _context7.next = 6;
+          _context8.next = 6;
           return (_classPrivateFieldLoo6 = (_classPrivateFieldLoo7 = _classPrivateFieldLooseBase(this, _logger)[_logger])[logMethod]) == null ? void 0 : _classPrivateFieldLoo6.call(_classPrivateFieldLoo7, logMessage);
         case 6:
         case "end":
-          return _context7.stop();
+          return _context8.stop();
       }
-    }, _callee7, this);
+    }, _callee8, this);
   }));
   return _log3.apply(this, arguments);
 }
 function _makeStepDef2(stepId) {
-  var _this7 = this;
+  var _this8 = this;
   var handler = /*#__PURE__*/function () {
-    var _ref28 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref27) {
+    var _ref31 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_ref30) {
       var context, runId, targetStep, payload, action, mergedData, finalAction;
-      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-        while (1) switch (_context4.prev = _context4.next) {
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
           case 0:
-            context = _ref27.context, runId = _ref27.runId;
-            targetStep = _classPrivateFieldLooseBase(_this7, _steps)[_steps][stepId];
+            context = _ref30.context, runId = _ref30.runId;
+            targetStep = _classPrivateFieldLooseBase(_this8, _steps)[_steps][stepId];
             if (targetStep) {
-              _context4.next = 4;
+              _context5.next = 4;
               break;
             }
             throw new Error("Step not found");
@@ -5059,34 +5223,34 @@ function _makeStepDef2(stepId) {
             payload = targetStep.payload, action = targetStep.action; // Merge static payload with dynamically resolved variables
             // Variables take precedence over payload values
             mergedData = _extends({}, payload, context); // Only trace if telemetry is available and action exists
-            finalAction = action && _classPrivateFieldLooseBase(_this7, _telemetry)[_telemetry] ? _classPrivateFieldLooseBase(_this7, _telemetry)[_telemetry].traceMethod(action, {
-              spanName: "workflow." + _this7.name + ".action." + stepId
+            finalAction = action && _classPrivateFieldLooseBase(_this8, _telemetry)[_telemetry] ? _classPrivateFieldLooseBase(_this8, _telemetry)[_telemetry].traceMethod(action, {
+              spanName: "workflow." + _this8.name + ".action." + stepId
             }) : action;
             if (!finalAction) {
-              _context4.next = 13;
+              _context5.next = 13;
               break;
             }
-            _context4.next = 10;
+            _context5.next = 10;
             return finalAction({
               context: mergedData,
               runId: runId
             });
           case 10:
-            _context4.t0 = _context4.sent;
-            _context4.next = 14;
+            _context5.t0 = _context5.sent;
+            _context5.next = 14;
             break;
           case 13:
-            _context4.t0 = {};
+            _context5.t0 = {};
           case 14:
-            return _context4.abrupt("return", _context4.t0);
+            return _context5.abrupt("return", _context5.t0);
           case 15:
           case "end":
-            return _context4.stop();
+            return _context5.stop();
         }
-      }, _callee4);
+      }, _callee5);
     }));
-    return function handler(_x9) {
-      return _ref28.apply(this, arguments);
+    return function handler(_x10) {
+      return _ref31.apply(this, arguments);
     };
   }();
   // Only trace handler if telemetry is available
@@ -5099,11 +5263,11 @@ function _makeStepDef2(stepId) {
   };
 }
 function _makeDelayMap2() {
-  var _this8 = this;
+  var _this9 = this;
   var delayMap = {};
   Object.keys(_classPrivateFieldLooseBase(this, _steps)[_steps]).forEach(function (stepId) {
     var _classPrivateFieldLoo3, _classPrivateFieldLoo4;
-    delayMap[stepId] = ((_classPrivateFieldLoo3 = _classPrivateFieldLooseBase(_this8, _steps)[_steps][stepId]) == null || (_classPrivateFieldLoo3 = _classPrivateFieldLoo3.retryConfig) == null ? void 0 : _classPrivateFieldLoo3.delay) || ((_classPrivateFieldLoo4 = _classPrivateFieldLooseBase(_this8, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo4.delay) || 1000;
+    delayMap[stepId] = ((_classPrivateFieldLoo3 = _classPrivateFieldLooseBase(_this9, _steps)[_steps][stepId]) == null || (_classPrivateFieldLoo3 = _classPrivateFieldLoo3.retryConfig) == null ? void 0 : _classPrivateFieldLoo3.delay) || ((_classPrivateFieldLoo4 = _classPrivateFieldLooseBase(_this9, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo4.delay) || 1000;
   });
   return delayMap;
 }