@mastra/inngest 0.10.5 → 0.10.6-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/inngest@0.10.5-alpha.1 build /home/runner/work/mastra/mastra/workflows/inngest
+> @mastra/inngest@0.10.6-alpha.0 build /home/runner/work/mastra/mastra/workflows/inngest
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 8101ms
+TSC ⚡️ Build success in 8972ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/workflows/inngest/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/workflows/inngest/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 6203ms
+DTS ⚡️ Build success in 6816ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 26.84 KB
-CJS ⚡️ Build success in 304ms
-ESM dist/index.js 26.65 KB
-ESM ⚡️ Build success in 305ms
+ESM dist/index.js 31.23 KB
+ESM ⚡️ Build success in 293ms
+CJS dist/index.cjs 31.43 KB
+CJS ⚡️ Build success in 293ms

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @mastra/inngest
 
+## 0.10.6-alpha.0
+
+### Patch Changes
+
+- 9d52b17: Fix inngest workflows streaming and add step metadata
+- Updated dependencies [d8f2d19]
+- Updated dependencies [9d52b17]
+- Updated dependencies [8ba1b51]
+  - @mastra/core@0.10.7-alpha.0
+
 ## 0.10.5
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -1,7 +1,8 @@
-import { Agent } from '@mastra/core';
+import type { Agent } from '@mastra/core';
 import type { BaseContext } from 'inngest';
 import { ClientOptions } from 'inngest';
 import { DefaultExecutionEngine } from '@mastra/core/workflows';
+import type { Emitter } from '@mastra/core/workflows';
 import type { ExecuteFunction } from '@mastra/core/workflows';
 import type { ExecutionContext } from '@mastra/core/workflows';
 import type { ExecutionEngine } from '@mastra/core/workflows';
@@ -19,7 +20,8 @@ import type { Span } from '@opentelemetry/api';
 import type { Step } from '@mastra/core/workflows';
 import type { StepFlowEntry } from '@mastra/core/workflows';
 import type { StepResult } from '@mastra/core/workflows';
-import { Tool } from '@mastra/core';
+import type { StreamEvent } from '@mastra/core/workflows';
+import { Tool } from '@mastra/core/tools';
 import type { ToolExecutionContext } from '@mastra/core';
 import type { WatchEvent } from '@mastra/core/workflows';
 import { Workflow } from '@mastra/core/workflows';
@@ -70,9 +72,26 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
     private inngestStep;
     private inngestAttempts;
     constructor(mastra: Mastra, inngestStep: BaseContext<Inngest>['step'], inngestAttempts?: number);
-    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: {
-        emit: (event: string, data: any) => Promise<void>;
-    }, stepResults: Record<string, StepResult<any, any, any, any>>, lastOutput: StepResult<any, any, any, any>, error?: Error | string): Promise<TOutput>;
+    execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: Emitter;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<TOutput>;
+    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: Emitter, stepResults: Record<string, StepResult<any, any, any, any>>, lastOutput: StepResult<any, any, any, any>, error?: Error | string): Promise<TOutput>;
     superExecuteStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
         workflowId: string;
         runId: string;
@@ -84,15 +103,17 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
             resumePayload: any;
         };
         prevOutput: any;
-        emitter: {
-            emit: (event: string, data: any) => Promise<void>;
-        };
+        emitter: Emitter;
         runtimeContext: RuntimeContext;
     }): Promise<StepResult<any, any, any, any>>;
     executeSleep({ id, duration }: {
         id: string;
         duration: number;
     }): Promise<void>;
+    executeWaitForEvent({ event, timeout }: {
+        event: string;
+        timeout?: number;
+    }): Promise<any>;
     executeStep({ step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
         step: Step<string, any, any>;
         stepResults: Record<string, StepResult<any, any, any, any>>;
@@ -112,9 +133,7 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
             runId?: string;
         };
         prevOutput: any;
-        emitter: {
-            emit: (event: string, data: any) => Promise<void>;
-        };
+        emitter: Emitter;
         runtimeContext: RuntimeContext;
     }): Promise<StepResult<any, any, any, any>>;
     persistStepUpdate({ workflowId, runId, stepResults, executionContext, serializedStepGraph, workflowStatus, result, error, }: {
@@ -146,9 +165,7 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
             resumePath: number[];
         };
         executionContext: ExecutionContext;
-        emitter: {
-            emit: (event: string, data: any) => Promise<void>;
-        };
+        emitter: Emitter;
         runtimeContext: RuntimeContext;
     }): Promise<StepResult<any, any, any, any>>;
 }
@@ -172,6 +189,7 @@ export declare class InngestRun<TEngineType = InngestEngineType, TSteps extends
     }, inngest: Inngest);
     getRuns(eventId: string): Promise<any>;
     getRunOutput(eventId: string): Promise<any>;
+    sendEvent(event: string, data: any): Promise<void>;
     start({ inputData, }: {
         inputData?: z.infer<TInput>;
         runtimeContext?: RuntimeContext;
@@ -181,7 +199,19 @@ export declare class InngestRun<TEngineType = InngestEngineType, TSteps extends
         step: Step<string, any, any, TResumeSchema, any> | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>] | string | string[];
         runtimeContext?: RuntimeContext;
     }): Promise<WorkflowResult<TOutput, TSteps>>;
-    watch(cb: (event: any) => void): () => void;
+    _resume<TResumeSchema extends z.ZodType<any>>(params: {
+        resumeData?: z.infer<TResumeSchema>;
+        step: Step<string, any, any, TResumeSchema, any> | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>] | string | string[];
+        runtimeContext?: RuntimeContext;
+    }): Promise<WorkflowResult<TOutput, TSteps>>;
+    watch(cb: (event: WatchEvent) => void, type?: 'watch' | 'watch-v2'): () => void;
+    stream({ inputData, runtimeContext }?: {
+        inputData?: z.infer<TInput>;
+        runtimeContext?: RuntimeContext;
+    }): {
+        stream: ReadableStream<StreamEvent>;
+        getWorkflowState: () => Promise<WorkflowResult<TOutput, TSteps>>;
+    };
 }
 
 export declare class InngestWorkflow<TEngineType = InngestEngineType, TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TPrevSchema extends z.ZodType<any> = TInput> extends Workflow<TEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {

package/dist/_tsup-dts-rollup.d.ts

@@ -1,7 +1,8 @@
-import { Agent } from '@mastra/core';
+import type { Agent } from '@mastra/core';
 import type { BaseContext } from 'inngest';
 import { ClientOptions } from 'inngest';
 import { DefaultExecutionEngine } from '@mastra/core/workflows';
+import type { Emitter } from '@mastra/core/workflows';
 import type { ExecuteFunction } from '@mastra/core/workflows';
 import type { ExecutionContext } from '@mastra/core/workflows';
 import type { ExecutionEngine } from '@mastra/core/workflows';
@@ -19,7 +20,8 @@ import type { Span } from '@opentelemetry/api';
 import type { Step } from '@mastra/core/workflows';
 import type { StepFlowEntry } from '@mastra/core/workflows';
 import type { StepResult } from '@mastra/core/workflows';
-import { Tool } from '@mastra/core';
+import type { StreamEvent } from '@mastra/core/workflows';
+import { Tool } from '@mastra/core/tools';
 import type { ToolExecutionContext } from '@mastra/core';
 import type { WatchEvent } from '@mastra/core/workflows';
 import { Workflow } from '@mastra/core/workflows';
@@ -70,9 +72,26 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
     private inngestStep;
     private inngestAttempts;
     constructor(mastra: Mastra, inngestStep: BaseContext<Inngest>['step'], inngestAttempts?: number);
-    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: {
-        emit: (event: string, data: any) => Promise<void>;
-    }, stepResults: Record<string, StepResult<any, any, any, any>>, lastOutput: StepResult<any, any, any, any>, error?: Error | string): Promise<TOutput>;
+    execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: Emitter;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<TOutput>;
+    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: Emitter, stepResults: Record<string, StepResult<any, any, any, any>>, lastOutput: StepResult<any, any, any, any>, error?: Error | string): Promise<TOutput>;
     superExecuteStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
         workflowId: string;
         runId: string;
@@ -84,15 +103,17 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
             resumePayload: any;
         };
         prevOutput: any;
-        emitter: {
-            emit: (event: string, data: any) => Promise<void>;
-        };
+        emitter: Emitter;
         runtimeContext: RuntimeContext;
     }): Promise<StepResult<any, any, any, any>>;
     executeSleep({ id, duration }: {
         id: string;
         duration: number;
     }): Promise<void>;
+    executeWaitForEvent({ event, timeout }: {
+        event: string;
+        timeout?: number;
+    }): Promise<any>;
     executeStep({ step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
         step: Step<string, any, any>;
         stepResults: Record<string, StepResult<any, any, any, any>>;
@@ -112,9 +133,7 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
             runId?: string;
         };
         prevOutput: any;
-        emitter: {
-            emit: (event: string, data: any) => Promise<void>;
-        };
+        emitter: Emitter;
         runtimeContext: RuntimeContext;
     }): Promise<StepResult<any, any, any, any>>;
     persistStepUpdate({ workflowId, runId, stepResults, executionContext, serializedStepGraph, workflowStatus, result, error, }: {
@@ -146,9 +165,7 @@ export declare class InngestExecutionEngine extends DefaultExecutionEngine {
             resumePath: number[];
         };
         executionContext: ExecutionContext;
-        emitter: {
-            emit: (event: string, data: any) => Promise<void>;
-        };
+        emitter: Emitter;
         runtimeContext: RuntimeContext;
     }): Promise<StepResult<any, any, any, any>>;
 }
@@ -172,6 +189,7 @@ export declare class InngestRun<TEngineType = InngestEngineType, TSteps extends
     }, inngest: Inngest);
     getRuns(eventId: string): Promise<any>;
     getRunOutput(eventId: string): Promise<any>;
+    sendEvent(event: string, data: any): Promise<void>;
     start({ inputData, }: {
         inputData?: z.infer<TInput>;
         runtimeContext?: RuntimeContext;
@@ -181,7 +199,19 @@ export declare class InngestRun<TEngineType = InngestEngineType, TSteps extends
         step: Step<string, any, any, TResumeSchema, any> | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>] | string | string[];
         runtimeContext?: RuntimeContext;
     }): Promise<WorkflowResult<TOutput, TSteps>>;
-    watch(cb: (event: any) => void): () => void;
+    _resume<TResumeSchema extends z.ZodType<any>>(params: {
+        resumeData?: z.infer<TResumeSchema>;
+        step: Step<string, any, any, TResumeSchema, any> | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>] | string | string[];
+        runtimeContext?: RuntimeContext;
+    }): Promise<WorkflowResult<TOutput, TSteps>>;
+    watch(cb: (event: WatchEvent) => void, type?: 'watch' | 'watch-v2'): () => void;
+    stream({ inputData, runtimeContext }?: {
+        inputData?: z.infer<TInput>;
+        runtimeContext?: RuntimeContext;
+    }): {
+        stream: ReadableStream<StreamEvent>;
+        getWorkflowState: () => Promise<WorkflowResult<TOutput, TSteps>>;
+    };
 }
 
 export declare class InngestWorkflow<TEngineType = InngestEngineType, TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TPrevSchema extends z.ZodType<any> = TInput> extends Workflow<TEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 var crypto = require('crypto');
 var realtime = require('@inngest/realtime');
-var core = require('@mastra/core');
 var di = require('@mastra/core/di');
+var tools = require('@mastra/core/tools');
 var workflows = require('@mastra/core/workflows');
 var _constants = require('@mastra/core/workflows/_constants');
 var hono = require('inngest/hono');
@@ -45,7 +45,7 @@ var InngestRun = class extends workflows.Run {
   }
   async getRunOutput(eventId) {
     let runs = await this.getRuns(eventId);
-    while (runs?.[0]?.status !== "Completed") {
+    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" || runs?.[0]?.status === "Cancelled") {
@@ -54,6 +54,12 @@ var InngestRun = class extends workflows.Run {
     }
     return runs?.[0];
   }
+  async sendEvent(event, data) {
+    await this.inngest.send({
+      name: `user-event-${event}`,
+      data
+    });
+  }
   async start({
     inputData
   }) {
@@ -91,6 +97,17 @@ var InngestRun = class extends workflows.Run {
     return result;
   }
   async resume(params) {
+    const p = this._resume(params).then((result) => {
+      if (result.status !== "suspended") {
+        this.closeStreamAction?.().catch(() => {
+        });
+      }
+      return result;
+    });
+    this.executionResults = p;
+    return p;
+  }
+  async _resume(params) {
     const steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
       (step) => typeof step === "string" ? step : step?.id
     );
@@ -124,25 +141,60 @@ var InngestRun = class extends workflows.Run {
     }
     return result;
   }
-  watch(cb) {
+  watch(cb, type = "watch") {
+    let active = true;
     const streamPromise = realtime.subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: ["watch"],
+        topics: [type],
         app: this.inngest
       },
       (message) => {
-        cb(message.data);
+        if (active) {
+          cb(message.data);
+        }
       }
     );
     return () => {
-      streamPromise.then((stream) => {
-        stream.cancel();
+      active = false;
+      streamPromise.then(async (stream) => {
+        return stream.cancel();
       }).catch((err) => {
         console.error(err);
       });
     };
   }
+  stream({ inputData, runtimeContext } = {}) {
+    const { readable, writable } = new TransformStream();
+    const writer = writable.getWriter();
+    const unwatch = this.watch(async (event) => {
+      try {
+        await writer.write(event);
+      } catch {
+      }
+    }, "watch-v2");
+    this.closeStreamAction = async () => {
+      unwatch();
+      try {
+        await writer.close();
+      } catch (err) {
+        console.error("Error closing stream:", err);
+      } finally {
+        writer.releaseLock();
+      }
+    };
+    this.executionResults = this.start({ inputData, runtimeContext }).then((result) => {
+      if (result.status !== "suspended") {
+        this.closeStreamAction?.().catch(() => {
+        });
+      }
+      return result;
+    });
+    return {
+      stream: readable,
+      getWorkflowState: () => this.executionResults
+    };
+  }
 };
 var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
   #mastra;
@@ -250,12 +302,18 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
             try {
               await publish({
                 channel: `workflow:${this.id}:${runId}`,
-                topic: "watch",
+                topic: event2,
                 data
               });
             } catch (err) {
               this.logger.error("Error emitting event: " + (err?.stack ?? err?.message ?? err));
             }
+          },
+          on: (_event, _callback) => {
+          },
+          off: (_event, _callback) => {
+          },
+          once: (_event, _callback) => {
           }
         };
         const engine = new InngestExecutionEngine(this.#mastra, step, attempt);
@@ -293,8 +351,14 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
   }
 };
+function isAgent(params) {
+  return params?.component === "AGENT";
+}
+function isTool(params) {
+  return params instanceof tools.Tool;
+}
 function createStep(params) {
-  if (params instanceof core.Agent) {
+  if (isAgent(params)) {
     return {
       id: params.name,
       // @ts-ignore
@@ -359,7 +423,7 @@ function createStep(params) {
       }
     };
   }
-  if (params instanceof core.Tool) {
+  if (isTool(params)) {
     if (!params.inputSchema || !params.outputSchema) {
       throw new Error("Tool must have input and output schemas defined");
     }
@@ -425,6 +489,18 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     this.inngestStep = inngestStep;
     this.inngestAttempts = inngestAttempts;
   }
+  async execute(params) {
+    await params.emitter.emit("watch-v2", {
+      type: "start",
+      payload: { runId: params.runId }
+    });
+    const result = await super.execute(params);
+    await params.emitter.emit("watch-v2", {
+      type: "finish",
+      payload: { runId: params.runId }
+    });
+    return result;
+  }
   async fmtReturnValue(executionSpan, emitter, stepResults, lastOutput, error) {
     const base = {
       status: lastOutput.status,
@@ -508,6 +584,16 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
   async executeSleep({ id, duration }) {
     await this.inngestStep.sleep(id, duration);
   }
+  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,
@@ -517,9 +603,10 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     emitter,
     runtimeContext
   }) {
-    await this.inngestStep.run(
+    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: {
@@ -541,6 +628,13 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           },
           eventTimestamp: Date.now()
         });
+        await emitter.emit("watch-v2", {
+          type: "step-start",
+          payload: {
+            id: step.id
+          }
+        });
+        return startedAt2;
       }
     );
     if (step instanceof InngestWorkflow) {
@@ -601,6 +695,13 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               },
               eventTimestamp: Date.now()
             });
+            await emitter.emit("watch-v2", {
+              type: "step-result",
+              payload: {
+                id: step.id,
+                status: "failed"
+              }
+            });
             return { executionContext, result: { status: "failed", error: result?.error } };
           } else if (result.status === "suspended") {
             const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult]) => {
@@ -627,6 +728,12 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                 },
                 eventTimestamp: Date.now()
               });
+              await emitter.emit("watch-v2", {
+                type: "step-suspended",
+                payload: {
+                  id: step.id
+                }
+              });
               return {
                 executionContext,
                 result: {
@@ -677,6 +784,13 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             },
             eventTimestamp: Date.now()
           });
+          await emitter.emit("watch-v2", {
+            type: "step-finish",
+            payload: {
+              id: step.id,
+              metadata: {}
+            }
+          });
           return { executionContext, result: { status: "success", output: result?.result } };
         }
       );
@@ -716,12 +830,37 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             step: this.inngestStep
           }
         });
-        execResults = { status: "success", output: result };
+        const endedAt = Date.now();
+        execResults = {
+          status: "success",
+          output: result,
+          startedAt,
+          endedAt,
+          payload: prevOutput,
+          resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
+          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+        };
       } catch (e) {
-        execResults = { status: "failed", error: e instanceof Error ? e.message : String(e) };
+        execResults = {
+          status: "failed",
+          payload: prevOutput,
+          error: e instanceof Error ? e.message : String(e),
+          endedAt: Date.now(),
+          startedAt,
+          resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
+          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+        };
       }
       if (suspended) {
-        execResults = { status: "suspended", payload: suspended.payload };
+        execResults = {
+          status: "suspended",
+          suspendedPayload: suspended.payload,
+          payload: prevOutput,
+          suspendedAt: Date.now(),
+          startedAt,
+          resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
+          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+        };
       }
       if (execResults.status === "failed") {
         if (executionContext.retryConfig.attempts > 0 && this.inngestAttempts < executionContext.retryConfig.attempts) {
@@ -733,18 +872,43 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
         payload: {
           currentStep: {
             id: step.id,
-            status: execResults.status,
-            output: execResults.output
+            ...execResults
           },
           workflowState: {
             status: "running",
-            steps: stepResults,
+            steps: { ...stepResults, [step.id]: execResults },
             result: null,
             error: null
           }
         },
         eventTimestamp: Date.now()
       });
+      if (execResults.status === "suspended") {
+        await emitter.emit("watch-v2", {
+          type: "step-suspended",
+          payload: {
+            id: step.id,
+            status: execResults.status,
+            output: execResults.status === "success" ? execResults?.output : void 0
+          }
+        });
+      } else {
+        await emitter.emit("watch-v2", {
+          type: "step-result",
+          payload: {
+            id: step.id,
+            status: execResults.status,
+            output: execResults.status === "success" ? execResults?.output : void 0
+          }
+        });
+        await emitter.emit("watch-v2", {
+          type: "step-finish",
+          payload: {
+            id: step.id,
+            metadata: {}
+          }
+        });
+      }
       return { result: execResults, executionContext, stepResults };
     });
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
@@ -862,7 +1026,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     if (hasFailed) {
       execResults = { status: "failed", error: hasFailed.result.error };
     } else if (hasSuspended) {
-      execResults = { status: "suspended", payload: hasSuspended.result.payload };
+      execResults = { status: "suspended", payload: hasSuspended.result.suspendPayload };
     } else {
       execResults = {
         status: "success",