@mastra/inngest 0.0.0-netlify-no-bundle-20251127120354 → 0.0.0-partial-response-backport-20251204204441

package/dist/index.cjs

@@ -3,8 +3,8 @@
 var crypto = require('crypto');
 var web = require('stream/web');
 var realtime = require('@inngest/realtime');
+var aiTracing = require('@mastra/core/ai-tracing');
 var di = require('@mastra/core/di');
-var observability = require('@mastra/core/observability');
 var stream = require('@mastra/core/stream');
 var tools = require('@mastra/core/tools');
 var workflows = require('@mastra/core/workflows');
@@ -20,7 +20,7 @@ function serve({
   functions: userFunctions = [],
   registerOptions
 }) {
-  const wfs = mastra.listWorkflows();
+  const wfs = mastra.getWorkflows();
   const workflowFunctions = Array.from(
     new Set(
       Object.values(wfs).flatMap((wf) => {
@@ -59,12 +59,11 @@ var InngestRun = class extends workflows.Run {
   }
   async getRunOutput(eventId) {
     let runs = await this.getRuns(eventId);
-    const storage = this.#mastra?.getStorage();
     while (runs?.[0]?.status !== "Completed" || runs?.[0]?.event_id !== eventId) {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
       runs = await this.getRuns(eventId);
       if (runs?.[0]?.status === "Failed") {
-        const snapshot = await storage?.loadWorkflowSnapshot({
+        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
           workflowName: this.workflowId,
           runId: this.runId
         });
@@ -73,7 +72,7 @@ var InngestRun = class extends workflows.Run {
         };
       }
       if (runs?.[0]?.status === "Cancelled") {
-        const snapshot = await storage?.loadWorkflowSnapshot({
+        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
           workflowName: this.workflowId,
           runId: this.runId
         });
@@ -82,20 +81,25 @@ var InngestRun = class extends workflows.Run {
     }
     return runs?.[0];
   }
+  async sendEvent(event, data) {
+    await this.inngest.send({
+      name: `user-event-${event}`,
+      data
+    });
+  }
   async cancel() {
-    const storage = this.#mastra?.getStorage();
     await this.inngest.send({
       name: `cancel.workflow.${this.workflowId}`,
       data: {
         runId: this.runId
       }
     });
-    const snapshot = await storage?.loadWorkflowSnapshot({
+    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
     if (snapshot) {
-      await storage?.persistWorkflowSnapshot({
+      await this.#mastra?.storage?.persistWorkflowSnapshot({
         workflowName: this.workflowId,
         runId: this.runId,
         resourceId: this.resourceId,
@@ -107,15 +111,9 @@ var InngestRun = class extends workflows.Run {
       });
     }
   }
-  async start(params) {
-    return this._start(params);
-  }
-  async _start({
+  async start({
     inputData,
-    initialState,
-    outputOptions,
-    tracingOptions,
-    format
+    initialState
   }) {
     await this.#mastra.getStorage()?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
@@ -143,10 +141,7 @@ var InngestRun = class extends workflows.Run {
         inputData: inputDataToUse,
         initialState: initialStateToUse,
         runId: this.runId,
-        resourceId: this.resourceId,
-        outputOptions,
-        tracingOptions,
-        format
+        resourceId: this.resourceId
       }
     });
     const eventId = eventOutput.ids[0];
@@ -202,7 +197,8 @@ var InngestRun = class extends workflows.Run {
           steps,
           stepResults: snapshot?.context,
           resumePayload: resumeDataToUse,
-          resumePath: steps?.[0] ? snapshot?.suspendedPaths?.[steps?.[0]] : void 0
+          // @ts-ignore
+          resumePath: snapshot?.suspendedPaths?.[steps?.[0]]
         }
       }
     });
@@ -217,6 +213,29 @@ var InngestRun = class extends workflows.Run {
     }
     return result;
   }
+  watch(cb, type = "watch") {
+    let active = true;
+    const streamPromise = realtime.subscribe(
+      {
+        channel: `workflow:${this.workflowId}:${this.runId}`,
+        topics: [type],
+        app: this.inngest
+      },
+      (message) => {
+        if (active) {
+          cb(message.data);
+        }
+      }
+    );
+    return () => {
+      active = false;
+      streamPromise.then(async (stream) => {
+        return stream.cancel();
+      }).catch((err) => {
+        console.error(err);
+      });
+    };
+  }
   async timeTravel(params) {
     const p = this._timeTravel(params).then((result) => {
       if (result.status !== "suspended") {
@@ -308,58 +327,20 @@ var InngestRun = class extends workflows.Run {
     }
     return result;
   }
-  watch(cb) {
-    let active = true;
-    const streamPromise = realtime.subscribe(
-      {
-        channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: ["watch"],
-        app: this.inngest
-      },
-      (message) => {
-        if (active) {
-          cb(message.data);
-        }
-      }
-    );
-    return () => {
-      active = false;
-      streamPromise.then(async (stream) => {
-        return stream.cancel();
-      }).catch((err) => {
-        console.error(err);
-      });
-    };
-  }
-  streamLegacy({ inputData, requestContext } = {}) {
+  streamLegacy({ inputData, runtimeContext } = {}) {
     const { readable, writable } = new TransformStream();
     const writer = writable.getWriter();
-    void writer.write({
-      // @ts-ignore
-      type: "start",
-      // @ts-ignore
-      payload: { runId: this.runId }
-    });
     const unwatch = this.watch(async (event) => {
       try {
         const e = {
           ...event,
           type: event.type.replace("workflow-", "")
         };
-        if (e.type === "step-output") {
-          e.type = e.payload.output.type;
-          e.payload = e.payload.output.payload;
-        }
         await writer.write(e);
       } catch {
       }
-    });
+    }, "watch-v2");
     this.closeStreamAction = async () => {
-      await writer.write({
-        type: "finish",
-        // @ts-ignore
-        payload: { runId: this.runId }
-      });
       unwatch();
       try {
         await writer.close();
@@ -369,7 +350,7 @@ var InngestRun = class extends workflows.Run {
         writer.releaseLock();
       }
     };
-    this.executionResults = this._start({ inputData, requestContext, format: "legacy" }).then((result) => {
+    this.executionResults = this.start({ inputData, runtimeContext }).then((result) => {
       if (result.status !== "suspended") {
         this.closeStreamAction?.().catch(() => {
         });
@@ -383,18 +364,11 @@ var InngestRun = class extends workflows.Run {
   }
   stream({
     inputData,
-    requestContext,
-    tracingOptions,
-    closeOnSuspend = true,
-    initialState,
-    outputOptions
+    runtimeContext,
+    closeOnSuspend = true
   } = {}) {
-    if (this.closeStreamAction && this.streamOutput) {
-      return this.streamOutput;
-    }
-    this.closeStreamAction = async () => {
-    };
     const self = this;
+    let streamOutput;
     const stream$1 = new web.ReadableStream({
       async start(controller) {
         const unwatch = self.watch(async ({ type, from = stream.ChunkFrom.WORKFLOW, payload }) => {
@@ -403,11 +377,11 @@ var InngestRun = class extends workflows.Run {
             runId: self.runId,
             from,
             payload: {
-              stepName: payload?.id,
+              stepName: payload.id,
               ...payload
             }
           });
-        });
+        }, "watch-v2");
         self.closeStreamAction = async () => {
           unwatch();
           try {
@@ -416,46 +390,29 @@ var InngestRun = class extends workflows.Run {
             console.error("Error closing stream:", err);
           }
         };
-        const executionResultsPromise = self._start({
+        const executionResultsPromise = self.start({
           inputData,
-          requestContext,
-          // tracingContext, // We are not able to pass a reference to a span here, what to do?
-          initialState,
-          tracingOptions,
-          outputOptions,
-          format: "vnext"
+          runtimeContext
         });
-        let executionResults;
-        try {
-          executionResults = await executionResultsPromise;
-          if (closeOnSuspend) {
-            self.closeStreamAction?.().catch(() => {
-            });
-          } else if (executionResults.status !== "suspended") {
-            self.closeStreamAction?.().catch(() => {
-            });
-          }
-          if (self.streamOutput) {
-            self.streamOutput.updateResults(
-              executionResults
-            );
-          }
-        } catch (err) {
-          self.streamOutput?.rejectResults(err);
+        const executionResults = await executionResultsPromise;
+        if (closeOnSuspend) {
           self.closeStreamAction?.().catch(() => {
           });
+        } else if (executionResults.status !== "suspended") {
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+        if (streamOutput) {
+          streamOutput.updateResults(executionResults);
         }
       }
     });
-    this.streamOutput = new stream.WorkflowRunOutput({
+    streamOutput = new stream.WorkflowRunOutput({
       runId: this.runId,
       workflowId: this.workflowId,
       stream: stream$1
     });
-    return this.streamOutput;
-  }
-  streamVNext(args = {}) {
-    return this.stream(args);
+    return streamOutput;
   }
   timeTravelStream({
     inputData,
@@ -464,13 +421,12 @@ var InngestRun = class extends workflows.Run {
     step,
     context,
     nestedStepsContext,
-    requestContext,
+    runtimeContext,
     tracingOptions,
     outputOptions
   }) {
-    this.closeStreamAction = async () => {
-    };
     const self = this;
+    let streamOutput;
     const stream$1 = new web.ReadableStream({
       async start(controller) {
         const unwatch = self.watch(async ({ type, from = stream.ChunkFrom.WORKFLOW, payload }) => {
@@ -483,7 +439,7 @@ var InngestRun = class extends workflows.Run {
               ...payload
             }
           });
-        });
+        }, "watch-v2");
         self.closeStreamAction = async () => {
           unwatch();
           try {
@@ -499,7 +455,7 @@ var InngestRun = class extends workflows.Run {
           nestedStepsContext,
           resumeData,
           initialState,
-          requestContext,
+          runtimeContext,
           tracingOptions,
           outputOptions
         });
@@ -509,22 +465,22 @@ var InngestRun = class extends workflows.Run {
           executionResults = await executionResultsPromise;
           self.closeStreamAction?.().catch(() => {
           });
-          if (self.streamOutput) {
-            self.streamOutput.updateResults(executionResults);
+          if (streamOutput) {
+            streamOutput.updateResults(executionResults);
           }
         } catch (err) {
-          self.streamOutput?.rejectResults(err);
+          streamOutput?.rejectResults(err);
           self.closeStreamAction?.().catch(() => {
           });
         }
       }
     });
-    this.streamOutput = new stream.WorkflowRunOutput({
+    streamOutput = new stream.WorkflowRunOutput({
       runId: this.runId,
       workflowId: this.workflowId,
       stream: stream$1
     });
-    return this.streamOutput;
+    return streamOutput;
   }
 };
 var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
@@ -543,13 +499,13 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     this.#mastra = params.mastra;
     this.inngest = inngest;
   }
-  async listWorkflowRuns(args) {
+  async getWorkflowRuns(args) {
     const storage = this.#mastra?.getStorage();
     if (!storage) {
       this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
       return { runs: [], total: 0 };
     }
-    return storage.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
+    return storage.getWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
   async getWorkflowRunById(runId) {
     const storage = this.#mastra?.getStorage();
@@ -578,7 +534,16 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       }
     }
   }
-  async createRun(options) {
+  /**
+   * @deprecated Use createRunAsync() instead.
+   * @throws {Error} Always throws an error directing users to use createRunAsync()
+   */
+  createRun(_options) {
+    throw new Error(
+      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = workflow.createRun();\n  After:  const run = await workflow.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
+    );
+  }
+  async createRunAsync(options) {
     const runIdToUse = options?.runId || crypto.randomUUID();
     const run = this.runs.get(runIdToUse) ?? new InngestRun(
       {
@@ -621,6 +586,7 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
           resumeLabels: {},
           result: void 0,
           error: void 0,
+          // @ts-ignore
           timestamp: Date.now()
         }
       });
@@ -634,14 +600,15 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     this.function = this.inngest.createFunction(
       {
         id: `workflow.${this.id}`,
-        retries: Math.min(this.retryConfig?.attempts ?? 0, 20),
+        // @ts-ignore
+        retries: this.retryConfig?.attempts ?? 0,
         cancelOn: [{ event: `cancel.workflow.${this.id}` }],
         // Spread flow control configuration
         ...this.flowControlConfig
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, initialState, runId, resourceId, resume, outputOptions, format, timeTravel } = event.data;
+        let { inputData, initialState, runId, resourceId, resume, outputOptions, timeTravel } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
             return crypto.randomUUID();
@@ -680,20 +647,14 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
           initialState,
           emitter,
           retryConfig: this.retryConfig,
-          requestContext: new di.RequestContext(),
+          runtimeContext: new di.RuntimeContext(),
           // TODO
           resume,
           timeTravel,
-          format,
           abortController: new AbortController(),
-          // currentSpan: undefined, // TODO: Pass actual parent Span from workflow execution context
-          outputOptions,
-          writableStream: new web.WritableStream({
-            write(chunk) {
-              void emitter.emit("watch", chunk).catch(() => {
-              });
-            }
-          })
+          currentSpan: void 0,
+          // TODO: Pass actual parent AI span from workflow execution context
+          outputOptions
         });
         await step.run(`workflow.${this.id}.finalize`, async () => {
           if (result.status === "failed") {
@@ -731,29 +692,20 @@ function isAgent(params) {
 function isTool(params) {
   return params instanceof tools.Tool;
 }
-function createStep(params, agentOptions) {
+function createStep(params) {
   if (isAgent(params)) {
     return {
       id: params.name,
       description: params.getDescription(),
+      // @ts-ignore
       inputSchema: zod.z.object({
         prompt: zod.z.string()
-        // resourceId: z.string().optional(),
-        // threadId: z.string().optional(),
       }),
+      // @ts-ignore
       outputSchema: zod.z.object({
         text: zod.z.string()
       }),
-      execute: async ({
-        inputData,
-        [_constants.EMITTER_SYMBOL]: emitter,
-        [_constants.STREAM_FORMAT_SYMBOL]: streamFormat,
-        requestContext,
-        tracingContext,
-        abortSignal,
-        abort,
-        writer
-      }) => {
+      execute: async ({ inputData, [_constants.EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort, tracingContext }) => {
         let streamPromise = {};
         streamPromise.promise = new Promise((resolve, reject) => {
           streamPromise.resolve = resolve;
@@ -763,60 +715,61 @@ function createStep(params, agentOptions) {
           name: params.name,
           args: inputData
         };
-        let stream;
-        if ((await params.getModel()).specificationVersion === "v1") {
-          const { fullStream } = await params.streamLegacy(inputData.prompt, {
-            ...agentOptions ?? {},
-            // resourceId: inputData.resourceId,
-            // threadId: inputData.threadId,
-            requestContext,
+        if ((await params.getLLM()).getModel().specificationVersion === `v2`) {
+          const { fullStream } = await params.stream(inputData.prompt, {
+            runtimeContext,
             tracingContext,
             onFinish: (result) => {
               streamPromise.resolve(result.text);
-              void agentOptions?.onFinish?.(result);
             },
             abortSignal
           });
-          stream = fullStream;
+          if (abortSignal.aborted) {
+            return abort();
+          }
+          await emitter.emit("watch-v2", {
+            type: "tool-call-streaming-start",
+            ...toolData ?? {}
+          });
+          for await (const chunk of fullStream) {
+            if (chunk.type === "text-delta") {
+              await emitter.emit("watch-v2", {
+                type: "tool-call-delta",
+                ...toolData ?? {},
+                argsTextDelta: chunk.payload.text
+              });
+            }
+          }
         } else {
-          const modelOutput = await params.stream(inputData.prompt, {
-            ...agentOptions ?? {},
-            requestContext,
+          const { fullStream } = await params.streamLegacy(inputData.prompt, {
+            runtimeContext,
             tracingContext,
             onFinish: (result) => {
               streamPromise.resolve(result.text);
-              void agentOptions?.onFinish?.(result);
             },
             abortSignal
           });
-          stream = modelOutput.fullStream;
-        }
-        if (streamFormat === "legacy") {
-          await emitter.emit("watch", {
+          if (abortSignal.aborted) {
+            return abort();
+          }
+          await emitter.emit("watch-v2", {
             type: "tool-call-streaming-start",
             ...toolData ?? {}
           });
-          for await (const chunk of stream) {
+          for await (const chunk of fullStream) {
             if (chunk.type === "text-delta") {
-              await emitter.emit("watch", {
+              await emitter.emit("watch-v2", {
                 type: "tool-call-delta",
                 ...toolData ?? {},
                 argsTextDelta: chunk.textDelta
               });
             }
           }
-          await emitter.emit("watch", {
-            type: "tool-call-streaming-finish",
-            ...toolData ?? {}
-          });
-        } else {
-          for await (const chunk of stream) {
-            await writer.write(chunk);
-          }
-        }
-        if (abortSignal.aborted) {
-          return abort();
         }
+        await emitter.emit("watch-v2", {
+          type: "tool-call-streaming-finish",
+          ...toolData ?? {}
+        });
         return {
           text: await streamPromise.promise
         };
@@ -830,38 +783,20 @@ function createStep(params, agentOptions) {
     }
     return {
       // TODO: tool probably should have strong id type
+      // @ts-ignore
       id: params.id,
       description: params.description,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
-      suspendSchema: params.suspendSchema,
-      resumeSchema: params.resumeSchema,
-      execute: async ({
-        inputData,
-        mastra,
-        requestContext,
-        tracingContext,
-        suspend,
-        resumeData,
-        runId,
-        workflowId,
-        state,
-        setState
-      }) => {
-        const toolContext = {
-          mastra,
-          requestContext,
+      execute: async ({ inputData, mastra, runtimeContext, tracingContext, suspend, resumeData }) => {
+        return params.execute({
+          context: inputData,
+          mastra: aiTracing.wrapMastra(mastra, tracingContext),
+          runtimeContext,
           tracingContext,
-          workflow: {
-            runId,
-            resumeData,
-            suspend,
-            workflowId,
-            state,
-            setState
-          }
-        };
-        return params.execute(inputData, toolContext);
+          suspend,
+          resumeData
+        });
       },
       component: "TOOL"
     };
@@ -895,8 +830,6 @@ function init(inngest) {
         suspendSchema: step.suspendSchema,
         stateSchema: step.stateSchema,
         execute: step.execute,
-        retries: step.retries,
-        scorers: step.scorers,
         component: step.component
       };
     },
@@ -906,8 +839,7 @@ function init(inngest) {
         inputSchema: workflow.inputSchema,
         outputSchema: workflow.outputSchema,
         steps: workflow.stepDefs,
-        mastra: workflow.mastra,
-        options: workflow.options
+        mastra: workflow.mastra
       });
       wf.setStepFlow(workflow.stepGraph);
       wf.commit();
@@ -923,16 +855,63 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     this.inngestStep = inngestStep;
     this.inngestAttempts = inngestAttempts;
   }
-  async fmtReturnValue(emitter, stepResults, lastOutput, error) {
+  async execute(params) {
+    await params.emitter.emit("watch-v2", {
+      type: "workflow-start",
+      payload: { runId: params.runId }
+    });
+    const result = await super.execute(params);
+    await params.emitter.emit("watch-v2", {
+      type: "workflow-finish",
+      payload: { runId: params.runId }
+    });
+    return result;
+  }
+  async fmtReturnValue(executionSpan, emitter, stepResults, lastOutput, error) {
     const base = {
       status: lastOutput.status,
       steps: stepResults
     };
     if (lastOutput.status === "success") {
+      await emitter.emit("watch", {
+        type: "watch",
+        payload: {
+          workflowState: {
+            status: lastOutput.status,
+            steps: stepResults,
+            result: lastOutput.output
+          }
+        },
+        eventTimestamp: Date.now()
+      });
       base.result = lastOutput.output;
     } else if (lastOutput.status === "failed") {
       base.error = error instanceof Error ? error?.stack ?? error.message : lastOutput?.error instanceof Error ? lastOutput.error.message : lastOutput.error ?? error ?? "Unknown error";
+      await emitter.emit("watch", {
+        type: "watch",
+        payload: {
+          workflowState: {
+            status: lastOutput.status,
+            steps: stepResults,
+            result: null,
+            error: base.error
+          }
+        },
+        eventTimestamp: Date.now()
+      });
     } else if (lastOutput.status === "suspended") {
+      await emitter.emit("watch", {
+        type: "watch",
+        payload: {
+          workflowState: {
+            status: lastOutput.status,
+            steps: stepResults,
+            result: null,
+            error: null
+          }
+        },
+        eventTimestamp: Date.now()
+      });
       const suspendedStepIds = Object.entries(stepResults).flatMap(([stepId, stepResult]) => {
         if (stepResult?.status === "suspended") {
           const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
@@ -942,6 +921,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       });
       base.suspended = suspendedStepIds;
     }
+    executionSpan?.end();
     return base;
   }
   // async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
@@ -955,14 +935,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     stepResults,
     emitter,
     abortController,
-    requestContext,
+    runtimeContext,
     executionContext,
     writableStream,
     tracingContext
   }) {
     let { duration, fn } = entry;
     const sleepSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: observability.SpanType.WORKFLOW_SLEEP,
+      type: aiTracing.AISpanType.WORKFLOW_SLEEP,
       name: `sleep: ${duration ? `${duration}ms` : "dynamic"}`,
       attributes: {
         durationMs: duration,
@@ -973,53 +953,45 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     if (fn) {
       const stepCallId = crypto.randomUUID();
       duration = await this.inngestStep.run(`workflow.${workflowId}.sleep.${entry.id}`, async () => {
-        return await fn(
-          workflows.createDeprecationProxy(
+        return await fn({
+          runId,
+          workflowId,
+          mastra: this.mastra,
+          runtimeContext,
+          inputData: prevOutput,
+          state: executionContext.state,
+          setState: (state) => {
+            executionContext.state = state;
+          },
+          runCount: -1,
+          tracingContext: {
+            currentSpan: sleepSpan
+          },
+          getInitData: () => stepResults?.input,
+          getStepResult: workflows.getStepResult.bind(this, stepResults),
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload) => {
+          },
+          bail: () => {
+          },
+          abort: () => {
+            abortController?.abort();
+          },
+          [_constants.EMITTER_SYMBOL]: emitter,
+          // TODO: add streamVNext support
+          [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new tools.ToolStream(
             {
-              runId,
-              workflowId,
-              mastra: this.mastra,
-              requestContext,
-              inputData: prevOutput,
-              state: executionContext.state,
-              setState: (state) => {
-                executionContext.state = state;
-              },
-              retryCount: -1,
-              tracingContext: {
-                currentSpan: sleepSpan
-              },
-              getInitData: () => stepResults?.input,
-              getStepResult: workflows.getStepResult.bind(this, stepResults),
-              // TODO: this function shouldn't have suspend probably?
-              suspend: async (_suspendPayload) => {
-              },
-              bail: () => {
-              },
-              abort: () => {
-                abortController?.abort();
-              },
-              [_constants.EMITTER_SYMBOL]: emitter,
-              [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
-              engine: { step: this.inngestStep },
-              abortSignal: abortController?.signal,
-              writer: new tools.ToolStream(
-                {
-                  prefix: "workflow-step",
-                  callId: stepCallId,
-                  name: "sleep",
-                  runId
-                },
-                writableStream
-              )
+              prefix: "workflow-step",
+              callId: stepCallId,
+              name: "sleep",
+              runId
             },
-            {
-              paramName: "runCount",
-              deprecationMessage: workflows.runCountDeprecationMessage,
-              logger: this.logger
-            }
+            writableStream
           )
-        );
+        });
       });
       sleepSpan?.update({
         attributes: {
@@ -1043,14 +1015,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     stepResults,
     emitter,
     abortController,
-    requestContext,
+    runtimeContext,
     executionContext,
     writableStream,
     tracingContext
   }) {
     let { date, fn } = entry;
     const sleepUntilSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: observability.SpanType.WORKFLOW_SLEEP,
+      type: aiTracing.AISpanType.WORKFLOW_SLEEP,
       name: `sleepUntil: ${date ? date.toISOString() : "dynamic"}`,
       attributes: {
         untilDate: date,
@@ -1062,53 +1034,45 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     if (fn) {
       date = await this.inngestStep.run(`workflow.${workflowId}.sleepUntil.${entry.id}`, async () => {
         const stepCallId = crypto.randomUUID();
-        return await fn(
-          workflows.createDeprecationProxy(
+        return await fn({
+          runId,
+          workflowId,
+          mastra: this.mastra,
+          runtimeContext,
+          inputData: prevOutput,
+          state: executionContext.state,
+          setState: (state) => {
+            executionContext.state = state;
+          },
+          runCount: -1,
+          tracingContext: {
+            currentSpan: sleepUntilSpan
+          },
+          getInitData: () => stepResults?.input,
+          getStepResult: workflows.getStepResult.bind(this, stepResults),
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload) => {
+          },
+          bail: () => {
+          },
+          abort: () => {
+            abortController?.abort();
+          },
+          [_constants.EMITTER_SYMBOL]: emitter,
+          [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
+          // TODO: add streamVNext support
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new tools.ToolStream(
             {
-              runId,
-              workflowId,
-              mastra: this.mastra,
-              requestContext,
-              inputData: prevOutput,
-              state: executionContext.state,
-              setState: (state) => {
-                executionContext.state = state;
-              },
-              retryCount: -1,
-              tracingContext: {
-                currentSpan: sleepUntilSpan
-              },
-              getInitData: () => stepResults?.input,
-              getStepResult: workflows.getStepResult.bind(this, stepResults),
-              // TODO: this function shouldn't have suspend probably?
-              suspend: async (_suspendPayload) => {
-              },
-              bail: () => {
-              },
-              abort: () => {
-                abortController?.abort();
-              },
-              [_constants.EMITTER_SYMBOL]: emitter,
-              [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
-              engine: { step: this.inngestStep },
-              abortSignal: abortController?.signal,
-              writer: new tools.ToolStream(
-                {
-                  prefix: "workflow-step",
-                  callId: stepCallId,
-                  name: "sleep",
-                  runId
-                },
-                writableStream
-              )
+              prefix: "workflow-step",
+              callId: stepCallId,
+              name: "sleep",
+              runId
             },
-            {
-              paramName: "runCount",
-              deprecationMessage: workflows.runCountDeprecationMessage,
-              logger: this.logger
-            }
+            writableStream
           )
-        );
+        });
       });
       if (date && !(date instanceof Date)) {
         date = new Date(date);
@@ -1132,6 +1096,16 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       throw e;
     }
   }
+  async executeWaitForEvent({ event, timeout }) {
+    const eventData = await this.inngestStep.waitForEvent(`user-event-${event}`, {
+      event: `user-event-${event}`,
+      timeout: timeout ?? 5e3
+    });
+    if (eventData === null) {
+      throw "Timeout waiting for event";
+    }
+    return eventData?.data;
+  }
   async executeStep({
     step,
     stepResults,
@@ -1141,14 +1115,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     prevOutput,
     emitter,
     abortController,
-    requestContext,
+    runtimeContext,
     tracingContext,
     writableStream,
     disableScorers
   }) {
-    const stepSpan = tracingContext?.currentSpan?.createChildSpan({
+    const stepAISpan = tracingContext?.currentSpan?.createChildSpan({
       name: `workflow step: '${step.id}'`,
-      type: observability.SpanType.WORKFLOW_STEP,
+      type: aiTracing.AISpanType.WORKFLOW_STEP,
       input: prevOutput,
       attributes: {
         stepId: step.id
@@ -1158,13 +1132,34 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     const { inputData, validationError } = await workflows.validateStepInput({
       prevOutput,
       step,
-      validateInputs: this.options?.validateInputs ?? true
+      validateInputs: this.options?.validateInputs ?? false
     });
     const startedAt = await this.inngestStep.run(
       `workflow.${executionContext.workflowId}.run.${executionContext.runId}.step.${step.id}.running_ev`,
       async () => {
         const startedAt2 = Date.now();
         await emitter.emit("watch", {
+          type: "watch",
+          payload: {
+            currentStep: {
+              id: step.id,
+              status: "running"
+            },
+            workflowState: {
+              status: "running",
+              steps: {
+                ...stepResults,
+                [step.id]: {
+                  status: "running"
+                }
+              },
+              result: null,
+              error: null
+            }
+          },
+          eventTimestamp: Date.now()
+        });
+        await emitter.emit("watch-v2", {
           type: "workflow-step-start",
           payload: {
             id: step.id,
@@ -1183,7 +1178,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       const isTimeTravel = !!(timeTravel && timeTravel.steps?.length > 1 && timeTravel.steps[0] === step.id);
       try {
         if (isResume) {
-          runId = stepResults[resume?.steps?.[0] ?? ""]?.suspendPayload?.__workflow_meta?.runId ?? crypto.randomUUID();
+          runId = stepResults[resume?.steps?.[0]]?.suspendPayload?.__workflow_meta?.runId ?? crypto.randomUUID();
           const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
             workflowName: step.id,
             runId
@@ -1199,7 +1194,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                 steps: resume.steps.slice(1),
                 stepResults: snapshot?.context,
                 resumePayload: resume.resumePayload,
-                resumePath: resume.steps?.[1] ? snapshot?.suspendedPaths?.[resume.steps?.[1]] : void 0
+                // @ts-ignore
+                resumePath: snapshot?.suspendedPaths?.[resume.steps?.[1]]
               },
               outputOptions: { includeState: true }
             }
@@ -1266,6 +1262,23 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
         async () => {
           if (result.status === "failed") {
             await emitter.emit("watch", {
+              type: "watch",
+              payload: {
+                currentStep: {
+                  id: step.id,
+                  status: "failed",
+                  error: result?.error
+                },
+                workflowState: {
+                  status: "running",
+                  steps: stepResults,
+                  result: null,
+                  error: null
+                }
+              },
+              eventTimestamp: Date.now()
+            });
+            await emitter.emit("watch-v2", {
               type: "workflow-step-result",
               payload: {
                 id: step.id,
@@ -1276,14 +1289,35 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             });
             return { executionContext, result: { status: "failed", error: result?.error } };
           } else if (result.status === "suspended") {
-            const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult]) => {
-              const stepRes2 = stepResult;
+            const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult2]) => {
+              const stepRes2 = stepResult2;
               return stepRes2?.status === "suspended";
             });
-            for (const [stepName, stepResult] of suspendedSteps) {
-              const suspendPath = [stepName, ...stepResult?.suspendPayload?.__workflow_meta?.path ?? []];
+            for (const [stepName, stepResult2] of suspendedSteps) {
+              const suspendPath = [stepName, ...stepResult2?.suspendPayload?.__workflow_meta?.path ?? []];
               executionContext.suspendedPaths[step.id] = executionContext.executionPath;
               await emitter.emit("watch", {
+                type: "watch",
+                payload: {
+                  currentStep: {
+                    id: step.id,
+                    status: "suspended",
+                    payload: stepResult2.payload,
+                    suspendPayload: {
+                      ...stepResult2?.suspendPayload,
+                      __workflow_meta: { runId, path: suspendPath }
+                    }
+                  },
+                  workflowState: {
+                    status: "running",
+                    steps: stepResults,
+                    result: null,
+                    error: null
+                  }
+                },
+                eventTimestamp: Date.now()
+              });
+              await emitter.emit("watch-v2", {
                 type: "workflow-step-suspended",
                 payload: {
                   id: step.id,
@@ -1294,14 +1328,31 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                 executionContext,
                 result: {
                   status: "suspended",
-                  payload: stepResult.payload,
+                  payload: stepResult2.payload,
                   suspendPayload: {
-                    ...stepResult?.suspendPayload,
+                    ...stepResult2?.suspendPayload,
                     __workflow_meta: { runId, path: suspendPath }
                   }
                 }
               };
             }
+            await emitter.emit("watch", {
+              type: "watch",
+              payload: {
+                currentStep: {
+                  id: step.id,
+                  status: "suspended",
+                  payload: {}
+                },
+                workflowState: {
+                  status: "running",
+                  steps: stepResults,
+                  result: null,
+                  error: null
+                }
+              },
+              eventTimestamp: Date.now()
+            });
             return {
               executionContext,
               result: {
@@ -1311,6 +1362,23 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             };
           }
           await emitter.emit("watch", {
+            type: "watch",
+            payload: {
+              currentStep: {
+                id: step.id,
+                status: "success",
+                output: result?.result
+              },
+              workflowState: {
+                status: "running",
+                steps: stepResults,
+                result: null,
+                error: null
+              }
+            },
+            eventTimestamp: Date.now()
+          });
+          await emitter.emit("watch-v2", {
             type: "workflow-step-result",
             payload: {
               id: step.id,
@@ -1318,7 +1386,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               output: result?.result
             }
           });
-          await emitter.emit("watch", {
+          await emitter.emit("watch-v2", {
             type: "workflow-step-finish",
             payload: {
               id: step.id,
@@ -1329,7 +1397,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
         }
       );
       Object.assign(executionContext, res.executionContext);
-      return {
+      const stepResult = {
         ...res.result,
         startedAt,
         endedAt: Date.now(),
@@ -1337,8 +1405,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
         resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
         resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
       };
+      return { result: stepResult, executionContextState: executionContext.state };
     }
-    const stepCallId = crypto.randomUUID();
     let stepRes;
     try {
       stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
@@ -1364,22 +1432,11 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           if (validationError) {
             throw validationError;
           }
-          const retryCount = this.getOrGenerateRetryCount(step.id);
           const result = await step.execute({
             runId: executionContext.runId,
-            workflowId: executionContext.workflowId,
             mastra: this.mastra,
-            requestContext,
-            retryCount,
-            writer: new tools.ToolStream(
-              {
-                prefix: "workflow-step",
-                callId: stepCallId,
-                name: step.id,
-                runId: executionContext.runId
-              },
-              writableStream
-            ),
+            runtimeContext,
+            writableStream,
             state: executionContext?.state ?? {},
             setState: (state) => {
               executionContext.state = state;
@@ -1387,18 +1444,11 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             inputData,
             resumeData: resumeDataToUse,
             tracingContext: {
-              currentSpan: stepSpan
+              currentSpan: stepAISpan
             },
             getInitData: () => stepResults?.input,
             getStepResult: workflows.getStepResult.bind(this, stepResults),
             suspend: async (suspendPayload, suspendOptions) => {
-              const { suspendData, validationError: validationError2 } = await workflows.validateStepSuspendData({
-                suspendData: suspendPayload,
-                step
-              });
-              if (validationError2) {
-                throw validationError2;
-              }
               executionContext.suspendedPaths[step.id] = executionContext.executionPath;
               if (suspendOptions?.resumeLabel) {
                 const resumeLabel = Array.isArray(suspendOptions.resumeLabel) ? suspendOptions.resumeLabel : [suspendOptions.resumeLabel];
@@ -1409,16 +1459,18 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                   };
                 }
               }
-              suspended = { payload: suspendData };
+              suspended = { payload: suspendPayload };
             },
             bail: (result2) => {
               bailed = { payload: result2 };
             },
-            abort: () => {
-              abortController?.abort();
+            resume: {
+              steps: resume?.steps?.slice(1) || [],
+              resumePayload: resume?.resumePayload,
+              // @ts-ignore
+              runId: stepResults[step.id]?.suspendPayload?.__workflow_meta?.runId
             },
             [_constants.EMITTER_SYMBOL]: emitter,
-            [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
             engine: {
               step: this.inngestStep
             },
@@ -1438,7 +1490,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           const stepFailure = {
             status: "failed",
             payload: inputData,
-            error: e instanceof Error ? e.message : String(e),
+            error: e instanceof Error ? e.stack ?? e.message : String(e),
             endedAt: Date.now(),
             startedAt,
             resumedAt: resumeDataToUse ? startedAt : void 0,
@@ -1446,7 +1498,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           };
           execResults = stepFailure;
           const fallbackErrorMessage = `Step ${step.id} failed`;
-          stepSpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
+          stepAISpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
           throw new inngest.RetryAfterError(execResults.error ?? fallbackErrorMessage, executionContext.retryConfig.delay, {
             cause: execResults
           });
@@ -1455,7 +1507,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           execResults = {
             status: "suspended",
             suspendPayload: suspended.payload,
-            ...execResults.output ? { suspendOutput: execResults.output } : {},
             payload: inputData,
             suspendedAt: Date.now(),
             startedAt,
@@ -1471,8 +1522,24 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             startedAt
           };
         }
+        await emitter.emit("watch", {
+          type: "watch",
+          payload: {
+            currentStep: {
+              id: step.id,
+              ...execResults
+            },
+            workflowState: {
+              status: "running",
+              steps: { ...stepResults, [step.id]: execResults },
+              result: null,
+              error: null
+            }
+          },
+          eventTimestamp: Date.now()
+        });
         if (execResults.status === "suspended") {
-          await emitter.emit("watch", {
+          await emitter.emit("watch-v2", {
             type: "workflow-step-suspended",
             payload: {
               id: step.id,
@@ -1480,14 +1547,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             }
           });
         } else {
-          await emitter.emit("watch", {
+          await emitter.emit("watch-v2", {
             type: "workflow-step-result",
             payload: {
               id: step.id,
               ...execResults
             }
           });
-          await emitter.emit("watch", {
+          await emitter.emit("watch-v2", {
             type: "workflow-step-finish",
             payload: {
               id: step.id,
@@ -1495,25 +1562,25 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             }
           });
         }
-        stepSpan?.end({ output: execResults });
+        stepAISpan?.end({ output: execResults });
         return { result: execResults, executionContext, stepResults };
       });
     } catch (e) {
       const stepFailure = e instanceof Error ? e?.cause : {
         status: "failed",
-        error: e instanceof Error ? e.message : String(e),
+        error: e instanceof Error ? e.stack ?? e.message : String(e),
         payload: inputData,
         startedAt,
         endedAt: Date.now()
       };
-      await emitter.emit("watch", {
+      await emitter.emit("watch-v2", {
         type: "workflow-step-result",
         payload: {
           id: step.id,
           ...stepFailure
         }
       });
-      await emitter.emit("watch", {
+      await emitter.emit("watch-v2", {
         type: "workflow-step-finish",
         payload: {
           id: step.id,
@@ -1539,16 +1606,19 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             output: stepRes.result,
             workflowId: executionContext.workflowId,
             stepId: step.id,
-            requestContext,
+            runtimeContext,
             disableScorers,
-            tracingContext: { currentSpan: stepSpan }
+            tracingContext: { currentSpan: stepAISpan }
           });
         }
       });
     }
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
     executionContext.state = stepRes.executionContext.state;
-    return stepRes.result;
+    return {
+      result: stepRes.result,
+      executionContextState: stepRes.executionContext.state
+    };
   }
   async persistStepUpdate({
     workflowId,
@@ -1585,6 +1655,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             serializedStepGraph,
             result,
             error,
+            // @ts-ignore
             timestamp: Date.now()
           }
         });
@@ -1602,13 +1673,13 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     executionContext,
     emitter,
     abortController,
-    requestContext,
+    runtimeContext,
     writableStream,
     disableScorers,
     tracingContext
   }) {
     const conditionalSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: observability.SpanType.WORKFLOW_CONDITIONAL,
+      type: aiTracing.AISpanType.WORKFLOW_CONDITIONAL,
       name: `conditional: '${entry.conditions.length} conditions'`,
       input: prevOutput,
       attributes: {
@@ -1621,7 +1692,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       entry.conditions.map(
         (cond, index) => this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
           const evalSpan = conditionalSpan?.createChildSpan({
-            type: observability.SpanType.WORKFLOW_CONDITIONAL_EVAL,
+            type: aiTracing.AISpanType.WORKFLOW_CONDITIONAL_EVAL,
             name: `condition: '${index}'`,
             input: prevOutput,
             attributes: {
@@ -1630,55 +1701,47 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             tracingPolicy: this.options?.tracingPolicy
           });
           try {
-            const result = await cond(
-              workflows.createDeprecationProxy(
+            const result = await cond({
+              runId,
+              workflowId,
+              mastra: this.mastra,
+              runtimeContext,
+              runCount: -1,
+              inputData: prevOutput,
+              state: executionContext.state,
+              setState: (state) => {
+                executionContext.state = state;
+              },
+              tracingContext: {
+                currentSpan: evalSpan
+              },
+              getInitData: () => stepResults?.input,
+              getStepResult: workflows.getStepResult.bind(this, stepResults),
+              // TODO: this function shouldn't have suspend probably?
+              suspend: async (_suspendPayload) => {
+              },
+              bail: () => {
+              },
+              abort: () => {
+                abortController.abort();
+              },
+              [_constants.EMITTER_SYMBOL]: emitter,
+              [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
+              // TODO: add streamVNext support
+              engine: {
+                step: this.inngestStep
+              },
+              abortSignal: abortController.signal,
+              writer: new tools.ToolStream(
                 {
-                  runId,
-                  workflowId,
-                  mastra: this.mastra,
-                  requestContext,
-                  retryCount: -1,
-                  inputData: prevOutput,
-                  state: executionContext.state,
-                  setState: (state) => {
-                    executionContext.state = state;
-                  },
-                  tracingContext: {
-                    currentSpan: evalSpan
-                  },
-                  getInitData: () => stepResults?.input,
-                  getStepResult: workflows.getStepResult.bind(this, stepResults),
-                  // TODO: this function shouldn't have suspend probably?
-                  suspend: async (_suspendPayload) => {
-                  },
-                  bail: () => {
-                  },
-                  abort: () => {
-                    abortController.abort();
-                  },
-                  [_constants.EMITTER_SYMBOL]: emitter,
-                  [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
-                  engine: {
-                    step: this.inngestStep
-                  },
-                  abortSignal: abortController.signal,
-                  writer: new tools.ToolStream(
-                    {
-                      prefix: "workflow-step",
-                      callId: crypto.randomUUID(),
-                      name: "conditional",
-                      runId
-                    },
-                    writableStream
-                  )
+                  prefix: "workflow-step",
+                  callId: crypto.randomUUID(),
+                  name: "conditional",
+                  runId
                 },
-                {
-                  paramName: "runCount",
-                  deprecationMessage: workflows.runCountDeprecationMessage,
-                  logger: this.logger
-                }
+                writableStream
               )
-            );
+            });
             evalSpan?.end({
               output: result,
               attributes: {
@@ -1725,19 +1788,21 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             suspendedPaths: executionContext.suspendedPaths,
             resumeLabels: executionContext.resumeLabels,
             retryConfig: executionContext.retryConfig,
+            executionSpan: executionContext.executionSpan,
             state: executionContext.state
           },
           emitter,
           abortController,
-          requestContext,
+          runtimeContext,
           writableStream,
           disableScorers,
           tracingContext: {
             currentSpan: conditionalSpan
           }
         });
-        stepResults[step.step.id] = result;
-        return result;
+        stepResults[step.step.id] = result.result;
+        executionContext.state = result.executionContextState;
+        return result.result;
       })
     );
     const hasFailed = results.find((result) => result.status === "failed");
@@ -1745,19 +1810,13 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     if (hasFailed) {
       execResults = { status: "failed", error: hasFailed.error };
     } else if (hasSuspended) {
-      execResults = {
-        status: "suspended",
-        suspendPayload: hasSuspended.suspendPayload,
-        ...hasSuspended.suspendOutput ? { suspendOutput: hasSuspended.suspendOutput } : {}
-      };
+      execResults = { status: "suspended", suspendPayload: hasSuspended.suspendPayload };
     } else {
       execResults = {
         status: "success",
         output: results.reduce((acc, result, index) => {
           if (result.status === "success") {
-            if ("step" in stepsToRun[index]) {
-              acc[stepsToRun[index].step.id] = result.output;
-            }
+            acc[stepsToRun[index].step.id] = result.output;
           }
           return acc;
         }, {})