@mastra/core 1.1.0 → 1.2.0-alpha.0

package/dist/{chunk-YQMDMIP6.js → chunk-FYMM4PKR.js}

@@ -1,14 +1,17 @@
-import { validateStepInput, createDeprecationProxy, EventEmitterPubSub, getStepResult, validateStepSuspendData, runCountDeprecationMessage, createTimeTravelExecutionParams, validateStepResumeData, Workflow, ProcessorStepOutputSchema, ProcessorStepSchema, Run, ExecutionEngine, hydrateSerializedStepErrors, Agent, TripWire, ProcessorRunner } from './chunk-FVVQY6UU.js';
-import { STREAM_FORMAT_SYMBOL, PUBSUB_SYMBOL } from './chunk-YEQB4VUA.js';
+import { validateStepInput, createDeprecationProxy, getStepResult, validateStepSuspendData, runCountDeprecationMessage, TripWire, createTimeTravelExecutionParams, validateStepResumeData, Workflow, isSupportedLanguageModel, ProcessorStepOutputSchema, ProcessorStepSchema, Run, WorkflowRunOutput, ExecutionEngine, cleanStepResult, hydrateSerializedStepErrors, Agent, ProcessorRunner } from './chunk-FAJYC6PA.js';
+import { STREAM_FORMAT_SYMBOL, PUBSUB_SYMBOL } from './chunk-2QXNHEDL.js';
+import { createPendingMarker } from './chunk-OQPAOUDS.js';
 import { MessageList } from './chunk-HIP5W3LZ.js';
 import { getErrorFromUnknown, MastraError } from './chunk-FJEVLHJT.js';
+import { ToolStream } from './chunk-DD2VNRQM.js';
 import { Tool } from './chunk-IW3BNL7A.js';
 import { RequestContext } from './chunk-CCLV5CAA.js';
 import { MastraBase } from './chunk-JIT2OY3X.js';
 import { RegisteredLogger } from './chunk-X2WMFSPB.js';
-import EventEmitter from 'events';
 import { randomUUID } from 'crypto';
+import { ReadableStream } from 'stream/web';
 import { z } from 'zod';
+import EventEmitter from 'events';
 
 var StepExecutor = class extends MastraBase {
   mastra;
@@ -19,6 +22,26 @@ var StepExecutor = class extends MastraBase {
   __registerMastra(mastra) {
     this.mastra = mastra;
   }
+  /**
+   * Creates an output writer function that publishes chunks to the workflow event stream.
+   * @param runId - The workflow run ID
+   * @returns An async function that writes chunks to the pubsub
+   */
+  createOutputWriter(runId) {
+    return async (chunk) => {
+      try {
+        if (this.mastra?.pubsub) {
+          await this.mastra.pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: chunk
+          });
+        }
+      } catch (err) {
+        this.logger.debug("Failed to publish workflow watch event", { runId, error: err });
+      }
+    };
+  }
   async execute(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0, perStep } = params;
     const abortController = params.abortController ?? new AbortController();
@@ -36,9 +59,12 @@ var StepExecutor = class extends MastraBase {
       payload: (typeof params.foreachIdx === "number" ? params.input : inputData) ?? {}
     };
     if (params.resumeData) {
-      delete stepInfo.suspendPayload?.["__workflow_meta"];
       stepInfo.resumePayload = params.resumeData;
       stepInfo.resumedAt = Date.now();
+      if (stepInfo.suspendPayload && "__workflow_meta" in stepInfo.suspendPayload) {
+        const { __workflow_meta, ...userSuspendPayload } = stepInfo.suspendPayload;
+        stepInfo.suspendPayload = userSuspendPayload;
+      }
     }
     let suspendDataToUse = params.stepResults[step.id]?.status === "suspended" ? params.stepResults[step.id]?.suspendPayload : void 0;
     if (suspendDataToUse && "__workflow_meta" in suspendDataToUse) {
@@ -49,6 +75,8 @@ var StepExecutor = class extends MastraBase {
       if (validationError) {
         throw validationError;
       }
+      const callId = randomUUID();
+      const outputWriter = this.createOutputWriter(runId);
       const stepOutput = await step.execute(
         createDeprecationProxy(
           {
@@ -58,15 +86,15 @@ var StepExecutor = class extends MastraBase {
             requestContext,
             inputData,
             state: params.state,
-            setState: async (state) => {
-              params.state = state;
+            setState: async (newState) => {
+              Object.assign(params.state, newState);
             },
             retryCount,
             resumeData: params.resumeData,
             suspendData: suspendDataToUse,
             getInitData: () => stepResults?.input,
             getStepResult: getStepResult.bind(this, stepResults),
-            suspend: async (suspendPayload) => {
+            suspend: async (suspendPayload, suspendOptions) => {
               const { suspendData, validationError: validationError2 } = await validateStepSuspendData({
                 suspendData: suspendPayload,
                 step,
@@ -75,17 +103,44 @@ var StepExecutor = class extends MastraBase {
               if (validationError2) {
                 throw validationError2;
               }
-              suspended = { payload: { ...suspendData, __workflow_meta: { runId, path: [step.id] } } };
+              const resumeLabels = {};
+              if (suspendOptions?.resumeLabel) {
+                const labels = Array.isArray(suspendOptions.resumeLabel) ? suspendOptions.resumeLabel : [suspendOptions.resumeLabel];
+                for (const label of labels) {
+                  resumeLabels[label] = {
+                    stepId: step.id,
+                    foreachIndex: params.foreachIdx
+                  };
+                }
+              }
+              suspended = {
+                payload: {
+                  ...suspendData,
+                  __workflow_meta: {
+                    runId,
+                    path: [step.id],
+                    foreachIndex: params.foreachIdx,
+                    resumeLabels: Object.keys(resumeLabels).length > 0 ? resumeLabels : void 0
+                  }
+                }
+              };
             },
             bail: (result) => {
               bailed = { payload: result };
             },
-            // TODO
-            writer: void 0,
+            writer: new ToolStream(
+              {
+                prefix: "workflow-step",
+                callId,
+                name: step.id,
+                runId
+              },
+              outputWriter
+            ),
             abort: () => {
               abortController?.abort();
             },
-            [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(params.emitter),
+            [PUBSUB_SYMBOL]: this.mastra.pubsub,
             [STREAM_FORMAT_SYMBOL]: void 0,
             // TODO
             engine: {},
@@ -109,7 +164,8 @@ var StepExecutor = class extends MastraBase {
           ...stepInfo,
           status: "suspended",
           suspendedAt: endedAt,
-          ...stepOutput ? { suspendOutput: stepOutput } : {}
+          ...stepOutput ? { suspendOutput: stepOutput } : {},
+          __state: params.state
         };
         if (suspended.payload) {
           finalResult.suspendPayload = suspended.payload;
@@ -120,19 +176,22 @@ var StepExecutor = class extends MastraBase {
           // @ts-expect-error - bailed status not in type
           status: "bailed",
           endedAt,
-          output: bailed.payload
+          output: bailed.payload,
+          __state: params.state
         };
       } else if (nestedWflowStepPaused) {
         finalResult = {
           ...stepInfo,
-          status: "paused"
+          status: "paused",
+          __state: params.state
         };
       } else {
         finalResult = {
           ...stepInfo,
           status: "success",
           endedAt,
-          output: stepOutput
+          output: stepOutput,
+          __state: params.state
         };
       }
       return finalResult;
@@ -146,14 +205,22 @@ var StepExecutor = class extends MastraBase {
         ...stepInfo,
         status: "failed",
         endedAt,
-        error: errorInstance
+        error: errorInstance,
+        // Preserve TripWire data as plain object for proper serialization
+        // Important: Check `error` not `errorInstance` because getErrorFromUnknown
+        // converts the error and loses the prototype chain
+        tripwire: error instanceof TripWire ? {
+          reason: error.message,
+          retry: error.options?.retry,
+          metadata: error.options?.metadata,
+          processorId: error.processorId
+        } : void 0
       };
     }
   }
   async evaluateConditions(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0 } = params;
     const abortController = params.abortController ?? new AbortController();
-    const ee = new EventEmitter();
     const results = await Promise.all(
       step.conditions.map((condition) => {
         try {
@@ -168,7 +235,6 @@ var StepExecutor = class extends MastraBase {
             resumeData: params.resumeData,
             abortController,
             stepResults,
-            emitter: ee,
             iterationCount: 0
           });
         } catch (e) {
@@ -194,11 +260,12 @@ var StepExecutor = class extends MastraBase {
     stepResults,
     state,
     requestContext,
-    emitter,
     abortController,
     retryCount = 0,
     iterationCount
   }) {
+    const callId = randomUUID();
+    const outputWriter = this.createOutputWriter(runId);
     return condition(
       createDeprecationProxy(
         {
@@ -215,12 +282,19 @@ var StepExecutor = class extends MastraBase {
           bail: (_result) => {
             throw new Error("Not implemented");
           },
-          // TODO
-          writer: void 0,
+          writer: new ToolStream(
+            {
+              prefix: "workflow-step",
+              callId,
+              name: "condition",
+              runId
+            },
+            outputWriter
+          ),
           abort: () => {
             abortController?.abort();
           },
-          [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(emitter),
+          [PUBSUB_SYMBOL]: this.mastra.pubsub,
           [STREAM_FORMAT_SYMBOL]: void 0,
           // TODO
           engine: {},
@@ -239,8 +313,8 @@ var StepExecutor = class extends MastraBase {
   }
   async resolveSleep(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0 } = params;
+    const currentState = params.state ?? stepResults?.__state ?? {};
     const abortController = params.abortController ?? new AbortController();
-    const ee = new EventEmitter();
     if (step.duration) {
       return step.duration;
     }
@@ -248,6 +322,8 @@ var StepExecutor = class extends MastraBase {
       return 0;
     }
     try {
+      const callId = randomUUID();
+      const outputWriter = this.createOutputWriter(runId);
       return await step.fn(
         createDeprecationProxy(
           {
@@ -256,9 +332,9 @@ var StepExecutor = class extends MastraBase {
             mastra: this.mastra,
             requestContext,
             inputData: params.input,
-            // TODO: implement state
-            state: {},
-            setState: async (_state) => {
+            state: currentState,
+            setState: async (newState) => {
+              Object.assign(currentState, newState);
             },
             retryCount,
             resumeData: params.resumeData,
@@ -273,9 +349,16 @@ var StepExecutor = class extends MastraBase {
             abort: () => {
               abortController?.abort();
             },
-            // TODO
-            writer: void 0,
-            [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(ee),
+            writer: new ToolStream(
+              {
+                prefix: "workflow-step",
+                callId,
+                name: step.id,
+                runId
+              },
+              outputWriter
+            ),
+            [PUBSUB_SYMBOL]: this.mastra.pubsub,
             [STREAM_FORMAT_SYMBOL]: void 0,
             // TODO
             engine: {},
@@ -297,8 +380,8 @@ var StepExecutor = class extends MastraBase {
   }
   async resolveSleepUntil(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0 } = params;
+    const currentState = params.state ?? stepResults?.__state ?? {};
     const abortController = params.abortController ?? new AbortController();
-    const ee = new EventEmitter();
     if (step.date) {
       return step.date.getTime() - Date.now();
     }
@@ -306,6 +389,8 @@ var StepExecutor = class extends MastraBase {
       return 0;
     }
     try {
+      const callId = randomUUID();
+      const outputWriter = this.createOutputWriter(runId);
       const result = await step.fn(
         createDeprecationProxy(
           {
@@ -314,9 +399,9 @@ var StepExecutor = class extends MastraBase {
             mastra: this.mastra,
             requestContext,
             inputData: params.input,
-            // TODO: implement state
-            state: {},
-            setState: async (_state) => {
+            state: currentState,
+            setState: async (newState) => {
+              Object.assign(currentState, newState);
             },
             retryCount,
             resumeData: params.resumeData,
@@ -331,9 +416,16 @@ var StepExecutor = class extends MastraBase {
             abort: () => {
               abortController?.abort();
             },
-            // TODO
-            writer: void 0,
-            [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(ee),
+            writer: new ToolStream(
+              {
+                prefix: "workflow-step",
+                callId,
+                name: step.id,
+                runId
+              },
+              outputWriter
+            ),
+            [PUBSUB_SYMBOL]: this.mastra.pubsub,
             [STREAM_FORMAT_SYMBOL]: void 0,
             // TODO
             engine: {},
@@ -356,6 +448,32 @@ var StepExecutor = class extends MastraBase {
   }
 };
 
+// src/workflows/evented/helpers.ts
+function isTripwireChunk(chunk) {
+  return chunk !== null && typeof chunk === "object" && "type" in chunk && chunk.type === "tripwire" && "payload" in chunk;
+}
+function createTripWireFromChunk(chunk) {
+  const { payload } = chunk;
+  return new TripWire(
+    payload.reason || "Agent tripwire triggered",
+    {
+      retry: payload.retry,
+      metadata: payload.metadata
+    },
+    payload.processorId
+  );
+}
+function getTextDeltaFromChunk(chunk, isV2Model) {
+  if (chunk.type !== "text-delta") {
+    return void 0;
+  }
+  return isV2Model ? chunk.payload?.text : chunk.textDelta;
+}
+function resolveCurrentState(params) {
+  const { stepResult, stepResults, state } = params;
+  return stepResult?.__state ?? stepResults?.__state ?? state ?? {};
+}
+
 // src/events/processor.ts
 var EventProcessor = class {
   mastra;
@@ -366,6 +484,8 @@ var EventProcessor = class {
     this.mastra = mastra;
   }
 };
+
+// src/workflows/evented/workflow-event-processor/loop.ts
 async function processWorkflowLoop({
   workflowId,
   prevResult,
@@ -378,30 +498,31 @@ async function processWorkflowLoop({
   parentWorkflow,
   requestContext,
   retryCount = 0,
-  perStep
+  perStep,
+  state,
+  outputOptions
 }, {
   pubsub,
   stepExecutor,
   step,
   stepResult
 }) {
+  const currentState = resolveCurrentState({ stepResult, stepResults, state });
+  const reqContext = new RequestContext(Object.entries(requestContext ?? {}));
+  const prevIterationCount = stepResults[step.step?.id]?.metadata?.iterationCount ?? 0;
+  const iterationCount = prevIterationCount + 1;
   const loopCondition = await stepExecutor.evaluateCondition({
     workflowId,
     condition: step.condition,
     runId,
     stepResults,
-    // TODO: implement state
-    state: {},
-    emitter: new EventEmitter(),
-    // TODO
-    requestContext: new RequestContext(),
-    // TODO
+    state: currentState,
+    requestContext: reqContext,
     inputData: prevResult?.status === "success" ? prevResult.output : void 0,
     resumeData,
     abortController: new AbortController(),
     retryCount,
-    iterationCount: 0
-    //TODO: implement
+    iterationCount
   });
   if (step.loopType === "dountil") {
     if (loopCondition) {
@@ -419,7 +540,9 @@ async function processWorkflowLoop({
           resumeData,
           activeSteps,
           requestContext,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions
         }
       });
     } else {
@@ -433,6 +556,8 @@ async function processWorkflowLoop({
           executionPath,
           resumeSteps,
           stepResults,
+          state: currentState,
+          outputOptions,
           prevResult: stepResult,
           resumeData,
           activeSteps,
@@ -459,7 +584,9 @@ async function processWorkflowLoop({
           activeSteps,
           requestContext,
           retryCount,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions
         }
       });
     } else {
@@ -477,7 +604,9 @@ async function processWorkflowLoop({
           resumeData,
           activeSteps,
           requestContext,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions
         }
       });
     }
@@ -495,15 +624,180 @@ async function processWorkflowForEach({
   resumeData,
   parentWorkflow,
   requestContext,
-  perStep
+  perStep,
+  state,
+  outputOptions,
+  forEachIndex
 }, {
   pubsub,
   mastra,
   step
 }) {
+  const currentState = resolveCurrentState({ stepResults, state });
   const currentResult = stepResults[step.step.id];
   const idx = currentResult?.output?.length ?? 0;
   const targetLen = prevResult?.output?.length ?? 0;
+  if (forEachIndex !== void 0 && resumeSteps?.length > 0 && idx > 0) {
+    const outputArray = currentResult?.output;
+    const outputLength = Array.isArray(outputArray) ? outputArray.length : 0;
+    if (!Array.isArray(outputArray) || forEachIndex < 0 || forEachIndex >= outputLength) {
+      const error = new Error(
+        `Invalid forEachIndex ${forEachIndex} for forEach resume: expected index in range [0, ${outputLength - 1}] but output array has length ${outputLength}`
+      );
+      await pubsub.publish("workflows", {
+        type: "workflow.fail",
+        runId,
+        data: {
+          parentWorkflow,
+          workflowId,
+          runId,
+          executionPath,
+          resumeSteps,
+          stepResults,
+          prevResult: { status: "failed", error },
+          activeSteps,
+          requestContext,
+          state: currentState,
+          outputOptions
+        }
+      });
+      return;
+    }
+    const iterationResult = currentResult?.output?.[forEachIndex];
+    if (iterationResult?.status === "suspended" || iterationResult === null) {
+      const isNestedWorkflow2 = step.step.component === "WORKFLOW";
+      const targetArray2 = prevResult?.output;
+      const iterationPrevResult2 = isNestedWorkflow2 && prevResult.status === "success" && Array.isArray(targetArray2) ? { status: "success", output: targetArray2[forEachIndex] } : prevResult;
+      await pubsub.publish("workflows", {
+        type: "workflow.step.run",
+        runId,
+        data: {
+          parentWorkflow,
+          workflowId,
+          runId,
+          executionPath: [executionPath[0], forEachIndex],
+          resumeSteps,
+          timeTravel,
+          stepResults,
+          prevResult: iterationPrevResult2,
+          resumeData,
+          activeSteps,
+          requestContext,
+          perStep,
+          state: currentState,
+          outputOptions
+        }
+      });
+      return;
+    }
+    const pendingIterations = currentResult.output.filter((r) => r === null || r?.status === "suspended");
+    if (pendingIterations.length > 0) {
+      const collectedResumeLabels = {};
+      for (let i = 0; i < currentResult.output.length; i++) {
+        const iterResult = currentResult.output[i];
+        if (iterResult?.status === "suspended" && iterResult.suspendPayload?.__workflow_meta?.resumeLabels) {
+          Object.assign(collectedResumeLabels, iterResult.suspendPayload.__workflow_meta.resumeLabels);
+        }
+      }
+      const suspendMeta = {
+        foreachIndex: forEachIndex
+      };
+      if (Object.keys(collectedResumeLabels).length > 0) {
+        suspendMeta.resumeLabels = collectedResumeLabels;
+      }
+      await pubsub.publish("workflows", {
+        type: "workflow.step.end",
+        runId,
+        data: {
+          parentWorkflow,
+          workflowId,
+          runId,
+          executionPath,
+          resumeSteps,
+          stepResults: {
+            ...stepResults,
+            [step.step.id]: {
+              ...currentResult,
+              status: "suspended",
+              suspendedAt: Date.now(),
+              suspendPayload: { __workflow_meta: suspendMeta }
+            }
+          },
+          prevResult: {
+            status: "suspended",
+            output: currentResult.output,
+            suspendPayload: { __workflow_meta: suspendMeta },
+            payload: currentResult.payload,
+            startedAt: currentResult.startedAt,
+            suspendedAt: Date.now()
+          },
+          activeSteps,
+          requestContext,
+          state: currentState,
+          outputOptions
+        }
+      });
+      return;
+    }
+    return;
+  }
+  if (resumeData !== void 0 && forEachIndex === void 0 && currentResult?.output?.length > 0) {
+    const suspendedIndices = [];
+    for (let i = 0; i < currentResult.output.length; i++) {
+      const iterResult = currentResult.output[i];
+      if (iterResult && typeof iterResult === "object" && iterResult.status === "suspended") {
+        suspendedIndices.push(i);
+      }
+    }
+    if (suspendedIndices.length > 0) {
+      const concurrency = step.opts.concurrency ?? 1;
+      const indicesToResume = suspendedIndices.slice(0, concurrency);
+      const workflowsStore2 = await mastra.getStorage()?.getStore("workflows");
+      const updatedOutput = [...currentResult.output];
+      for (const suspIdx of indicesToResume) {
+        updatedOutput[suspIdx] = createPendingMarker();
+      }
+      await workflowsStore2?.updateWorkflowResults({
+        workflowName: workflowId,
+        runId,
+        stepId: step.step.id,
+        result: {
+          ...currentResult,
+          output: updatedOutput
+        },
+        requestContext
+      });
+      const isNestedWorkflow2 = step.step.component === "WORKFLOW";
+      for (const suspIdx of indicesToResume) {
+        const targetArray2 = prevResult?.output;
+        const iterationPrevResult2 = isNestedWorkflow2 && prevResult.status === "success" && Array.isArray(targetArray2) ? { status: "success", output: targetArray2[suspIdx] } : prevResult;
+        try {
+          await pubsub.publish("workflows", {
+            type: "workflow.step.run",
+            runId,
+            data: {
+              parentWorkflow,
+              workflowId,
+              runId,
+              executionPath: [executionPath[0], suspIdx],
+              resumeSteps,
+              timeTravel,
+              stepResults,
+              prevResult: iterationPrevResult2,
+              resumeData,
+              activeSteps,
+              requestContext,
+              perStep,
+              state: currentState,
+              outputOptions
+            }
+          });
+        } catch {
+        }
+      }
+      return;
+    }
+  }
   if (idx >= targetLen && currentResult.output.filter((r) => r !== null).length >= targetLen) {
     await pubsub.publish("workflows", {
       type: "workflow.step.run",
@@ -517,10 +811,13 @@ async function processWorkflowForEach({
         stepResults,
         timeTravel,
         prevResult: currentResult,
-        resumeData,
+        resumeData: void 0,
+        // No resumeData when advancing past foreach
         activeSteps,
         requestContext,
-        perStep
+        perStep,
+        state: currentState,
+        outputOptions
       }
     });
     return;
@@ -543,7 +840,10 @@ async function processWorkflowForEach({
       },
       requestContext
     });
+    const isNestedWorkflow2 = step.step.component === "WORKFLOW";
     for (let i = 0; i < concurrency; i++) {
+      const targetArray2 = prevResult?.output;
+      const iterationPrevResult2 = isNestedWorkflow2 && prevResult.status === "success" && Array.isArray(targetArray2) ? { status: "success", output: targetArray2[i] } : prevResult;
       await pubsub.publish("workflows", {
         type: "workflow.step.run",
         runId,
@@ -555,11 +855,13 @@ async function processWorkflowForEach({
           resumeSteps,
           stepResults,
           timeTravel,
-          prevResult,
+          prevResult: iterationPrevResult2,
           resumeData,
           activeSteps,
           requestContext,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions
         }
       });
     }
@@ -578,6 +880,9 @@ async function processWorkflowForEach({
     },
     requestContext
   });
+  const isNestedWorkflow = step.step.component === "WORKFLOW";
+  const targetArray = prevResult?.output;
+  const iterationPrevResult = isNestedWorkflow && prevResult.status === "success" && Array.isArray(targetArray) ? { status: "success", output: targetArray[idx] } : prevResult;
   await pubsub.publish("workflows", {
     type: "workflow.step.run",
     runId,
@@ -589,14 +894,18 @@ async function processWorkflowForEach({
       resumeSteps,
       timeTravel,
       stepResults,
-      prevResult,
+      prevResult: iterationPrevResult,
       resumeData,
       activeSteps,
       requestContext,
-      perStep
+      perStep,
+      state: currentState,
+      outputOptions
     }
   });
 }
+
+// src/workflows/evented/workflow-event-processor/parallel.ts
 async function processWorkflowParallel({
   workflowId,
   runId,
@@ -609,11 +918,14 @@ async function processWorkflowParallel({
   resumeData,
   parentWorkflow,
   requestContext,
-  perStep
+  perStep,
+  state,
+  outputOptions
 }, {
   pubsub,
   step
 }) {
+  const currentState = resolveCurrentState({ stepResults, state });
   for (let i = 0; i < step.steps.length; i++) {
     const nestedStep = step.steps[i];
     if (nestedStep?.type === "step") {
@@ -640,7 +952,9 @@ async function processWorkflowParallel({
           parentWorkflow,
           activeSteps,
           requestContext,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions
         }
       });
     })
@@ -658,23 +972,23 @@ async function processWorkflowConditional({
   resumeData,
   parentWorkflow,
   requestContext,
-  perStep
+  perStep,
+  state,
+  outputOptions
 }, {
   pubsub,
   stepExecutor,
   step
 }) {
+  const currentState = resolveCurrentState({ stepResults, state });
+  const reqContext = new RequestContext(Object.entries(requestContext ?? {}));
   const idxs = await stepExecutor.evaluateConditions({
     workflowId,
     step,
     runId,
     stepResults,
-    // TODO: implement state
-    state: {},
-    emitter: new EventEmitter(),
-    // TODO
-    requestContext: new RequestContext(),
-    // TODO
+    state: currentState,
+    requestContext: reqContext,
     input: prevResult?.status === "success" ? prevResult.output : void 0,
     resumeData
   });
@@ -705,7 +1019,9 @@ async function processWorkflowConditional({
         parentWorkflow,
         activeSteps,
         requestContext,
-        perStep
+        perStep,
+        state: currentState,
+        outputOptions
       }
     });
   } else {
@@ -730,7 +1046,9 @@ async function processWorkflowConditional({
               parentWorkflow,
               activeSteps,
               requestContext,
-              perStep
+              perStep,
+              state: currentState,
+              outputOptions
             }
           });
         } else {
@@ -748,7 +1066,9 @@ async function processWorkflowConditional({
               parentWorkflow,
               activeSteps,
               requestContext,
-              perStep
+              perStep,
+              state: currentState,
+              outputOptions
             }
           });
         }
@@ -756,6 +1076,8 @@ async function processWorkflowConditional({
     );
   }
 }
+
+// src/workflows/evented/workflow-event-processor/sleep.ts
 async function processWorkflowWaitForEvent(workflowData, {
   pubsub,
   eventName,
@@ -820,15 +1142,13 @@ async function processWorkflowSleep({
       }
     }
   });
+  const reqContext = new RequestContext(Object.entries(requestContext ?? {}));
   const duration = await stepExecutor.resolveSleep({
     workflowId,
     step,
     runId,
     stepResults,
-    emitter: new EventEmitter(),
-    // TODO
-    requestContext: new RequestContext(),
-    // TODO
+    requestContext: reqContext,
     input: prevResult?.status === "success" ? prevResult.output : void 0,
     resumeData
   });
@@ -901,15 +1221,13 @@ async function processWorkflowSleepUntil({
   step
 }) {
   const startedAt = Date.now();
+  const reqContext = new RequestContext(Object.entries(requestContext ?? {}));
   const duration = await stepExecutor.resolveSleepUntil({
     workflowId,
     step,
     runId,
     stepResults,
-    emitter: new EventEmitter(),
-    // TODO
-    requestContext: new RequestContext(),
-    // TODO
+    requestContext: reqContext,
     input: prevResult?.status === "success" ? prevResult.output : void 0,
     resumeData
   });
@@ -1095,8 +1413,12 @@ var WorkflowEventProcessor = class extends EventProcessor {
     executionPath,
     stepResults,
     requestContext,
-    perStep
+    perStep,
+    state,
+    outputOptions,
+    forEachIndex
   }) {
+    const initialState = arguments[0].initialState ?? state ?? {};
     this.getOrCreateAbortController(runId);
     if (parentWorkflow?.runId) {
       this.parentChildRelationships.set(runId, parentWorkflow.runId);
@@ -1104,26 +1426,35 @@ var WorkflowEventProcessor = class extends EventProcessor {
     const workflowsStore = await this.mastra.getStorage()?.getStore("workflows");
     const existingRun = await workflowsStore?.getWorkflowRunById({ runId, workflowName: workflow.id });
     const resourceId = existingRun?.resourceId;
-    await workflowsStore?.persistWorkflowSnapshot({
-      workflowName: workflow.id,
-      runId,
-      resourceId,
-      snapshot: {
-        activePaths: [],
-        suspendedPaths: {},
-        resumeLabels: {},
-        waitingPaths: {},
-        activeStepsPath: {},
-        serializedStepGraph: workflow.serializedStepGraph,
-        timestamp: Date.now(),
+    const shouldPersist = workflow?.options?.shouldPersistSnapshot?.({
+      stepResults: stepResults ?? {},
+      workflowStatus: "running"
+    }) ?? true;
+    if (shouldPersist) {
+      await workflowsStore?.persistWorkflowSnapshot({
+        workflowName: workflow.id,
         runId,
-        context: stepResults ?? {
-          input: prevResult?.status === "success" ? prevResult.output : void 0
-        },
-        status: "running",
-        value: {}
-      }
-    });
+        resourceId,
+        snapshot: {
+          activePaths: [],
+          suspendedPaths: {},
+          resumeLabels: {},
+          waitingPaths: {},
+          activeStepsPath: {},
+          serializedStepGraph: workflow.serializedStepGraph,
+          timestamp: Date.now(),
+          runId,
+          context: {
+            ...stepResults ?? {
+              input: prevResult?.status === "success" ? prevResult.output : void 0
+            },
+            __state: initialState
+          },
+          status: "running",
+          value: initialState
+        }
+      });
+    }
     await this.mastra.pubsub.publish("workflows", {
       type: "workflow.step.run",
       runId,
@@ -1133,29 +1464,42 @@ var WorkflowEventProcessor = class extends EventProcessor {
         runId,
         executionPath: executionPath ?? [0],
         resumeSteps,
-        stepResults: stepResults ?? {
-          input: prevResult?.status === "success" ? prevResult.output : void 0
+        stepResults: {
+          ...stepResults ?? {
+            input: prevResult?.status === "success" ? prevResult.output : void 0
+          },
+          __state: initialState
         },
         prevResult,
         timeTravel,
         requestContext,
         resumeData,
         activeSteps: {},
-        perStep
+        perStep,
+        state: initialState,
+        outputOptions,
+        forEachIndex
       }
     });
   }
   async endWorkflow(args, status = "success") {
-    const { workflowId, runId, prevResult, perStep } = args;
+    const { workflowId, runId, prevResult, perStep, workflow, stepResults } = args;
     const workflowsStore = await this.mastra.getStorage()?.getStore("workflows");
-    await workflowsStore?.updateWorkflowState({
-      workflowName: workflowId,
-      runId,
-      opts: {
-        status: perStep && status === "success" ? "paused" : status,
-        result: prevResult
-      }
-    });
+    const finalStatus = perStep && status === "success" ? "paused" : status;
+    const shouldPersist = workflow?.options?.shouldPersistSnapshot?.({
+      stepResults: stepResults ?? {},
+      workflowStatus: finalStatus
+    }) ?? true;
+    if (shouldPersist) {
+      await workflowsStore?.updateWorkflowState({
+        workflowName: workflowId,
+        runId,
+        opts: {
+          status: finalStatus,
+          result: prevResult
+        }
+      });
+    }
     if (perStep) {
       await this.mastra.pubsub.publish(`workflow.events.v2.${runId}`, {
         type: "watch",
@@ -1192,13 +1536,16 @@ var WorkflowEventProcessor = class extends EventProcessor {
       requestContext,
       runId,
       timeTravel,
-      perStep
-    } = args;
+      perStep,
+      stepResults,
+      state} = args;
+    const finalState = resolveCurrentState({ stepResults, state });
     this.cleanupRun(runId);
     if (parentWorkflow) {
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.step.end",
-        runId,
+        runId: parentWorkflow.runId,
+        // Use parent's runId for event routing
         data: {
           workflowId: parentWorkflow.workflowId,
           runId: parentWorkflow.runId,
@@ -1212,22 +1559,39 @@ var WorkflowEventProcessor = class extends EventProcessor {
           parentContext: parentWorkflow,
           requestContext,
           timeTravel,
-          perStep
+          perStep,
+          state: finalState,
+          nestedRunId: runId
+          // Pass nested workflow's runId for step retrieval
         }
       });
     }
     await this.mastra.pubsub.publish("workflows-finish", {
       type: "workflow.end",
       runId,
-      data: { ...args, workflow: void 0 }
+      data: { ...args, workflow: void 0, state: finalState }
     });
   }
   async processWorkflowSuspend(args) {
-    const { resumeSteps, prevResult, resumeData, parentWorkflow, activeSteps, runId, requestContext, timeTravel } = args;
+    const {
+      resumeSteps,
+      prevResult,
+      resumeData,
+      parentWorkflow,
+      activeSteps,
+      runId,
+      requestContext,
+      timeTravel,
+      stepResults,
+      state,
+      outputOptions
+    } = args;
+    const finalState = resolveCurrentState({ stepResults, state });
     if (parentWorkflow) {
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.step.end",
-        runId,
+        runId: parentWorkflow.runId,
+        // Use parent's runId for event routing
         data: {
           workflowId: parentWorkflow.workflowId,
           runId: parentWorkflow.runId,
@@ -1249,14 +1613,18 @@ var WorkflowEventProcessor = class extends EventProcessor {
           activeSteps,
           requestContext,
           parentWorkflow: parentWorkflow.parentWorkflow,
-          parentContext: parentWorkflow
+          parentContext: parentWorkflow,
+          state: finalState,
+          outputOptions,
+          nestedRunId: runId
+          // Pass nested workflow's runId for step retrieval
         }
       });
     }
     await this.mastra.pubsub.publish("workflows-finish", {
       type: "workflow.suspend",
       runId,
-      data: { ...args, workflow: void 0 }
+      data: { ...args, workflow: void 0, state: finalState }
     });
   }
   async processWorkflowFail(args) {
@@ -1269,22 +1637,34 @@ var WorkflowEventProcessor = class extends EventProcessor {
       parentWorkflow,
       activeSteps,
       requestContext,
-      timeTravel
+      timeTravel,
+      stepResults,
+      state,
+      outputOptions,
+      workflow
     } = args;
+    const finalState = resolveCurrentState({ stepResults, state });
     this.cleanupRun(runId);
     const workflowsStore = await this.mastra.getStorage()?.getStore("workflows");
-    await workflowsStore?.updateWorkflowState({
-      workflowName: workflowId,
-      runId,
-      opts: {
-        status: "failed",
-        error: prevResult.error
-      }
-    });
+    const shouldPersist = workflow?.options?.shouldPersistSnapshot?.({
+      stepResults: stepResults ?? {},
+      workflowStatus: "failed"
+    }) ?? true;
+    if (shouldPersist) {
+      await workflowsStore?.updateWorkflowState({
+        workflowName: workflowId,
+        runId,
+        opts: {
+          status: "failed",
+          error: prevResult.error
+        }
+      });
+    }
     if (parentWorkflow) {
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.step.end",
-        runId,
+        runId: parentWorkflow.runId,
+        // Use parent's runId for event routing
         data: {
           workflowId: parentWorkflow.workflowId,
           runId: parentWorkflow.runId,
@@ -1297,14 +1677,18 @@ var WorkflowEventProcessor = class extends EventProcessor {
           activeSteps,
           requestContext,
           parentWorkflow: parentWorkflow.parentWorkflow,
-          parentContext: parentWorkflow
+          parentContext: parentWorkflow,
+          state: finalState,
+          outputOptions,
+          nestedRunId: runId
+          // Pass nested workflow's runId for step retrieval
         }
       });
     }
     await this.mastra.pubsub.publish("workflows-finish", {
       type: "workflow.fail",
       runId,
-      data: { ...args, workflow: void 0 }
+      data: { ...args, workflow: void 0, state: finalState }
     });
   }
   async processWorkflowStepRun({
@@ -1321,8 +1705,12 @@ var WorkflowEventProcessor = class extends EventProcessor {
     parentWorkflow,
     requestContext,
     retryCount = 0,
-    perStep
+    perStep,
+    state,
+    outputOptions,
+    forEachIndex
   }) {
+    const currentState = resolveCurrentState({ stepResults, state });
     let stepGraph = workflow.stepGraph;
     if (!executionPath?.length) {
       return this.errorWorkflow(
@@ -1348,6 +1736,24 @@ var WorkflowEventProcessor = class extends EventProcessor {
     }
     let step = stepGraph[executionPath[0]];
     if (!step) {
+      if (executionPath[0] >= stepGraph.length) {
+        return this.endWorkflow({
+          workflow,
+          parentWorkflow,
+          workflowId,
+          runId,
+          executionPath,
+          resumeSteps,
+          stepResults,
+          prevResult,
+          activeSteps,
+          requestContext,
+          // Use currentState (resolved from stepResults.__state and state) instead of
+          // the possibly-undefined state parameter, to ensure final state is preserved
+          state: currentState,
+          outputOptions
+        });
+      }
       return this.errorWorkflow(
         {
           workflowId,
@@ -1385,7 +1791,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
           resumeData,
           parentWorkflow,
           requestContext,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions
         },
         {
           pubsub: this.mastra.pubsub,
@@ -1406,7 +1814,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
           resumeData,
           parentWorkflow,
           requestContext,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions
         },
         {
           pubsub: this.mastra.pubsub,
@@ -1428,8 +1838,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
           resumeData,
           parentWorkflow,
           requestContext,
-          perStep
-        },
+          perStep},
         {
           pubsub: this.mastra.pubsub,
           stepExecutor: this.stepExecutor,
@@ -1450,8 +1859,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
           resumeData,
           parentWorkflow,
           requestContext,
-          perStep
-        },
+          perStep},
         {
           pubsub: this.mastra.pubsub,
           stepExecutor: this.stepExecutor,
@@ -1472,7 +1880,10 @@ var WorkflowEventProcessor = class extends EventProcessor {
           resumeData,
           parentWorkflow,
           requestContext,
-          perStep
+          perStep,
+          state: currentState,
+          outputOptions,
+          forEachIndex
         },
         {
           pubsub: this.mastra.pubsub,
@@ -1505,7 +1916,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
     }
     activeSteps[step.step.id] = true;
     const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
-    if (step.step instanceof EventedWorkflow) {
+    if (step.step instanceof EventedWorkflow || step.step.component === "WORKFLOW") {
       if (resumeSteps?.length > 1) {
         const stepData = stepResults[step.step.id];
         const nestedRunId = stepData?.suspendPayload?.__workflow_meta?.runId;
@@ -1560,7 +1971,10 @@ var WorkflowEventProcessor = class extends EventProcessor {
             resumeData,
             activeSteps,
             requestContext,
-            perStep
+            perStep,
+            initialState: currentState,
+            state: currentState,
+            outputOptions
           }
         });
       } else if (timeTravel && timeTravel.steps?.length > 1 && timeTravel.steps[0] === step.step.id) {
@@ -1568,6 +1982,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
           workflowName: step.step.id,
           runId
         }) ?? { context: {} };
+        const nestedWorkflow = step.step;
         const timeTravelParams = createTimeTravelExecutionParams({
           steps: timeTravel.steps.slice(1),
           inputData: timeTravel.inputData,
@@ -1575,10 +1990,10 @@ var WorkflowEventProcessor = class extends EventProcessor {
           context: timeTravel.nestedStepResults?.[step.step.id] ?? {},
           nestedStepsContext: timeTravel.nestedStepResults ?? {},
           snapshot,
-          graph: step.step.buildExecutionGraph(),
+          graph: nestedWorkflow.buildExecutionGraph(),
           perStep
         });
-        const nestedPrevStep = getStep(step.step, timeTravelParams.executionPath);
+        const nestedPrevStep = getStep(nestedWorkflow, timeTravelParams.executionPath);
         const nestedPrevResult = timeTravelParams.stepResults[nestedPrevStep?.id ?? "input"];
         await this.mastra.pubsub.publish("workflows", {
           type: "workflow.start",
@@ -1603,7 +2018,10 @@ var WorkflowEventProcessor = class extends EventProcessor {
             timeTravel: timeTravelParams,
             activeSteps,
             requestContext,
-            perStep
+            perStep,
+            initialState: currentState,
+            state: currentState,
+            outputOptions
           }
         });
       } else {
@@ -1629,7 +2047,10 @@ var WorkflowEventProcessor = class extends EventProcessor {
             resumeData,
             activeSteps,
             requestContext,
-            perStep
+            perStep,
+            initialState: currentState,
+            state: currentState,
+            outputOptions
           }
         });
       }
@@ -1683,9 +2104,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
       step: step.step,
       runId,
       stepResults,
-      // TODO: implement state
-      state: {},
-      emitter: ee,
+      state: currentState,
       requestContext: rc,
       input: prevResult?.output,
       resumeData: resumeDataToUse,
@@ -1713,7 +2132,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
         prevResult: stepResult,
         activeSteps,
         requestContext,
-        perStep
+        perStep,
+        state: currentState,
+        outputOptions
       });
       return;
     }
@@ -1732,7 +2153,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
             stepResults,
             prevResult: stepResult,
             activeSteps,
-            requestContext
+            requestContext,
+            state: currentState,
+            outputOptions
           }
         });
       } else {
@@ -1750,7 +2173,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
             prevResult,
             activeSteps,
             requestContext,
-            retryCount: retryCount + 1
+            retryCount: retryCount + 1,
+            state: currentState,
+            outputOptions
           }
         });
       }
@@ -1778,6 +2203,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
         }
       );
     } else {
+      const updatedState = stepResult.__state ?? currentState;
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.step.end",
         runId,
@@ -1789,11 +2215,17 @@ var WorkflowEventProcessor = class extends EventProcessor {
           resumeSteps,
           timeTravel,
           //timeTravel is passed in as workflow.step.end ends the step, not the workflow, the timeTravel info is passed to the next step to run.
-          stepResults,
+          stepResults: {
+            ...stepResults,
+            __state: updatedState
+          },
           prevResult: stepResult,
           activeSteps,
           requestContext,
-          perStep
+          perStep,
+          state: updatedState,
+          outputOptions,
+          forEachIndex
         }
       });
     }
@@ -1811,8 +2243,15 @@ var WorkflowEventProcessor = class extends EventProcessor {
     activeSteps,
     parentContext,
     requestContext,
-    perStep
+    perStep,
+    state,
+    outputOptions,
+    forEachIndex,
+    nestedRunId
   }) {
+    const currentState = parentContext ? state ?? prevResult?.__state ?? stepResults?.__state ?? {} : prevResult?.__state ?? stepResults?.__state ?? state ?? {};
+    const { __state: _removedState, ...cleanPrevResult } = prevResult;
+    prevResult = cleanPrevResult;
     let step = workflow.stepGraph[executionPath[0]];
     if ((step?.type === "parallel" || step?.type === "conditional") && executionPath.length > 1) {
       step = step.steps[executionPath[1]];
@@ -1844,15 +2283,62 @@ var WorkflowEventProcessor = class extends EventProcessor {
         runId
       });
       const currentIdx = executionPath[1];
-      const currentResult = snapshot?.context?.[step.step.id]?.output;
+      const existingStepResult = snapshot?.context?.[step.step.id];
+      const currentResult = existingStepResult?.output;
+      const originalPayload = existingStepResult?.payload;
       let newResult = prevResult;
       if (currentIdx !== void 0) {
-        if (currentResult) {
-          currentResult[currentIdx] = prevResult.output;
-          newResult = { ...prevResult, output: currentResult };
-        } else {
-          newResult = { ...prevResult, output: [prevResult.output] };
-        }
+        if (prevResult.status === "bailed") {
+          const bailedResult = {
+            status: "success",
+            output: prevResult.output,
+            startedAt: existingStepResult?.startedAt ?? Date.now(),
+            endedAt: Date.now(),
+            payload: originalPayload
+          };
+          await workflowsStore?.updateWorkflowResults({
+            workflowName: workflow.id,
+            runId,
+            stepId: step.step.id,
+            result: bailedResult,
+            requestContext
+          });
+          return this.endWorkflow({
+            workflow,
+            parentWorkflow,
+            workflowId,
+            runId,
+            executionPath: [executionPath[0]],
+            resumeSteps,
+            stepResults: { ...stepResults, [step.step.id]: bailedResult },
+            prevResult: bailedResult,
+            activeSteps,
+            requestContext,
+            perStep,
+            state: currentState,
+            outputOptions
+          });
+        }
+        const iterationResult = prevResult.status === "suspended" ? prevResult : prevResult.output;
+        if (currentResult) {
+          currentResult[currentIdx] = iterationResult;
+          newResult = {
+            ...existingStepResult,
+            // Preserve step-level properties
+            ...prevResult,
+            // Get iteration timing info
+            output: currentResult,
+            payload: originalPayload,
+            // Preserve suspend metadata from first suspension
+            suspendPayload: existingStepResult?.suspendPayload ?? prevResult.suspendPayload,
+            suspendedAt: existingStepResult?.suspendedAt ?? prevResult.suspendedAt,
+            // Update resume metadata to most recent resume (new iteration takes precedence)
+            resumePayload: prevResult.resumePayload ?? existingStepResult?.resumePayload,
+            resumedAt: prevResult.resumedAt ?? existingStepResult?.resumedAt
+          };
+        } else {
+          newResult = { ...prevResult, output: [iterationResult], payload: originalPayload };
+        }
       }
       const newStepResults = await workflowsStore?.updateWorkflowResults({
         workflowName: workflow.id,
@@ -1865,12 +2351,159 @@ var WorkflowEventProcessor = class extends EventProcessor {
         return;
       }
       stepResults = newStepResults;
+      if (currentIdx !== void 0) {
+        const foreachResult = stepResults[step.step.id];
+        const iterationResults = foreachResult?.output ?? [];
+        const targetLen = foreachResult?.payload?.length ?? 0;
+        const pendingCount = iterationResults.filter((r) => r === null).length;
+        const suspendedCount = iterationResults.filter(
+          (r) => r && typeof r === "object" && r.status === "suspended"
+        ).length;
+        const iterationsStarted = iterationResults.length;
+        if (pendingCount > 0) {
+          return;
+        }
+        if (iterationsStarted < targetLen) {
+          await processWorkflowForEach(
+            {
+              workflowId,
+              prevResult: { status: "success", output: foreachResult.payload },
+              runId,
+              executionPath: [executionPath[0]],
+              stepResults,
+              activeSteps,
+              resumeSteps,
+              timeTravel,
+              resumeData: void 0,
+              // Don't pass resumeData when starting new iterations
+              parentWorkflow,
+              requestContext,
+              perStep,
+              state: currentState,
+              outputOptions
+            },
+            {
+              pubsub: this.mastra.pubsub,
+              mastra: this.mastra,
+              step
+            }
+          );
+          return;
+        }
+        if (suspendedCount > 0) {
+          const collectedResumeLabels = {};
+          const suspendedPaths = {
+            [step.step.id]: [executionPath[0]]
+          };
+          for (let i = 0; i < iterationResults.length; i++) {
+            const iterResult = iterationResults[i];
+            if (iterResult && typeof iterResult === "object" && iterResult.status === "suspended") {
+              if (iterResult.suspendPayload?.__workflow_meta?.resumeLabels) {
+                Object.assign(collectedResumeLabels, iterResult.suspendPayload.__workflow_meta.resumeLabels);
+              }
+            }
+          }
+          const foreachSuspendResult = {
+            status: "suspended",
+            output: iterationResults,
+            payload: foreachResult.payload,
+            suspendedAt: Date.now(),
+            startedAt: foreachResult.startedAt,
+            suspendPayload: {
+              __workflow_meta: {
+                path: executionPath,
+                resumeLabels: collectedResumeLabels
+              }
+            }
+          };
+          await workflowsStore?.updateWorkflowResults({
+            workflowName: workflow.id,
+            runId,
+            stepId: step.step.id,
+            result: foreachSuspendResult,
+            requestContext
+          });
+          const shouldPersist = workflow?.options?.shouldPersistSnapshot?.({
+            stepResults: stepResults ?? {},
+            workflowStatus: "suspended"
+          }) ?? true;
+          if (shouldPersist) {
+            await workflowsStore?.updateWorkflowResults({
+              workflowName: workflow.id,
+              runId,
+              stepId: "__state",
+              result: currentState,
+              requestContext
+            });
+            await workflowsStore?.updateWorkflowState({
+              workflowName: workflowId,
+              runId,
+              opts: {
+                status: "suspended",
+                result: foreachSuspendResult,
+                suspendedPaths,
+                resumeLabels: collectedResumeLabels
+              }
+            });
+          }
+          await this.mastra.pubsub.publish("workflows", {
+            type: "workflow.suspend",
+            runId,
+            data: {
+              workflowId,
+              runId,
+              executionPath: [executionPath[0]],
+              resumeSteps,
+              parentWorkflow,
+              stepResults: { ...stepResults, [step.step.id]: foreachSuspendResult },
+              prevResult: foreachSuspendResult,
+              activeSteps,
+              requestContext,
+              timeTravel,
+              state: currentState,
+              outputOptions
+            }
+          });
+          return;
+        }
+        await processWorkflowForEach(
+          {
+            workflowId,
+            prevResult: { status: "success", output: foreachResult.payload },
+            runId,
+            executionPath: [executionPath[0]],
+            stepResults,
+            activeSteps,
+            resumeSteps,
+            timeTravel,
+            resumeData: void 0,
+            parentWorkflow,
+            requestContext,
+            perStep,
+            state: currentState,
+            outputOptions
+          },
+          {
+            pubsub: this.mastra.pubsub,
+            mastra: this.mastra,
+            step
+          }
+        );
+        return;
+      }
     } else if (isExecutableStep(step)) {
       delete activeSteps[step.step.id];
       if (parentContext) {
         prevResult = stepResults[step.step.id] = {
           ...prevResult,
-          payload: parentContext.input?.output ?? {}
+          payload: parentContext.input?.output ?? {},
+          // Store nestedRunId in metadata for getWorkflowRunById retrieval
+          ...nestedRunId && {
+            metadata: {
+              ...prevResult.metadata,
+              nestedRunId
+            }
+          }
         };
       }
       const newStepResults = await workflowsStore?.updateWorkflowResults({
@@ -1885,6 +2518,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
       }
       stepResults = newStepResults;
     }
+    stepResults = { ...stepResults, __state: currentState };
     if (!prevResult?.status || prevResult.status === "failed") {
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.fail",
@@ -1899,7 +2533,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
           timeTravel,
           prevResult,
           activeSteps,
-          requestContext
+          requestContext,
+          state: currentState,
+          outputOptions
         }
       });
       return;
@@ -1909,15 +2545,30 @@ var WorkflowEventProcessor = class extends EventProcessor {
       if (suspendedStep) {
         suspendedPaths[suspendedStep.id] = executionPath;
       }
-      await workflowsStore?.updateWorkflowState({
-        workflowName: workflowId,
-        runId,
-        opts: {
-          status: "suspended",
-          result: prevResult,
-          suspendedPaths
-        }
-      });
+      const resumeLabels = prevResult.suspendPayload?.__workflow_meta?.resumeLabels ?? {};
+      const shouldPersist = workflow?.options?.shouldPersistSnapshot?.({
+        stepResults: stepResults ?? {},
+        workflowStatus: "suspended"
+      }) ?? true;
+      if (shouldPersist) {
+        await workflowsStore?.updateWorkflowResults({
+          workflowName: workflow.id,
+          runId,
+          stepId: "__state",
+          result: currentState,
+          requestContext
+        });
+        await workflowsStore?.updateWorkflowState({
+          workflowName: workflowId,
+          runId,
+          opts: {
+            status: "suspended",
+            result: prevResult,
+            suspendedPaths,
+            resumeLabels
+          }
+        });
+      }
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.suspend",
         runId,
@@ -1931,7 +2582,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
           prevResult,
           activeSteps,
           requestContext,
-          timeTravel
+          timeTravel,
+          state: currentState,
+          outputOptions
         }
       });
       await this.mastra.pubsub.publish(`workflow.events.v2.${runId}`, {
@@ -2040,10 +2693,14 @@ var WorkflowEventProcessor = class extends EventProcessor {
           prevResult: { status: "success", output: allResults },
           activeSteps,
           requestContext,
-          timeTravel
+          timeTravel,
+          state: currentState,
+          outputOptions
         }
       });
     } else if (step?.type === "foreach") {
+      const foreachStepResult = stepResults[step.step.id];
+      const originalArray = foreachStepResult?.payload;
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.step.run",
         runId,
@@ -2054,10 +2711,13 @@ var WorkflowEventProcessor = class extends EventProcessor {
           resumeSteps,
           parentWorkflow,
           stepResults,
-          prevResult: { ...prevResult, output: prevResult?.payload },
+          prevResult: { ...prevResult, output: originalArray },
           activeSteps,
           requestContext,
-          timeTravel
+          timeTravel,
+          state: currentState,
+          outputOptions,
+          forEachIndex
         }
       });
     } else if (executionPath[0] >= workflow.stepGraph.length - 1) {
@@ -2071,7 +2731,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
         stepResults,
         prevResult,
         activeSteps,
-        requestContext
+        requestContext,
+        state: currentState,
+        outputOptions
       });
     } else {
       await this.mastra.pubsub.publish("workflows", {
@@ -2087,7 +2749,9 @@ var WorkflowEventProcessor = class extends EventProcessor {
           prevResult,
           activeSteps,
           requestContext,
-          timeTravel
+          timeTravel,
+          state: currentState,
+          outputOptions
         }
       });
     }
@@ -2288,6 +2952,57 @@ function createStepFromParams(params) {
     execute: params.execute.bind(params)
   };
 }
+async function processAgentStream(params) {
+  const { fullStream, isV2Model, pubsub, runId, toolData, logger } = params;
+  try {
+    await pubsub.publish(`workflow.events.v2.${runId}`, {
+      type: "watch",
+      runId,
+      data: { type: "tool-call-streaming-start", ...toolData }
+    });
+  } catch (err) {
+    logger?.debug("Failed to publish stream start event", { runId, error: err });
+  }
+  let tripwireChunk = null;
+  for await (const chunk of fullStream) {
+    if (isTripwireChunk(chunk)) {
+      tripwireChunk = chunk;
+      break;
+    }
+    if (typeof chunk === "object" && chunk !== null && "type" in chunk && chunk.type === "text-delta") {
+      const textDelta = getTextDeltaFromChunk(chunk, isV2Model);
+      if (textDelta) {
+        try {
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: { type: "tool-call-delta", ...toolData, argsTextDelta: textDelta }
+          });
+        } catch (err) {
+          logger?.debug("Failed to publish stream delta event", { runId, error: err });
+        }
+      }
+    }
+  }
+  try {
+    await pubsub.publish(`workflow.events.v2.${runId}`, {
+      type: "watch",
+      runId,
+      data: { type: "tool-call-streaming-finish", ...toolData }
+    });
+  } catch (err) {
+    logger?.debug("Failed to publish stream finish event", { runId, error: err });
+  }
+  return { tripwireChunk };
+}
+async function safeOnFinish(callback, result, logger) {
+  if (!callback) return;
+  try {
+    await callback(result);
+  } catch (err) {
+    logger?.warn("User onFinish callback threw an error", { error: err });
+  }
+}
 function createStepFromAgent(params, agentOrToolOptions) {
   const options = agentOrToolOptions ?? {};
   const outputSchema = options?.structuredOutput?.schema ?? z.object({ text: z.string() });
@@ -2304,54 +3019,80 @@ function createStepFromAgent(params, agentOrToolOptions) {
     execute: async ({
       inputData,
       runId,
+      mastra,
       [PUBSUB_SYMBOL]: pubsub,
       requestContext,
       tracingContext,
       abortSignal,
       abort
     }) => {
-      let streamPromise = {};
-      streamPromise.promise = new Promise((resolve, reject) => {
-        streamPromise.resolve = resolve;
-        streamPromise.reject = reject;
-      });
-      const { fullStream } = await params.streamLegacy(inputData.prompt, {
-        ...agentOptions ?? {},
-        tracingContext,
-        requestContext,
-        onFinish: (result) => {
-          streamPromise.resolve(result.text);
-        },
-        abortSignal
-      });
-      if (abortSignal.aborted) {
-        return abort();
-      }
+      const logger = mastra?.getLogger();
       const toolData = {
         name: params.name,
         args: inputData
       };
-      await pubsub.publish(`workflow.events.v2.${runId}`, {
-        type: "watch",
-        runId,
-        data: { type: "tool-call-streaming-start", ...toolData ?? {} }
-      });
-      for await (const chunk of fullStream) {
-        if (chunk.type === "text-delta") {
-          await pubsub.publish(`workflow.events.v2.${runId}`, {
-            type: "watch",
-            runId,
-            data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
-          });
+      const llm = await params.getLLM({ requestContext });
+      const modelInfo = llm.getModel();
+      const isV2Model = isSupportedLanguageModel(modelInfo);
+      let structuredResult = null;
+      const handleFinish = (result) => {
+        const resultWithObject = result;
+        if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
+          structuredResult = resultWithObject.object;
         }
+      };
+      let fullStream;
+      let textPromise;
+      if (isV2Model) {
+        const modelOutput = await params.stream(inputData.prompt, {
+          ...agentOptions ?? {},
+          tracingContext,
+          requestContext,
+          onFinish: (result) => {
+            handleFinish(result);
+            void safeOnFinish(agentOptions?.onFinish, result, logger);
+          },
+          abortSignal
+        });
+        fullStream = modelOutput.fullStream;
+        textPromise = modelOutput.text;
+      } else {
+        let resolveText;
+        textPromise = new Promise((resolve) => {
+          resolveText = resolve;
+        });
+        const legacyResult = await params.streamLegacy(inputData.prompt, {
+          ...agentOptions ?? {},
+          tracingContext,
+          requestContext,
+          onFinish: (result) => {
+            handleFinish(result);
+            resolveText(result.text);
+            void safeOnFinish(agentOptions?.onFinish, result, logger);
+          },
+          abortSignal
+        });
+        fullStream = legacyResult.fullStream;
       }
-      await pubsub.publish(`workflow.events.v2.${runId}`, {
-        type: "watch",
+      if (abortSignal.aborted) {
+        return abort();
+      }
+      const { tripwireChunk } = await processAgentStream({
+        fullStream,
+        isV2Model,
+        pubsub,
         runId,
-        data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
+        toolData,
+        logger
       });
+      if (tripwireChunk) {
+        throw createTripWireFromChunk(tripwireChunk);
+      }
+      if (structuredResult !== null) {
+        return structuredResult;
+      }
       return {
-        text: await streamPromise.promise
+        text: await textPromise
       };
     },
     component: params.component
@@ -2879,6 +3620,8 @@ var EventedWorkflow = class extends Workflow {
       cleanup: () => this.runs.delete(runIdToUse),
       workflowSteps: this.steps,
       validateInputs: this.options?.validateInputs,
+      inputSchema: this.inputSchema,
+      stateSchema: this.stateSchema,
       workflowEngineType: this.engineType
     });
     this.runs.set(runIdToUse, run);
@@ -2890,6 +3633,9 @@ var EventedWorkflow = class extends Workflow {
       withNestedWorkflows: false
     });
     const existsInStorage = existingRun && !existingRun.isFromInMemory;
+    if (existsInStorage && existingRun.status) {
+      run.workflowRunStatus = existingRun.status;
+    }
     if (!existsInStorage && shouldPersistSnapshot) {
       const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
       await workflowsStore?.persistWorkflowSnapshot({
@@ -2944,7 +3690,8 @@ var EventedRun = class extends Run {
     inputData,
     initialState,
     requestContext,
-    perStep
+    perStep,
+    outputOptions
   }) {
     if (this.serializedStepGraph.length === 0) {
       throw new Error(
@@ -2984,6 +3731,7 @@ var EventedRun = class extends Run {
     const result = await this.executionEngine.execute({
       workflowId: this.workflowId,
       runId: this.runId,
+      resourceId: this.resourceId,
       graph: this.executionGraph,
       serializedStepGraph: this.serializedStepGraph,
       input: inputDataToUse,
@@ -2992,7 +3740,8 @@ var EventedRun = class extends Run {
       retryConfig: this.retryConfig,
       requestContext,
       abortController: this.abortController,
-      perStep
+      perStep,
+      outputOptions
     });
     if (result.status !== "suspended") {
       this.cleanup?.();
@@ -3058,19 +3807,147 @@ var EventedRun = class extends Run {
     });
     return { runId: this.runId };
   }
-  // TODO: stream
-  async resume(params) {
-    let steps = [];
-    if (typeof params.step === "string") {
-      steps = params.step.split(".");
-    } else {
-      steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
-        (step) => typeof step === "string" ? step : step?.id
-      );
-    }
-    if (steps.length === 0) {
-      throw new Error("No steps provided to resume");
+  /**
+   * Starts the workflow execution as a stream, returning a WorkflowRunOutput
+   * with .fullStream for iteration and .result for the final result.
+   */
+  stream({
+    inputData,
+    requestContext,
+    initialState,
+    closeOnSuspend = true,
+    perStep,
+    outputOptions
+  }) {
+    if (this.closeStreamAction && this.streamOutput) {
+      return this.streamOutput;
     }
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch((event) => {
+          const { type, payload } = event;
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from: "WORKFLOW" /* WORKFLOW */,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            if (controller.desiredSize !== null) {
+              controller.close();
+            }
+          } catch (err) {
+            self.mastra?.getLogger()?.error("Error closing stream:", err);
+          }
+        };
+        try {
+          const executionResults = await self.start({
+            inputData,
+            requestContext,
+            initialState,
+            perStep,
+            outputOptions
+          });
+          if (self.streamOutput) {
+            self.streamOutput.updateResults(executionResults);
+          }
+          if (closeOnSuspend) {
+            self.closeStreamAction?.().catch(() => {
+            });
+          } else if (executionResults.status !== "suspended") {
+            self.closeStreamAction?.().catch(() => {
+            });
+          }
+        } catch (err) {
+          self.streamOutput?.rejectResults(err);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return this.streamOutput;
+  }
+  /**
+   * Resumes a suspended workflow as a stream, returning a WorkflowRunOutput
+   * with .fullStream for iteration and .result for the final result.
+   */
+  resumeStream({
+    step,
+    resumeData,
+    requestContext,
+    perStep,
+    outputOptions
+  } = {}) {
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch((event) => {
+          const { type, payload } = event;
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from: "WORKFLOW" /* WORKFLOW */,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            if (controller.desiredSize !== null) {
+              controller.close();
+            }
+          } catch (err) {
+            self.mastra?.getLogger()?.error("Error closing stream:", err);
+          }
+        };
+        try {
+          const executionResults = await self.resume({
+            resumeData,
+            step,
+            requestContext,
+            perStep,
+            outputOptions
+          });
+          if (self.streamOutput) {
+            self.streamOutput.updateResults(executionResults);
+          }
+          await new Promise((resolve) => setTimeout(resolve, 0));
+          self.closeStreamAction?.().catch(() => {
+          });
+        } catch (err) {
+          self.streamOutput?.rejectResults(err);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return this.streamOutput;
+  }
+  async resume(params) {
     const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
     if (!workflowsStore) {
       throw new Error("Cannot resume workflow: workflows store is required");
@@ -3082,12 +3959,62 @@ var EventedRun = class extends Run {
     if (!snapshot) {
       throw new Error(`Cannot resume workflow: no snapshot found for runId ${this.runId}`);
     }
-    const resumePath = snapshot.suspendedPaths?.[steps[0]];
-    if (!resumePath) {
+    if (snapshot.status !== "suspended") {
+      throw new Error("This workflow run was not suspended");
+    }
+    const snapshotResumeLabel = params.label ? snapshot?.resumeLabels?.[params.label] : void 0;
+    if (params.label && !snapshotResumeLabel) {
+      const availableLabels = Object.keys(snapshot?.resumeLabels ?? {});
+      throw new Error(
+        `Resume label "${params.label}" not found. Available labels: [${availableLabels.join(", ")}]`
+      );
+    }
+    const stepParam = snapshotResumeLabel?.stepId ?? params.step;
+    let steps;
+    if (stepParam) {
+      if (typeof stepParam === "string") {
+        steps = stepParam.split(".");
+      } else {
+        steps = (Array.isArray(stepParam) ? stepParam : [stepParam]).map(
+          (step) => typeof step === "string" ? step : step?.id
+        );
+      }
+    } else {
+      const suspendedStepPaths = [];
+      Object.entries(snapshot?.suspendedPaths ?? {}).forEach(([stepId, _executionPath]) => {
+        const stepResult = snapshot?.context?.[stepId];
+        if (stepResult && typeof stepResult === "object" && "status" in stepResult) {
+          const stepRes = stepResult;
+          if (stepRes.status === "suspended") {
+            const nestedPath = stepRes.suspendPayload?.__workflow_meta?.path;
+            if (nestedPath && Array.isArray(nestedPath)) {
+              suspendedStepPaths.push([stepId, ...nestedPath]);
+            } else {
+              suspendedStepPaths.push([stepId]);
+            }
+          }
+        }
+      });
+      if (suspendedStepPaths.length === 0) {
+        throw new Error("No suspended steps found in this workflow run");
+      }
+      if (suspendedStepPaths.length === 1) {
+        steps = suspendedStepPaths[0];
+      } else {
+        const pathStrings = suspendedStepPaths.map((path) => `[${path.join(", ")}]`);
+        throw new Error(
+          `Multiple suspended steps found: ${pathStrings.join(", ")}. Please specify which step to resume using the "step" parameter.`
+        );
+      }
+    }
+    const suspendedStepIds = Object.keys(snapshot?.suspendedPaths ?? {});
+    const isStepSuspended = suspendedStepIds.includes(steps?.[0] ?? "");
+    if (!isStepSuspended) {
       throw new Error(
-        `No resume path found for step ${JSON.stringify(steps)}, currently suspended paths are ${JSON.stringify(snapshot.suspendedPaths)}`
+        `This workflow step "${steps?.[0]}" was not suspended. Available suspended steps: [${suspendedStepIds.join(", ")}]`
       );
     }
+    const resumePath = snapshot.suspendedPaths?.[steps[0]];
     console.dir(
       { resume: { requestContextObj: snapshot.requestContext, requestContext: params.requestContext } },
       { depth: null }
@@ -3108,22 +4035,26 @@ var EventedRun = class extends Run {
       throw new Error("Mastra instance with pubsub is required for workflow execution");
     }
     this.setupAbortHandler();
+    const resumeState = snapshot?.context?.__state ?? snapshot?.value ?? {};
     const executionResultPromise = this.executionEngine.execute({
       workflowId: this.workflowId,
       runId: this.runId,
       graph: this.executionGraph,
       serializedStepGraph: this.serializedStepGraph,
       input: snapshot?.context?.input,
+      initialState: resumeState,
       resume: {
         steps,
         stepResults: snapshot?.context,
         resumePayload: resumeDataToUse,
-        resumePath
+        resumePath,
+        forEachIndex: params.forEachIndex ?? snapshotResumeLabel?.foreachIndex
       },
       pubsub: this.mastra.pubsub,
       requestContext,
       abortController: this.abortController,
-      perStep: params.perStep
+      perStep: params.perStep,
+      outputOptions: params.outputOptions
     }).then((result) => {
       if (result.status !== "suspended") {
         this.closeStreamAction?.().catch(() => {
@@ -3178,6 +4109,18 @@ var EventedRun = class extends Run {
 };
 
 // src/workflows/evented/workflow-event-processor/utils.ts
+function isWorkflowStep(step) {
+  if (!step || typeof step !== "object") {
+    return false;
+  }
+  if (step instanceof EventedWorkflow) {
+    return true;
+  }
+  if ("component" in step && step.component === "WORKFLOW") {
+    return true;
+  }
+  return false;
+}
 function getNestedWorkflow(mastra, { workflowId, executionPath, parentWorkflow }) {
   let workflow = null;
   if (parentWorkflow) {
@@ -3194,7 +4137,16 @@ function getNestedWorkflow(mastra, { workflowId, executionPath, parentWorkflow }
     parentStep = parentStep.steps[executionPath[1]];
   }
   if (parentStep?.type === "step" || parentStep?.type === "loop") {
-    return parentStep.step;
+    if (isWorkflowStep(parentStep.step)) {
+      return parentStep.step;
+    }
+    return null;
+  }
+  if (parentStep?.type === "foreach") {
+    if (isWorkflowStep(parentStep.step)) {
+      return parentStep.step;
+    }
+    return null;
   }
   return null;
 }
@@ -3246,101 +4198,147 @@ var EventedExecutionEngine = class extends ExecutionEngine {
     if (!pubsub) {
       throw new Error("No Pubsub adapter configured on the Mastra instance");
     }
-    if (params.resume) {
-      const prevStep = getStep(this.mastra.getWorkflow(params.workflowId), params.resume.resumePath);
-      const prevResult = params.resume.stepResults[prevStep?.id ?? "input"];
-      await pubsub.publish("workflows", {
-        type: "workflow.resume",
-        runId: params.runId,
-        data: {
-          workflowId: params.workflowId,
-          runId: params.runId,
-          executionPath: params.resume.resumePath,
-          stepResults: params.resume.stepResults,
-          resumeSteps: params.resume.steps,
-          prevResult: { status: "success", output: prevResult?.payload },
-          resumeData: params.resume.resumePayload,
-          requestContext: Object.fromEntries(params.requestContext.entries()),
-          format: params.format,
-          perStep: params.perStep
+    let resolveResult;
+    let rejectResult;
+    const resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    const finishCb = async (event, ack) => {
+      if (event.runId !== params.runId) {
+        await ack?.();
+        return;
+      }
+      if (["workflow.end", "workflow.fail", "workflow.suspend"].includes(event.type)) {
+        await ack?.();
+        await pubsub.unsubscribe("workflows-finish", finishCb);
+        if (event.type === "workflow.fail" && event.data.stepResults) {
+          event.data.stepResults = hydrateSerializedStepErrors(event.data.stepResults);
         }
-      });
-    } else if (params.timeTravel) {
-      const prevStep = getStep(this.mastra.getWorkflow(params.workflowId), params.timeTravel.executionPath);
-      const prevResult = params.timeTravel.stepResults[prevStep?.id ?? "input"];
-      await pubsub.publish("workflows", {
-        type: "workflow.start",
-        runId: params.runId,
-        data: {
-          workflowId: params.workflowId,
+        resolveResult(event.data);
+        return;
+      }
+      await ack?.();
+    };
+    try {
+      await pubsub.subscribe("workflows-finish", finishCb);
+    } catch (err) {
+      this.mastra?.getLogger()?.error("Failed to subscribe to workflows-finish:", err);
+      throw err;
+    }
+    try {
+      if (params.resume) {
+        const prevStep = getStep(this.mastra.getWorkflow(params.workflowId), params.resume.resumePath);
+        const prevResult = params.resume.stepResults[prevStep?.id ?? "input"];
+        const resumeState = params.resume.stepResults?.__state ?? params.initialState ?? {};
+        await pubsub.publish("workflows", {
+          type: "workflow.resume",
           runId: params.runId,
-          executionPath: params.timeTravel.executionPath,
-          stepResults: params.timeTravel.stepResults,
-          timeTravel: params.timeTravel,
-          prevResult: { status: "success", output: prevResult?.payload },
-          requestContext: Object.fromEntries(params.requestContext.entries()),
-          format: params.format,
-          perStep: params.perStep
-        }
-      });
-    } else {
-      await pubsub.publish("workflows", {
-        type: "workflow.start",
-        runId: params.runId,
-        data: {
-          workflowId: params.workflowId,
+          data: {
+            workflowId: params.workflowId,
+            runId: params.runId,
+            executionPath: params.resume.resumePath,
+            stepResults: params.resume.stepResults,
+            resumeSteps: params.resume.steps,
+            prevResult: { status: "success", output: prevResult?.payload },
+            resumeData: params.resume.resumePayload,
+            requestContext: Object.fromEntries(params.requestContext.entries()),
+            format: params.format,
+            perStep: params.perStep,
+            initialState: resumeState,
+            state: resumeState,
+            outputOptions: params.outputOptions,
+            forEachIndex: params.resume.forEachIndex
+          }
+        });
+      } else if (params.timeTravel) {
+        const prevStep = getStep(this.mastra.getWorkflow(params.workflowId), params.timeTravel.executionPath);
+        const prevResult = params.timeTravel.stepResults[prevStep?.id ?? "input"];
+        await pubsub.publish("workflows", {
+          type: "workflow.start",
           runId: params.runId,
-          prevResult: { status: "success", output: params.input },
-          requestContext: Object.fromEntries(params.requestContext.entries()),
-          format: params.format,
-          perStep: params.perStep
-        }
-      });
-    }
-    const resultData = await new Promise((resolve, reject) => {
-      const finishCb = async (event, ack) => {
-        if (event.runId !== params.runId) {
-          await ack?.();
-          return;
-        }
-        if (["workflow.end", "workflow.fail", "workflow.suspend"].includes(event.type)) {
-          await ack?.();
-          await pubsub.unsubscribe("workflows-finish", finishCb);
-          if (event.type === "workflow.fail" && event.data.stepResults) {
-            event.data.stepResults = hydrateSerializedStepErrors(event.data.stepResults);
+          data: {
+            workflowId: params.workflowId,
+            runId: params.runId,
+            executionPath: params.timeTravel.executionPath,
+            stepResults: params.timeTravel.stepResults,
+            timeTravel: params.timeTravel,
+            prevResult: { status: "success", output: prevResult?.payload },
+            requestContext: Object.fromEntries(params.requestContext.entries()),
+            format: params.format,
+            perStep: params.perStep
           }
-          resolve(event.data);
-          return;
-        }
-        await ack?.();
-      };
-      pubsub.subscribe("workflows-finish", finishCb).catch((err) => {
-        this.mastra?.getLogger()?.error("Failed to subscribe to workflows-finish:", err);
-        reject(err);
-      });
-    });
+        });
+      } else {
+        await pubsub.publish("workflows", {
+          type: "workflow.start",
+          runId: params.runId,
+          data: {
+            workflowId: params.workflowId,
+            runId: params.runId,
+            prevResult: { status: "success", output: params.input },
+            requestContext: Object.fromEntries(params.requestContext.entries()),
+            format: params.format,
+            perStep: params.perStep,
+            initialState: params.initialState,
+            outputOptions: params.outputOptions
+          }
+        });
+      }
+    } catch (err) {
+      await pubsub.unsubscribe("workflows-finish", finishCb);
+      rejectResult(err);
+      throw err;
+    }
+    const resultData = await resultPromise;
+    const finalState = resultData.state ?? resultData.stepResults?.__state ?? params.initialState ?? {};
+    const { __state: _removedState, ...stepResultsWithoutTopLevelState } = resultData.stepResults ?? {};
+    const cleanStepResults = {};
+    for (const [stepId, stepResult] of Object.entries(stepResultsWithoutTopLevelState)) {
+      cleanStepResults[stepId] = cleanStepResult(stepResult);
+    }
     let callbackArg;
     if (resultData.prevResult.status === "failed") {
-      callbackArg = {
-        status: "failed",
-        error: resultData.prevResult.error,
-        steps: resultData.stepResults
-      };
+      let tripwireData;
+      for (const stepResult of Object.values(cleanStepResults)) {
+        if (stepResult?.status === "failed" && stepResult?.tripwire) {
+          tripwireData = stepResult.tripwire;
+          break;
+        }
+      }
+      if (tripwireData && typeof tripwireData === "object" && "reason" in tripwireData) {
+        callbackArg = {
+          status: "tripwire",
+          steps: cleanStepResults,
+          state: finalState,
+          tripwire: tripwireData
+        };
+      } else {
+        callbackArg = {
+          status: "failed",
+          error: resultData.prevResult.error,
+          steps: cleanStepResults,
+          state: finalState
+        };
+      }
     } else if (resultData.prevResult.status === "suspended") {
       callbackArg = {
         status: "suspended",
-        steps: resultData.stepResults
+        steps: cleanStepResults,
+        state: finalState
       };
     } else if (resultData.prevResult.status === "paused" || params.perStep) {
       callbackArg = {
         status: "paused",
-        steps: resultData.stepResults
+        steps: cleanStepResults,
+        state: finalState
       };
     } else {
       callbackArg = {
         status: resultData.prevResult.status,
         result: resultData.prevResult?.output,
-        steps: resultData.stepResults
+        steps: cleanStepResults,
+        state: finalState
       };
     }
     if (callbackArg.status !== "paused") {
@@ -3349,13 +4347,13 @@ var EventedExecutionEngine = class extends ExecutionEngine {
         result: callbackArg.result,
         error: callbackArg.error,
         steps: callbackArg.steps,
-        tripwire: void 0,
+        tripwire: callbackArg.tripwire,
         runId: params.runId,
         workflowId: params.workflowId,
-        resourceId: void 0,
+        resourceId: params.resourceId,
         input: params.input,
         requestContext: params.requestContext,
-        state: {}
+        state: finalState
       });
     }
     let result;
@@ -3367,16 +4365,43 @@ var EventedExecutionEngine = class extends ExecutionEngine {
         return null;
       }).filter(Boolean);
       result = {
-        ...callbackArg,
+        status: callbackArg.status,
+        steps: callbackArg.steps,
         suspended: suspendedSteps
       };
+    } else if (resultData.prevResult.status === "failed") {
+      if (callbackArg.status === "tripwire" && callbackArg.tripwire) {
+        result = {
+          status: "tripwire",
+          tripwire: callbackArg.tripwire,
+          steps: callbackArg.steps
+        };
+      } else {
+        result = {
+          status: callbackArg.status,
+          error: callbackArg.error,
+          steps: callbackArg.steps
+        };
+      }
+    } else if (resultData.prevResult.status === "paused" || params.perStep) {
+      result = {
+        status: "paused",
+        steps: callbackArg.steps
+      };
     } else {
-      result = callbackArg;
+      result = {
+        status: callbackArg.status,
+        result: callbackArg.result,
+        steps: callbackArg.steps
+      };
+    }
+    if (params.outputOptions?.includeState) {
+      result.state = finalState;
     }
     return result;
   }
 };
 
 export { EventedExecutionEngine, EventedRun, EventedWorkflow, StepExecutor, WorkflowEventProcessor, cloneStep, cloneWorkflow, createStep, createWorkflow };
-//# sourceMappingURL=chunk-YQMDMIP6.js.map
-//# sourceMappingURL=chunk-YQMDMIP6.js.map
+//# sourceMappingURL=chunk-FYMM4PKR.js.map
+//# sourceMappingURL=chunk-FYMM4PKR.js.map