@mastra/inngest 0.0.0-redis-cloud-transporter-20250508203756 → 0.0.0-scorers-api-v2-20250801171841

package/dist/index.cjs

@@ -3,34 +3,43 @@
 var crypto = require('crypto');
 var realtime = require('@inngest/realtime');
 var di = require('@mastra/core/di');
-var vNext = require('@mastra/core/workflows/vNext');
+var tools = require('@mastra/core/tools');
+var workflows = require('@mastra/core/workflows');
+var _constants = require('@mastra/core/workflows/_constants');
 var hono = require('inngest/hono');
+var zod = require('zod');
 
 // src/index.ts
 function serve({ mastra, inngest }) {
-  const wfs = mastra.vnext_getWorkflows();
-  const functions = Object.values(wfs).flatMap((wf) => {
-    if (wf instanceof InngestWorkflow) {
-      wf.__registerMastra(mastra);
-      return wf.getFunctions();
-    }
-    return [];
-  });
+  const wfs = mastra.getWorkflows();
+  const functions = Array.from(
+    new Set(
+      Object.values(wfs).flatMap((wf) => {
+        if (wf instanceof InngestWorkflow) {
+          wf.__registerMastra(mastra);
+          return wf.getFunctions();
+        }
+        return [];
+      })
+    )
+  );
   return hono.serve({
     client: inngest,
     functions
   });
 }
-var InngestRun = class extends vNext.Run {
+var InngestRun = class extends workflows.Run {
   inngest;
+  serializedStepGraph;
   #mastra;
   constructor(params, inngest) {
     super(params);
     this.inngest = inngest;
+    this.serializedStepGraph = params.serializedStepGraph;
     this.#mastra = params.mastra;
   }
   async getRuns(eventId) {
-    const response = await fetch(`${this.inngest.apiBaseUrl}/v1/events/${eventId}/runs`, {
+    const response = await fetch(`${this.inngest.apiBaseUrl ?? "https://api.inngest.com"}/v1/events/${eventId}/runs`, {
       headers: {
         Authorization: `Bearer ${process.env.INNGEST_SIGNING_KEY}`
       }
@@ -40,15 +49,50 @@ var InngestRun = class extends vNext.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") {
+      if (runs?.[0]?.status === "Failed") {
+        console.log("run", runs?.[0]);
         throw new Error(`Function run ${runs?.[0]?.status}`);
+      } else if (runs?.[0]?.status === "Cancelled") {
+        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId
+        });
+        return { output: { result: { steps: snapshot?.context, status: "canceled" } } };
       }
     }
     return runs?.[0];
   }
+  async sendEvent(event, data) {
+    await this.inngest.send({
+      name: `user-event-${event}`,
+      data
+    });
+  }
+  async cancel() {
+    await this.inngest.send({
+      name: `cancel.workflow.${this.workflowId}`,
+      data: {
+        runId: this.runId
+      }
+    });
+    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (snapshot) {
+      await this.#mastra?.storage?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        snapshot: {
+          ...snapshot,
+          status: "canceled"
+        }
+      });
+    }
+  }
   async start({
     inputData
   }) {
@@ -57,11 +101,13 @@ var InngestRun = class extends vNext.Run {
       runId: this.runId,
       snapshot: {
         runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
         value: {},
         context: {},
         activePaths: [],
         suspendedPaths: {},
-        timestamp: Date.now()
+        timestamp: Date.now(),
+        status: "running"
       }
     });
     const eventOutput = await this.inngest.send({
@@ -80,10 +126,23 @@ var InngestRun = class extends vNext.Run {
     if (result.status === "failed") {
       result.error = new Error(result.error);
     }
-    this.cleanup?.();
+    if (result.status !== "suspended") {
+      this.cleanup?.();
+    }
     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
     );
@@ -96,6 +155,7 @@ var InngestRun = class extends vNext.Run {
       data: {
         inputData: params.resumeData,
         runId: this.runId,
+        workflowId: this.workflowId,
         stepResults: snapshot?.context,
         resume: {
           steps,
@@ -117,27 +177,62 @@ var InngestRun = class extends vNext.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 vNext.NewWorkflow {
+var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
   #mastra;
   inngest;
   function;
@@ -158,11 +253,32 @@ var InngestWorkflow = class _InngestWorkflow extends vNext.NewWorkflow {
     const storage = this.#mastra?.getStorage();
     if (!storage) {
       this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
-      return null;
+      return this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null;
     }
     const run = await storage.getWorkflowRunById({ runId, workflowName: this.id });
     return run ?? (this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null);
   }
+  async getWorkflowRunExecutionResult(runId) {
+    const storage = this.#mastra?.getStorage();
+    if (!storage) {
+      this.logger.debug("Cannot get workflow run execution result. Mastra storage is not initialized");
+      return null;
+    }
+    const run = await storage.getWorkflowRunById({ runId, workflowName: this.id });
+    if (!run?.snapshot) {
+      return null;
+    }
+    if (typeof run.snapshot === "string") {
+      return null;
+    }
+    return {
+      status: run.snapshot.status,
+      result: run.snapshot.result,
+      error: run.snapshot.error,
+      payload: run.snapshot.context?.input,
+      steps: run.snapshot.context
+    };
+  }
   __registerMastra(mastra) {
     this.#mastra = mastra;
     this.executionEngine.__registerMastra(mastra);
@@ -189,6 +305,7 @@ var InngestWorkflow = class _InngestWorkflow extends vNext.NewWorkflow {
         runId: runIdToUse,
         executionEngine: this.executionEngine,
         executionGraph: this.executionGraph,
+        serializedStepGraph: this.serializedStepGraph,
         mastra: this.#mastra,
         retryConfig: this.retryConfig,
         cleanup: () => this.runs.delete(runIdToUse)
@@ -198,13 +315,55 @@ var InngestWorkflow = class _InngestWorkflow extends vNext.NewWorkflow {
     this.runs.set(runIdToUse, run);
     return run;
   }
+  async createRunAsync(options) {
+    const runIdToUse = options?.runId || crypto.randomUUID();
+    const run = this.runs.get(runIdToUse) ?? new InngestRun(
+      {
+        workflowId: this.id,
+        runId: runIdToUse,
+        executionEngine: this.executionEngine,
+        executionGraph: this.executionGraph,
+        serializedStepGraph: this.serializedStepGraph,
+        mastra: this.#mastra,
+        retryConfig: this.retryConfig,
+        cleanup: () => this.runs.delete(runIdToUse)
+      },
+      this.inngest
+    );
+    this.runs.set(runIdToUse, run);
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse);
+    if (!workflowSnapshotInStorage) {
+      await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+        workflowName: this.id,
+        runId: runIdToUse,
+        snapshot: {
+          runId: runIdToUse,
+          status: "pending",
+          value: {},
+          context: {},
+          activePaths: [],
+          serializedStepGraph: this.serializedStepGraph,
+          suspendedPaths: {},
+          result: void 0,
+          error: void 0,
+          // @ts-ignore
+          timestamp: Date.now()
+        }
+      });
+    }
+    return run;
+  }
   getFunction() {
     if (this.function) {
       return this.function;
     }
     this.function = this.inngest.createFunction(
-      // @ts-ignore
-      { id: `workflow.${this.id}`, retries: this.retryConfig?.attempts ?? 0 },
+      {
+        id: `workflow.${this.id}`,
+        // @ts-ignore
+        retries: this.retryConfig?.attempts ?? 0,
+        cancelOn: [{ event: `cancel.workflow.${this.id}` }]
+      },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
         let { inputData, runId, resume } = event.data;
@@ -221,12 +380,18 @@ var InngestWorkflow = class _InngestWorkflow extends vNext.NewWorkflow {
             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);
@@ -234,12 +399,14 @@ var InngestWorkflow = class _InngestWorkflow extends vNext.NewWorkflow {
           workflowId: this.id,
           runId,
           graph: this.executionGraph,
+          serializedStepGraph: this.serializedStepGraph,
           input: inputData,
           emitter,
           retryConfig: this.retryConfig,
           runtimeContext: new di.RuntimeContext(),
           // TODO
-          resume
+          resume,
+          abortController: new AbortController()
         });
         return { result, runId };
       }
@@ -263,32 +430,141 @@ var InngestWorkflow = class _InngestWorkflow extends vNext.NewWorkflow {
     return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
   }
 };
-function cloneWorkflow(workflow, opts) {
-  const wf = new InngestWorkflow(
-    {
-      id: opts.id,
-      inputSchema: workflow.inputSchema,
-      outputSchema: workflow.outputSchema,
-      steps: workflow.stepDefs,
-      mastra: workflow.mastra
-    },
-    workflow.inngest
-  );
-  wf.setStepFlow(workflow.stepGraph);
-  wf.commit();
-  return wf;
+function isAgent(params) {
+  return params?.component === "AGENT";
+}
+function isTool(params) {
+  return params instanceof tools.Tool;
+}
+function createStep(params) {
+  if (isAgent(params)) {
+    return {
+      id: params.name,
+      // @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, runtimeContext, abortSignal, abort }) => {
+        let streamPromise = {};
+        streamPromise.promise = new Promise((resolve, reject) => {
+          streamPromise.resolve = resolve;
+          streamPromise.reject = reject;
+        });
+        const toolData = {
+          name: params.name,
+          args: inputData
+        };
+        await emitter.emit("watch-v2", {
+          type: "tool-call-streaming-start",
+          ...toolData
+        });
+        const { fullStream } = await params.stream(inputData.prompt, {
+          // resourceId: inputData.resourceId,
+          // threadId: inputData.threadId,
+          runtimeContext,
+          onFinish: (result) => {
+            streamPromise.resolve(result.text);
+          },
+          abortSignal
+        });
+        if (abortSignal.aborted) {
+          return abort();
+        }
+        for await (const chunk of fullStream) {
+          switch (chunk.type) {
+            case "text-delta":
+              await emitter.emit("watch-v2", {
+                type: "tool-call-delta",
+                ...toolData,
+                argsTextDelta: chunk.textDelta
+              });
+              break;
+            case "step-start":
+            case "step-finish":
+            case "finish":
+              break;
+            case "tool-call":
+            case "tool-result":
+            case "tool-call-streaming-start":
+            case "tool-call-delta":
+            case "source":
+            case "file":
+            default:
+              await emitter.emit("watch-v2", chunk);
+              break;
+          }
+        }
+        return {
+          text: await streamPromise.promise
+        };
+      }
+    };
+  }
+  if (isTool(params)) {
+    if (!params.inputSchema || !params.outputSchema) {
+      throw new Error("Tool must have input and output schemas defined");
+    }
+    return {
+      // TODO: tool probably should have strong id type
+      // @ts-ignore
+      id: params.id,
+      inputSchema: params.inputSchema,
+      outputSchema: params.outputSchema,
+      execute: async ({ inputData, mastra, runtimeContext }) => {
+        return params.execute({
+          context: inputData,
+          mastra,
+          runtimeContext
+        });
+      }
+    };
+  }
+  return {
+    id: params.id,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    execute: params.execute
+  };
 }
 function init(inngest) {
   return {
     createWorkflow(params) {
       return new InngestWorkflow(params, inngest);
     },
-    createStep: vNext.createStep,
-    cloneStep: vNext.cloneStep,
-    cloneWorkflow
+    createStep,
+    cloneStep(step, opts) {
+      return {
+        id: opts.id,
+        description: step.description,
+        inputSchema: step.inputSchema,
+        outputSchema: step.outputSchema,
+        execute: step.execute
+      };
+    },
+    cloneWorkflow(workflow, opts) {
+      const wf = new workflows.Workflow({
+        id: opts.id,
+        inputSchema: workflow.inputSchema,
+        outputSchema: workflow.outputSchema,
+        steps: workflow.stepDefs,
+        mastra: workflow.mastra
+      });
+      wf.setStepFlow(workflow.stepGraph);
+      wf.commit();
+      return wf;
+    }
   };
 }
-var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
+var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
   inngestStep;
   inngestAttempts;
   constructor(mastra, inngestStep, inngestAttempts = 0) {
@@ -296,6 +572,18 @@ var InngestExecutionEngine = class extends vNext.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,
@@ -362,7 +650,9 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
     resume,
     prevOutput,
     emitter,
-    runtimeContext
+    abortController,
+    runtimeContext,
+    writableStream
   }) {
     return super.executeStep({
       workflowId,
@@ -373,9 +663,143 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
       resume,
       prevOutput,
       emitter,
-      runtimeContext
+      abortController,
+      runtimeContext,
+      writableStream
     });
   }
+  // async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
+  //   await this.inngestStep.sleep(id, duration);
+  // }
+  async executeSleep({
+    workflowId,
+    runId,
+    entry,
+    prevOutput,
+    stepResults,
+    emitter,
+    abortController,
+    runtimeContext,
+    writableStream
+  }) {
+    let { duration, fn } = entry;
+    if (fn) {
+      const stepCallId = crypto.randomUUID();
+      duration = await this.inngestStep.run(`workflow.${workflowId}.sleep.${entry.id}`, async () => {
+        return await fn({
+          runId,
+          workflowId,
+          mastra: this.mastra,
+          runtimeContext,
+          inputData: prevOutput,
+          runCount: -1,
+          getInitData: () => stepResults?.input,
+          getStepResult: (step) => {
+            if (!step?.id) {
+              return null;
+            }
+            const result = stepResults[step.id];
+            if (result?.status === "success") {
+              return result.output;
+            }
+            return null;
+          },
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload) => {
+          },
+          bail: () => {
+          },
+          abort: () => {
+            abortController?.abort();
+          },
+          [_constants.EMITTER_SYMBOL]: emitter,
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new tools.ToolStream(
+            {
+              prefix: "step",
+              callId: stepCallId,
+              name: "sleep",
+              runId
+            },
+            writableStream
+          )
+        });
+      });
+    }
+    await this.inngestStep.sleep(entry.id, !duration || duration < 0 ? 0 : duration);
+  }
+  async executeSleepUntil({
+    workflowId,
+    runId,
+    entry,
+    prevOutput,
+    stepResults,
+    emitter,
+    abortController,
+    runtimeContext,
+    writableStream
+  }) {
+    let { date, fn } = entry;
+    if (fn) {
+      date = await this.inngestStep.run(`workflow.${workflowId}.sleepUntil.${entry.id}`, async () => {
+        const stepCallId = crypto.randomUUID();
+        return await fn({
+          runId,
+          workflowId,
+          mastra: this.mastra,
+          runtimeContext,
+          inputData: prevOutput,
+          runCount: -1,
+          getInitData: () => stepResults?.input,
+          getStepResult: (step) => {
+            if (!step?.id) {
+              return null;
+            }
+            const result = stepResults[step.id];
+            if (result?.status === "success") {
+              return result.output;
+            }
+            return null;
+          },
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload) => {
+          },
+          bail: () => {
+          },
+          abort: () => {
+            abortController?.abort();
+          },
+          [_constants.EMITTER_SYMBOL]: emitter,
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new tools.ToolStream(
+            {
+              prefix: "step",
+              callId: stepCallId,
+              name: "sleep",
+              runId
+            },
+            writableStream
+          )
+        });
+      });
+    }
+    if (!(date instanceof Date)) {
+      return;
+    }
+    await this.inngestStep.sleepUntil(entry.id, date);
+  }
+  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,
@@ -383,11 +807,14 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
     resume,
     prevOutput,
     emitter,
-    runtimeContext
+    abortController,
+    runtimeContext,
+    writableStream
   }) {
-    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: {
@@ -409,6 +836,16 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
           },
           eventTimestamp: Date.now()
         });
+        await emitter.emit("watch-v2", {
+          type: "step-start",
+          payload: {
+            id: step.id,
+            status: "running",
+            payload: prevOutput,
+            startedAt: startedAt2
+          }
+        });
+        return startedAt2;
       }
     );
     if (step instanceof InngestWorkflow) {
@@ -469,6 +906,15 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
               },
               eventTimestamp: Date.now()
             });
+            await emitter.emit("watch-v2", {
+              type: "step-result",
+              payload: {
+                id: step.id,
+                status: "failed",
+                error: result?.error,
+                payload: prevOutput
+              }
+            });
             return { executionContext, result: { status: "failed", error: result?.error } };
           } else if (result.status === "suspended") {
             const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult]) => {
@@ -495,6 +941,13 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
                 },
                 eventTimestamp: Date.now()
               });
+              await emitter.emit("watch-v2", {
+                type: "step-suspended",
+                payload: {
+                  id: step.id,
+                  status: "suspended"
+                }
+              });
               return {
                 executionContext,
                 result: {
@@ -545,6 +998,21 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
             },
             eventTimestamp: Date.now()
           });
+          await emitter.emit("watch-v2", {
+            type: "step-result",
+            payload: {
+              id: step.id,
+              status: "success",
+              output: result?.result
+            }
+          });
+          await emitter.emit("watch-v2", {
+            type: "step-finish",
+            payload: {
+              id: step.id,
+              metadata: {}
+            }
+          });
           return { executionContext, result: { status: "success", output: result?.result } };
         }
       );
@@ -554,10 +1022,13 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
     const stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
       let execResults;
       let suspended;
+      let bailed;
       try {
         const result = await step.execute({
+          runId: executionContext.runId,
           mastra: this.mastra,
           runtimeContext,
+          writableStream,
           inputData: prevOutput,
           resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
           getInitData: () => stepResults?.input,
@@ -572,20 +1043,54 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
             executionContext.suspendedPaths[step.id] = executionContext.executionPath;
             suspended = { payload: suspendPayload };
           },
+          bail: (result2) => {
+            bailed = { payload: result2 };
+          },
           resume: {
             steps: resume?.steps?.slice(1) || [],
             resumePayload: resume?.resumePayload,
             // @ts-ignore
             runId: stepResults[step.id]?.payload?.__workflow_meta?.runId
           },
-          emitter
+          [_constants.EMITTER_SYMBOL]: emitter,
+          engine: {
+            step: this.inngestStep
+          },
+          abortSignal: abortController.signal
         });
-        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
+        };
+      } else if (bailed) {
+        execResults = { status: "bailed", output: bailed.payload, payload: prevOutput, endedAt: Date.now(), startedAt };
       }
       if (execResults.status === "failed") {
         if (executionContext.retryConfig.attempts > 0 && this.inngestAttempts < executionContext.retryConfig.attempts) {
@@ -597,18 +1102,41 @@ var InngestExecutionEngine = class extends vNext.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,
+            ...execResults
+          }
+        });
+      } else {
+        await emitter.emit("watch-v2", {
+          type: "step-result",
+          payload: {
+            id: step.id,
+            ...execResults
+          }
+        });
+        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);
@@ -619,7 +1147,11 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
     workflowId,
     runId,
     stepResults,
-    executionContext
+    executionContext,
+    serializedStepGraph,
+    workflowStatus,
+    result,
+    error
   }) {
     await this.inngestStep.run(
       `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
@@ -633,6 +1165,10 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
             context: stepResults,
             activePaths: [],
             suspendedPaths: executionContext.suspendedPaths,
+            serializedStepGraph,
+            status: workflowStatus,
+            result,
+            error,
             // @ts-ignore
             timestamp: Date.now()
           }
@@ -647,10 +1183,13 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
     prevOutput,
     prevStep,
     stepResults,
+    serializedStepGraph,
     resume,
     executionContext,
     emitter,
-    runtimeContext
+    abortController,
+    runtimeContext,
+    writableStream
   }) {
     let execResults;
     const truthyIndexes = (await Promise.all(
@@ -658,8 +1197,11 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
         (cond, index) => this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
           try {
             const result = await cond({
+              runId,
+              workflowId,
               mastra: this.mastra,
               runtimeContext,
+              runCount: -1,
               inputData: prevOutput,
               getInitData: () => stepResults?.input,
               getStepResult: (step) => {
@@ -675,7 +1217,25 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
               // TODO: this function shouldn't have suspend probably?
               suspend: async (_suspendPayload) => {
               },
-              emitter
+              bail: () => {
+              },
+              abort: () => {
+                abortController.abort();
+              },
+              [_constants.EMITTER_SYMBOL]: emitter,
+              engine: {
+                step: this.inngestStep
+              },
+              abortSignal: abortController.signal,
+              writer: new tools.ToolStream(
+                {
+                  prefix: "step",
+                  callId: crypto.randomUUID(),
+                  name: "conditional",
+                  runId
+                },
+                writableStream
+              )
             });
             return result ? index : null;
           } catch (e) {
@@ -694,6 +1254,7 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
           prevStep,
           stepResults,
           resume,
+          serializedStepGraph,
           executionContext: {
             workflowId,
             runId,
@@ -703,21 +1264,23 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
             executionSpan: executionContext.executionSpan
           },
           emitter,
-          runtimeContext
+          abortController,
+          runtimeContext,
+          writableStream
         })
       )
     );
-    const hasFailed = results.find((result) => result.status === "failed");
-    const hasSuspended = results.find((result) => result.status === "suspended");
+    const hasFailed = results.find((result) => result.result.status === "failed");
+    const hasSuspended = results.find((result) => result.result.status === "suspended");
     if (hasFailed) {
-      execResults = { status: "failed", error: hasFailed.error };
+      execResults = { status: "failed", error: hasFailed.result.error };
     } else if (hasSuspended) {
-      execResults = { status: "suspended", payload: hasSuspended.payload };
+      execResults = { status: "suspended", payload: hasSuspended.result.suspendPayload };
     } else {
       execResults = {
         status: "success",
         output: results.reduce((acc, result, index) => {
-          if (result.status === "success") {
+          if (result.result.status === "success") {
             acc[stepsToRun[index].step.id] = result.output;
           }
           return acc;
@@ -731,5 +1294,8 @@ var InngestExecutionEngine = class extends vNext.DefaultExecutionEngine {
 exports.InngestExecutionEngine = InngestExecutionEngine;
 exports.InngestRun = InngestRun;
 exports.InngestWorkflow = InngestWorkflow;
+exports.createStep = createStep;
 exports.init = init;
 exports.serve = serve;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map