@mastra/inngest 0.0.0-scorers-api-v2-20250801171841 → 0.0.0-scorers-logs-20251208093427

package/dist/index.js

@@ -1,31 +1,300 @@
+import { Tool } from '@mastra/core/tools';
+import { DefaultExecutionEngine, createTimeTravelExecutionParams, Run, Workflow } from '@mastra/core/workflows';
+import { EMITTER_SYMBOL, STREAM_FORMAT_SYMBOL } from '@mastra/core/workflows/_constants';
+import { z } from 'zod';
 import { randomUUID } from 'crypto';
+import { ReadableStream, WritableStream } from 'stream/web';
+import { RequestContext } from '@mastra/core/di';
+import { RetryAfterError, NonRetriableError } from 'inngest';
 import { subscribe } from '@inngest/realtime';
-import { RuntimeContext } from '@mastra/core/di';
-import { ToolStream, Tool } from '@mastra/core/tools';
-import { Run, Workflow, DefaultExecutionEngine } from '@mastra/core/workflows';
-import { EMITTER_SYMBOL } from '@mastra/core/workflows/_constants';
+import { ChunkFrom, WorkflowRunOutput } from '@mastra/core/stream';
 import { serve as serve$1 } from 'inngest/hono';
-import { z } from 'zod';
 
 // src/index.ts
-function serve({ mastra, inngest }) {
-  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();
+var InngestExecutionEngine = class extends DefaultExecutionEngine {
+  inngestStep;
+  inngestAttempts;
+  constructor(mastra, inngestStep, inngestAttempts = 0, options) {
+    super({ mastra, options });
+    this.inngestStep = inngestStep;
+    this.inngestAttempts = inngestAttempts;
+  }
+  // =============================================================================
+  // Hook Overrides
+  // =============================================================================
+  /**
+   * Format errors with stack traces for better debugging in Inngest
+   */
+  formatResultError(error, lastOutput) {
+    if (error instanceof Error) {
+      return error.stack ?? error.message;
+    }
+    const outputError = lastOutput?.error;
+    if (outputError instanceof Error) {
+      return outputError.message;
+    }
+    return outputError ?? error ?? "Unknown error";
+  }
+  /**
+   * Detect InngestWorkflow instances for special nested workflow handling
+   */
+  isNestedWorkflowStep(step) {
+    return step instanceof InngestWorkflow;
+  }
+  /**
+   * Inngest requires requestContext serialization for memoization.
+   * When steps are replayed, the original function doesn't re-execute,
+   * so requestContext modifications must be captured and restored.
+   */
+  requiresDurableContextSerialization() {
+    return true;
+  }
+  /**
+   * Execute a step with retry logic for Inngest.
+   * Retries are handled via step-level retry (RetryAfterError thrown INSIDE step.run()).
+   * After retries exhausted, error propagates here and we return a failed result.
+   */
+  async executeStepWithRetry(stepId, runStep, params) {
+    try {
+      const result = await this.wrapDurableOperation(stepId, runStep, { delay: params.delay });
+      return { ok: true, result };
+    } catch (e) {
+      const cause = e?.cause;
+      if (cause?.status === "failed") {
+        params.stepSpan?.error({
+          error: e,
+          attributes: { status: "failed" }
+        });
+        return { ok: false, error: cause };
+      }
+      const errorMessage = e instanceof Error ? e.message : String(e);
+      params.stepSpan?.error({
+        error: e,
+        attributes: { status: "failed" }
+      });
+      return {
+        ok: false,
+        error: {
+          status: "failed",
+          error: `Error: ${errorMessage}`,
+          endedAt: Date.now()
         }
-        return [];
-      })
-    )
-  );
-  return serve$1({
-    client: inngest,
-    functions
-  });
-}
+      };
+    }
+  }
+  /**
+   * Use Inngest's sleep primitive for durability
+   */
+  async executeSleepDuration(duration, sleepId, workflowId) {
+    await this.inngestStep.sleep(`workflow.${workflowId}.sleep.${sleepId}`, duration < 0 ? 0 : duration);
+  }
+  /**
+   * Use Inngest's sleepUntil primitive for durability
+   */
+  async executeSleepUntilDate(date, sleepUntilId, workflowId) {
+    await this.inngestStep.sleepUntil(`workflow.${workflowId}.sleepUntil.${sleepUntilId}`, date);
+  }
+  /**
+   * Wrap durable operations in Inngest step.run() for durability.
+   * If retryConfig is provided, throws RetryAfterError INSIDE step.run() to trigger
+   * Inngest's step-level retry mechanism (not function-level retry).
+   */
+  async wrapDurableOperation(operationId, operationFn, retryConfig) {
+    return this.inngestStep.run(operationId, async () => {
+      try {
+        return await operationFn();
+      } catch (e) {
+        if (retryConfig) {
+          const errorMessage = e instanceof Error ? e.message : String(e);
+          throw new RetryAfterError(errorMessage, retryConfig.delay, {
+            cause: {
+              status: "failed",
+              error: `Error: ${errorMessage}`,
+              endedAt: Date.now()
+            }
+          });
+        }
+        throw e;
+      }
+    });
+  }
+  /**
+   * Provide Inngest step primitive in engine context
+   */
+  getEngineContext() {
+    return { step: this.inngestStep };
+  }
+  /**
+   * Execute nested InngestWorkflow using inngestStep.invoke() for durability.
+   * This MUST be called directly (not inside step.run()) due to Inngest constraints.
+   */
+  async executeWorkflowStep(params) {
+    if (!(params.step instanceof InngestWorkflow)) {
+      return null;
+    }
+    const { step, stepResults, executionContext, resume, timeTravel, prevOutput, inputData, emitter, startedAt } = params;
+    const isResume = !!resume?.steps?.length;
+    let result;
+    let runId;
+    const isTimeTravel = !!(timeTravel && timeTravel.steps?.length > 1 && timeTravel.steps[0] === step.id);
+    try {
+      if (isResume) {
+        runId = stepResults[resume?.steps?.[0] ?? ""]?.suspendPayload?.__workflow_meta?.runId ?? randomUUID();
+        const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
+          workflowName: step.id,
+          runId
+        });
+        const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
+          function: step.getFunction(),
+          data: {
+            inputData,
+            initialState: executionContext.state ?? snapshot?.value ?? {},
+            runId,
+            resume: {
+              runId,
+              steps: resume.steps.slice(1),
+              stepResults: snapshot?.context,
+              resumePayload: resume.resumePayload,
+              resumePath: resume.steps?.[1] ? snapshot?.suspendedPaths?.[resume.steps?.[1]] : void 0
+            },
+            outputOptions: { includeState: true }
+          }
+        });
+        result = invokeResp.result;
+        runId = invokeResp.runId;
+        executionContext.state = invokeResp.result.state;
+      } else if (isTimeTravel) {
+        const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
+          workflowName: step.id,
+          runId: executionContext.runId
+        }) ?? { context: {} };
+        const timeTravelParams = createTimeTravelExecutionParams({
+          steps: timeTravel.steps.slice(1),
+          inputData: timeTravel.inputData,
+          resumeData: timeTravel.resumeData,
+          context: timeTravel.nestedStepResults?.[step.id] ?? {},
+          nestedStepsContext: timeTravel.nestedStepResults ?? {},
+          snapshot,
+          graph: step.buildExecutionGraph()
+        });
+        const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
+          function: step.getFunction(),
+          data: {
+            timeTravel: timeTravelParams,
+            initialState: executionContext.state ?? {},
+            runId: executionContext.runId,
+            outputOptions: { includeState: true }
+          }
+        });
+        result = invokeResp.result;
+        runId = invokeResp.runId;
+        executionContext.state = invokeResp.result.state;
+      } else {
+        const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
+          function: step.getFunction(),
+          data: {
+            inputData,
+            initialState: executionContext.state ?? {},
+            outputOptions: { includeState: true }
+          }
+        });
+        result = invokeResp.result;
+        runId = invokeResp.runId;
+        executionContext.state = invokeResp.result.state;
+      }
+    } catch (e) {
+      const errorCause = e?.cause;
+      if (errorCause && typeof errorCause === "object") {
+        result = errorCause;
+        runId = errorCause.runId || randomUUID();
+      } else {
+        runId = randomUUID();
+        result = {
+          status: "failed",
+          error: e instanceof Error ? e : new Error(String(e)),
+          steps: {},
+          input: inputData
+        };
+      }
+    }
+    const res = await this.inngestStep.run(
+      `workflow.${executionContext.workflowId}.step.${step.id}.nestedwf-results`,
+      async () => {
+        if (result.status === "failed") {
+          await emitter.emit("watch", {
+            type: "workflow-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]) => {
+            const stepRes = stepResult;
+            return stepRes?.status === "suspended";
+          });
+          for (const [stepName, stepResult] of suspendedSteps) {
+            const suspendPath = [stepName, ...stepResult?.suspendPayload?.__workflow_meta?.path ?? []];
+            executionContext.suspendedPaths[step.id] = executionContext.executionPath;
+            await emitter.emit("watch", {
+              type: "workflow-step-suspended",
+              payload: {
+                id: step.id,
+                status: "suspended"
+              }
+            });
+            return {
+              executionContext,
+              result: {
+                status: "suspended",
+                payload: stepResult.payload,
+                suspendPayload: {
+                  ...stepResult?.suspendPayload,
+                  __workflow_meta: { runId, path: suspendPath }
+                }
+              }
+            };
+          }
+          return {
+            executionContext,
+            result: {
+              status: "suspended",
+              payload: {}
+            }
+          };
+        }
+        await emitter.emit("watch", {
+          type: "workflow-step-result",
+          payload: {
+            id: step.id,
+            status: "success",
+            output: result?.result
+          }
+        });
+        await emitter.emit("watch", {
+          type: "workflow-step-finish",
+          payload: {
+            id: step.id,
+            metadata: {}
+          }
+        });
+        return { executionContext, result: { status: "success", output: result?.result } };
+      }
+    );
+    Object.assign(executionContext, res.executionContext);
+    return {
+      ...res.result,
+      startedAt,
+      endedAt: Date.now(),
+      payload: inputData,
+      resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
+      resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+    };
+  }
+};
 var InngestRun = class extends Run {
   inngest;
   serializedStepGraph;
@@ -47,14 +316,21 @@ var InngestRun = class extends 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") {
-        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({
+        const snapshot = await storage?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId
+        });
+        return {
+          output: { result: { steps: snapshot?.context, status: "failed", error: runs?.[0]?.output?.message } }
+        };
+      }
+      if (runs?.[0]?.status === "Cancelled") {
+        const snapshot = await storage?.loadWorkflowSnapshot({
           workflowName: this.workflowId,
           runId: this.runId
         });
@@ -63,56 +339,73 @@ var InngestRun = class extends 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 this.#mastra?.storage?.loadWorkflowSnapshot({
+    const snapshot = await storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
     if (snapshot) {
-      await this.#mastra?.storage?.persistWorkflowSnapshot({
+      await storage?.persistWorkflowSnapshot({
         workflowName: this.workflowId,
         runId: this.runId,
+        resourceId: this.resourceId,
         snapshot: {
           ...snapshot,
-          status: "canceled"
+          status: "canceled",
+          value: snapshot.value
         }
       });
     }
   }
-  async start({
-    inputData
+  async start(params) {
+    return this._start(params);
+  }
+  async _start({
+    inputData,
+    initialState,
+    outputOptions,
+    tracingOptions,
+    format,
+    requestContext
   }) {
     await this.#mastra.getStorage()?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId,
+      resourceId: this.resourceId,
       snapshot: {
         runId: this.runId,
         serializedStepGraph: this.serializedStepGraph,
+        status: "running",
         value: {},
         context: {},
         activePaths: [],
         suspendedPaths: {},
-        timestamp: Date.now(),
-        status: "running"
+        activeStepsPath: {},
+        resumeLabels: {},
+        waitingPaths: {},
+        timestamp: Date.now()
       }
     });
+    const inputDataToUse = await this._validateInput(inputData);
+    const initialStateToUse = await this._validateInitialState(initialState ?? {});
     const eventOutput = await this.inngest.send({
       name: `workflow.${this.workflowId}`,
       data: {
-        inputData,
-        runId: this.runId
+        inputData: inputDataToUse,
+        initialState: initialStateToUse,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        outputOptions,
+        tracingOptions,
+        format,
+        requestContext: requestContext ? Object.fromEntries(requestContext.entries()) : {}
       }
     });
     const eventId = eventOutput.ids[0];
@@ -141,27 +434,131 @@ var InngestRun = class extends Run {
     return p;
   }
   async _resume(params) {
-    const steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
-      (step) => typeof step === "string" ? step : step?.id
-    );
-    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+    const storage = this.#mastra?.getStorage();
+    let steps = [];
+    if (typeof params.step === "string") {
+      steps = params.step.split(".");
+    } else {
+      steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
+        (step) => typeof step === "string" ? step : step?.id
+      );
+    }
+    const snapshot = await storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
+    const suspendedStep = this.workflowSteps[steps?.[0] ?? ""];
+    const resumeDataToUse = await this._validateResumeData(params.resumeData, suspendedStep);
+    const persistedRequestContext = snapshot?.requestContext ?? {};
+    const newRequestContext = params.requestContext ? Object.fromEntries(params.requestContext.entries()) : {};
+    const mergedRequestContext = { ...persistedRequestContext, ...newRequestContext };
     const eventOutput = await this.inngest.send({
       name: `workflow.${this.workflowId}`,
       data: {
-        inputData: params.resumeData,
+        inputData: resumeDataToUse,
+        initialState: snapshot?.value ?? {},
         runId: this.runId,
         workflowId: this.workflowId,
         stepResults: snapshot?.context,
         resume: {
           steps,
           stepResults: snapshot?.context,
-          resumePayload: params.resumeData,
-          // @ts-ignore
-          resumePath: snapshot?.suspendedPaths?.[steps?.[0]]
+          resumePayload: resumeDataToUse,
+          resumePath: steps?.[0] ? snapshot?.suspendedPaths?.[steps?.[0]] : void 0
+        },
+        requestContext: mergedRequestContext
+      }
+    });
+    const eventId = eventOutput.ids[0];
+    if (!eventId) {
+      throw new Error("Event ID is not set");
+    }
+    const runOutput = await this.getRunOutput(eventId);
+    const result = runOutput?.output?.result;
+    if (result.status === "failed") {
+      result.error = new Error(result.error);
+    }
+    return result;
+  }
+  async timeTravel(params) {
+    const p = this._timeTravel(params).then((result) => {
+      if (result.status !== "suspended") {
+        this.closeStreamAction?.().catch(() => {
+        });
+      }
+      return result;
+    });
+    this.executionResults = p;
+    return p;
+  }
+  async _timeTravel(params) {
+    if (!params.step || Array.isArray(params.step) && params.step?.length === 0) {
+      throw new Error("Step is required and must be a valid step or array of steps");
+    }
+    let steps = [];
+    if (typeof params.step === "string") {
+      steps = params.step.split(".");
+    } else {
+      steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
+        (step) => typeof step === "string" ? step : step?.id
+      );
+    }
+    if (steps.length === 0) {
+      throw new Error("No steps provided to timeTravel");
+    }
+    const storage = this.#mastra?.getStorage();
+    const snapshot = await storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (!snapshot) {
+      await storage?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        snapshot: {
+          runId: this.runId,
+          serializedStepGraph: this.serializedStepGraph,
+          status: "pending",
+          value: {},
+          context: {},
+          activePaths: [],
+          suspendedPaths: {},
+          activeStepsPath: {},
+          resumeLabels: {},
+          waitingPaths: {},
+          timestamp: Date.now()
         }
+      });
+    }
+    if (snapshot?.status === "running") {
+      throw new Error("This workflow run is still running, cannot time travel");
+    }
+    let inputDataToUse = params.inputData;
+    if (inputDataToUse && steps.length === 1) {
+      inputDataToUse = await this._validateTimetravelInputData(params.inputData, this.workflowSteps[steps[0]]);
+    }
+    const timeTravelData = createTimeTravelExecutionParams({
+      steps,
+      inputData: inputDataToUse,
+      resumeData: params.resumeData,
+      context: params.context,
+      nestedStepsContext: params.nestedStepsContext,
+      snapshot: snapshot ?? { context: {} },
+      graph: this.executionGraph,
+      initialState: params.initialState
+    });
+    const eventOutput = await this.inngest.send({
+      name: `workflow.${this.workflowId}`,
+      data: {
+        initialState: timeTravelData.state,
+        runId: this.runId,
+        workflowId: this.workflowId,
+        stepResults: timeTravelData.stepResults,
+        timeTravel: timeTravelData,
+        tracingOptions: params.tracingOptions,
+        outputOptions: params.outputOptions,
+        requestContext: params.requestContext ? Object.fromEntries(params.requestContext.entries()) : {}
       }
     });
     const eventId = eventOutput.ids[0];
@@ -175,12 +572,12 @@ var InngestRun = class extends Run {
     }
     return result;
   }
-  watch(cb, type = "watch") {
+  watch(cb) {
     let active = true;
     const streamPromise = subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: [type],
+        topics: ["watch"],
         app: this.inngest
       },
       (message) => {
@@ -198,16 +595,35 @@ var InngestRun = class extends Run {
       });
     };
   }
-  stream({ inputData, runtimeContext } = {}) {
+  streamLegacy({ inputData, requestContext } = {}) {
     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 {
-        await writer.write(event);
+        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();
@@ -217,7 +633,7 @@ var InngestRun = class extends Run {
         writer.releaseLock();
       }
     };
-    this.executionResults = this.start({ inputData, runtimeContext }).then((result) => {
+    this.executionResults = this._start({ inputData, requestContext, format: "legacy" }).then((result) => {
       if (result.status !== "suspended") {
         this.closeStreamAction?.().catch(() => {
         });
@@ -229,23 +645,177 @@ var InngestRun = class extends Run {
       getWorkflowState: () => this.executionResults
     };
   }
+  stream({
+    inputData,
+    requestContext,
+    tracingOptions,
+    closeOnSuspend = true,
+    initialState,
+    outputOptions
+  } = {}) {
+    if (this.closeStreamAction && this.streamOutput) {
+      return this.streamOutput;
+    }
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = ChunkFrom.WORKFLOW, payload }) => {
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            await controller.close();
+          } catch (err) {
+            console.error("Error closing stream:", err);
+          }
+        };
+        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"
+        });
+        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);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return this.streamOutput;
+  }
+  streamVNext(args = {}) {
+    return this.stream(args);
+  }
+  timeTravelStream({
+    inputData,
+    resumeData,
+    initialState,
+    step,
+    context,
+    nestedStepsContext,
+    requestContext,
+    tracingOptions,
+    outputOptions
+  }) {
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = ChunkFrom.WORKFLOW, payload }) => {
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            controller.close();
+          } catch (err) {
+            console.error("Error closing stream:", err);
+          }
+        };
+        const executionResultsPromise = self._timeTravel({
+          inputData,
+          step,
+          context,
+          nestedStepsContext,
+          resumeData,
+          initialState,
+          requestContext,
+          tracingOptions,
+          outputOptions
+        });
+        self.executionResults = executionResultsPromise;
+        let executionResults;
+        try {
+          executionResults = await executionResultsPromise;
+          self.closeStreamAction?.().catch(() => {
+          });
+          if (self.streamOutput) {
+            self.streamOutput.updateResults(executionResults);
+          }
+        } catch (err) {
+          self.streamOutput?.rejectResults(err);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return this.streamOutput;
+  }
 };
+
+// src/workflow.ts
 var InngestWorkflow = class _InngestWorkflow extends Workflow {
   #mastra;
   inngest;
   function;
+  flowControlConfig;
   constructor(params, inngest) {
-    super(params);
+    const { concurrency, rateLimit, throttle, debounce, priority, ...workflowParams } = params;
+    super(workflowParams);
+    this.engineType = "inngest";
+    const flowControlEntries = Object.entries({ concurrency, rateLimit, throttle, debounce, priority }).filter(
+      ([_, value]) => value !== void 0
+    );
+    this.flowControlConfig = flowControlEntries.length > 0 ? Object.fromEntries(flowControlEntries) : void 0;
     this.#mastra = params.mastra;
     this.inngest = inngest;
   }
-  async getWorkflowRuns(args) {
+  async listWorkflowRuns(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.getWorkflowRuns({ workflowName: this.id, ...args ?? {} });
+    return storage.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
   async getWorkflowRunById(runId) {
     const storage = this.#mastra?.getStorage();
@@ -256,27 +826,6 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     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);
@@ -295,56 +844,49 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       }
     }
   }
-  createRun(options) {
+  async createRun(options) {
     const runIdToUse = options?.runId || randomUUID();
     const run = this.runs.get(runIdToUse) ?? new InngestRun(
       {
         workflowId: this.id,
         runId: runIdToUse,
+        resourceId: options?.resourceId,
         executionEngine: this.executionEngine,
         executionGraph: this.executionGraph,
         serializedStepGraph: this.serializedStepGraph,
         mastra: this.#mastra,
         retryConfig: this.retryConfig,
-        cleanup: () => this.runs.delete(runIdToUse)
+        cleanup: () => this.runs.delete(runIdToUse),
+        workflowSteps: this.steps,
+        workflowEngineType: this.engineType,
+        validateInputs: this.options.validateInputs
       },
       this.inngest
     );
     this.runs.set(runIdToUse, run);
-    return run;
-  }
-  async createRunAsync(options) {
-    const runIdToUse = options?.runId || 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) {
+    const shouldPersistSnapshot = this.options.shouldPersistSnapshot({
+      workflowStatus: run.workflowRunStatus,
+      stepResults: {}
+    });
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, false);
+    if (!workflowSnapshotInStorage && shouldPersistSnapshot) {
       await this.mastra?.getStorage()?.persistWorkflowSnapshot({
         workflowName: this.id,
         runId: runIdToUse,
+        resourceId: options?.resourceId,
         snapshot: {
           runId: runIdToUse,
           status: "pending",
           value: {},
           context: {},
           activePaths: [],
+          activeStepsPath: {},
+          waitingPaths: {},
           serializedStepGraph: this.serializedStepGraph,
           suspendedPaths: {},
+          resumeLabels: {},
           result: void 0,
           error: void 0,
-          // @ts-ignore
           timestamp: Date.now()
         }
       });
@@ -358,13 +900,14 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     this.function = this.inngest.createFunction(
       {
         id: `workflow.${this.id}`,
-        // @ts-ignore
-        retries: this.retryConfig?.attempts ?? 0,
-        cancelOn: [{ event: `cancel.workflow.${this.id}` }]
+        retries: Math.min(this.retryConfig?.attempts ?? 0, 20),
+        cancelOn: [{ event: `cancel.workflow.${this.id}` }],
+        // Spread flow control configuration
+        ...this.flowControlConfig
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, runId, resume } = event.data;
+        let { inputData, initialState, runId, resourceId, resume, outputOptions, format, timeTravel } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
             return randomUUID();
@@ -392,19 +935,38 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
           once: (_event, _callback) => {
           }
         };
-        const engine = new InngestExecutionEngine(this.#mastra, step, attempt);
+        const engine = new InngestExecutionEngine(this.#mastra, step, attempt, this.options);
         const result = await engine.execute({
           workflowId: this.id,
           runId,
+          resourceId,
           graph: this.executionGraph,
           serializedStepGraph: this.serializedStepGraph,
           input: inputData,
+          initialState,
           emitter,
           retryConfig: this.retryConfig,
-          runtimeContext: new RuntimeContext(),
-          // TODO
+          requestContext: new RequestContext(Object.entries(event.data.requestContext ?? {})),
           resume,
-          abortController: new AbortController()
+          timeTravel,
+          format,
+          abortController: new AbortController(),
+          // currentSpan: undefined, // TODO: Pass actual parent Span from workflow execution context
+          outputOptions,
+          writableStream: new WritableStream({
+            write(chunk) {
+              void emitter.emit("watch", chunk).catch(() => {
+              });
+            }
+          })
+        });
+        await step.run(`workflow.${this.id}.finalize`, async () => {
+          if (result.status === "failed") {
+            throw new NonRetriableError(`Workflow failed`, {
+              cause: result
+            });
+          }
+          return result;
         });
         return { result, runId };
       }
@@ -428,27 +990,70 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
   }
 };
+function serve({
+  mastra,
+  inngest,
+  functions: userFunctions = [],
+  registerOptions
+}) {
+  const wfs = mastra.listWorkflows();
+  const workflowFunctions = Array.from(
+    new Set(
+      Object.values(wfs).flatMap((wf) => {
+        if (wf instanceof InngestWorkflow) {
+          wf.__registerMastra(mastra);
+          return wf.getFunctions();
+        }
+        return [];
+      })
+    )
+  );
+  return serve$1({
+    ...registerOptions,
+    client: inngest,
+    functions: [...workflowFunctions, ...userFunctions]
+  });
+}
+
+// src/types.ts
+var _compatibilityCheck = true;
+
+// src/index.ts
 function isAgent(params) {
   return params?.component === "AGENT";
 }
 function isTool(params) {
   return params instanceof Tool;
 }
-function createStep(params) {
+function isInngestWorkflow(params) {
+  return params instanceof InngestWorkflow;
+}
+function createStep(params, agentOptions) {
+  if (isInngestWorkflow(params)) {
+    return params;
+  }
   if (isAgent(params)) {
     return {
       id: params.name,
-      // @ts-ignore
+      description: params.getDescription(),
       inputSchema: z.object({
         prompt: z.string()
         // resourceId: z.string().optional(),
         // threadId: z.string().optional(),
       }),
-      // @ts-ignore
       outputSchema: z.object({
         text: z.string()
       }),
-      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort }) => {
+      execute: async ({
+        inputData,
+        [EMITTER_SYMBOL]: emitter,
+        [STREAM_FORMAT_SYMBOL]: streamFormat,
+        requestContext,
+        tracingContext,
+        abortSignal,
+        abort,
+        writer
+      }) => {
         let streamPromise = {};
         streamPromise.promise = new Promise((resolve, reject) => {
           streamPromise.resolve = resolve;
@@ -458,50 +1063,65 @@ function createStep(params) {
           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();
+        let stream;
+        if ((await params.getModel()).specificationVersion === "v1") {
+          const { fullStream } = await params.streamLegacy(inputData.prompt, {
+            ...agentOptions ?? {},
+            // resourceId: inputData.resourceId,
+            // threadId: inputData.threadId,
+            requestContext,
+            tracingContext,
+            onFinish: (result) => {
+              streamPromise.resolve(result.text);
+              void agentOptions?.onFinish?.(result);
+            },
+            abortSignal
+          });
+          stream = fullStream;
+        } else {
+          const modelOutput = await params.stream(inputData.prompt, {
+            ...agentOptions ?? {},
+            requestContext,
+            tracingContext,
+            onFinish: (result) => {
+              streamPromise.resolve(result.text);
+              void agentOptions?.onFinish?.(result);
+            },
+            abortSignal
+          });
+          stream = modelOutput.fullStream;
         }
-        for await (const chunk of fullStream) {
-          switch (chunk.type) {
-            case "text-delta":
-              await emitter.emit("watch-v2", {
+        if (streamFormat === "legacy") {
+          await emitter.emit("watch", {
+            type: "tool-call-streaming-start",
+            ...toolData ?? {}
+          });
+          for await (const chunk of stream) {
+            if (chunk.type === "text-delta") {
+              await emitter.emit("watch", {
                 type: "tool-call-delta",
-                ...toolData,
+                ...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;
+            }
+          }
+          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();
+        }
         return {
           text: await streamPromise.promise
         };
-      }
+      },
+      component: params.component
     };
   }
   if (isTool(params)) {
@@ -510,17 +1130,40 @@ function createStep(params) {
     }
     return {
       // TODO: tool probably should have strong id type
-      // @ts-ignore
       id: params.id,
+      description: params.description,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
-      execute: async ({ inputData, mastra, runtimeContext }) => {
-        return params.execute({
-          context: inputData,
+      suspendSchema: params.suspendSchema,
+      resumeSchema: params.resumeSchema,
+      execute: async ({
+        inputData,
+        mastra,
+        requestContext,
+        tracingContext,
+        suspend,
+        resumeData,
+        runId,
+        workflowId,
+        state,
+        setState
+      }) => {
+        const toolContext = {
           mastra,
-          runtimeContext
-        });
-      }
+          requestContext,
+          tracingContext,
+          workflow: {
+            runId,
+            resumeData,
+            suspend,
+            workflowId,
+            state,
+            setState
+          }
+        };
+        return params.execute(inputData, toolContext);
+      },
+      component: "TOOL"
     };
   }
   return {
@@ -536,7 +1179,10 @@ function createStep(params) {
 function init(inngest) {
   return {
     createWorkflow(params) {
-      return new InngestWorkflow(params, inngest);
+      return new InngestWorkflow(
+        params,
+        inngest
+      );
     },
     createStep,
     cloneStep(step, opts) {
@@ -545,7 +1191,13 @@ function init(inngest) {
         description: step.description,
         inputSchema: step.inputSchema,
         outputSchema: step.outputSchema,
-        execute: step.execute
+        resumeSchema: step.resumeSchema,
+        suspendSchema: step.suspendSchema,
+        stateSchema: step.stateSchema,
+        execute: step.execute,
+        retries: step.retries,
+        scorers: step.scorers,
+        component: step.component
       };
     },
     cloneWorkflow(workflow, opts) {
@@ -554,7 +1206,8 @@ function init(inngest) {
         inputSchema: workflow.inputSchema,
         outputSchema: workflow.outputSchema,
         steps: workflow.stepDefs,
-        mastra: workflow.mastra
+        mastra: workflow.mastra,
+        options: workflow.options
       });
       wf.setStepFlow(workflow.stepGraph);
       wf.commit();
@@ -562,733 +1215,7 @@ function init(inngest) {
     }
   };
 }
-var InngestExecutionEngine = class extends DefaultExecutionEngine {
-  inngestStep;
-  inngestAttempts;
-  constructor(mastra, inngestStep, inngestAttempts = 0) {
-    super({ mastra });
-    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,
-      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?.payload?.__workflow_meta?.path;
-          return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
-        }
-        return [];
-      });
-      base.suspended = suspendedStepIds;
-    }
-    executionSpan?.end();
-    return base;
-  }
-  async superExecuteStep({
-    workflowId,
-    runId,
-    step,
-    stepResults,
-    executionContext,
-    resume,
-    prevOutput,
-    emitter,
-    abortController,
-    runtimeContext,
-    writableStream
-  }) {
-    return super.executeStep({
-      workflowId,
-      runId,
-      step,
-      stepResults,
-      executionContext,
-      resume,
-      prevOutput,
-      emitter,
-      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 = 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();
-          },
-          [EMITTER_SYMBOL]: emitter,
-          engine: { step: this.inngestStep },
-          abortSignal: abortController?.signal,
-          writer: new 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 = 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();
-          },
-          [EMITTER_SYMBOL]: emitter,
-          engine: { step: this.inngestStep },
-          abortSignal: abortController?.signal,
-          writer: new 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,
-    executionContext,
-    resume,
-    prevOutput,
-    emitter,
-    abortController,
-    runtimeContext,
-    writableStream
-  }) {
-    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: "step-start",
-          payload: {
-            id: step.id,
-            status: "running",
-            payload: prevOutput,
-            startedAt: startedAt2
-          }
-        });
-        return startedAt2;
-      }
-    );
-    if (step instanceof InngestWorkflow) {
-      const isResume = !!resume?.steps?.length;
-      let result;
-      let runId;
-      if (isResume) {
-        runId = stepResults[resume?.steps?.[0]]?.payload?.__workflow_meta?.runId ?? randomUUID();
-        const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
-          workflowName: step.id,
-          runId
-        });
-        const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
-          function: step.getFunction(),
-          data: {
-            inputData: prevOutput,
-            runId,
-            resume: {
-              runId,
-              steps: resume.steps.slice(1),
-              stepResults: snapshot?.context,
-              resumePayload: resume.resumePayload,
-              // @ts-ignore
-              resumePath: snapshot?.suspendedPaths?.[resume.steps?.[1]]
-            }
-          }
-        });
-        result = invokeResp.result;
-        runId = invokeResp.runId;
-      } else {
-        const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
-          function: step.getFunction(),
-          data: {
-            inputData: prevOutput
-          }
-        });
-        result = invokeResp.result;
-        runId = invokeResp.runId;
-      }
-      const res = await this.inngestStep.run(
-        `workflow.${executionContext.workflowId}.step.${step.id}.nestedwf-results`,
-        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: "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]) => {
-              const stepRes2 = stepResult;
-              return stepRes2?.status === "suspended";
-            });
-            for (const [stepName, stepResult] of suspendedSteps) {
-              const suspendPath = [stepName, ...stepResult?.payload?.__workflow_meta?.path ?? []];
-              executionContext.suspendedPaths[step.id] = executionContext.executionPath;
-              await emitter.emit("watch", {
-                type: "watch",
-                payload: {
-                  currentStep: {
-                    id: step.id,
-                    status: "suspended",
-                    payload: { ...stepResult?.payload, __workflow_meta: { runId, path: suspendPath } }
-                  },
-                  workflowState: {
-                    status: "running",
-                    steps: stepResults,
-                    result: null,
-                    error: null
-                  }
-                },
-                eventTimestamp: Date.now()
-              });
-              await emitter.emit("watch-v2", {
-                type: "step-suspended",
-                payload: {
-                  id: step.id,
-                  status: "suspended"
-                }
-              });
-              return {
-                executionContext,
-                result: {
-                  status: "suspended",
-                  payload: { ...stepResult?.payload, __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: {
-                status: "suspended",
-                payload: {}
-              }
-            };
-          }
-          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: "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 } };
-        }
-      );
-      Object.assign(executionContext, res.executionContext);
-      return res.result;
-    }
-    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,
-          getStepResult: (step2) => {
-            const result2 = stepResults[step2.id];
-            if (result2?.status === "success") {
-              return result2.output;
-            }
-            return null;
-          },
-          suspend: async (suspendPayload) => {
-            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_SYMBOL]: emitter,
-          engine: {
-            step: this.inngestStep
-          },
-          abortSignal: abortController.signal
-        });
-        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",
-          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",
-          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) {
-          throw execResults.error;
-        }
-      }
-      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-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);
-    Object.assign(stepResults, stepRes.stepResults);
-    return stepRes.result;
-  }
-  async persistStepUpdate({
-    workflowId,
-    runId,
-    stepResults,
-    executionContext,
-    serializedStepGraph,
-    workflowStatus,
-    result,
-    error
-  }) {
-    await this.inngestStep.run(
-      `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
-      async () => {
-        await this.mastra?.getStorage()?.persistWorkflowSnapshot({
-          workflowName: workflowId,
-          runId,
-          snapshot: {
-            runId,
-            value: {},
-            context: stepResults,
-            activePaths: [],
-            suspendedPaths: executionContext.suspendedPaths,
-            serializedStepGraph,
-            status: workflowStatus,
-            result,
-            error,
-            // @ts-ignore
-            timestamp: Date.now()
-          }
-        });
-      }
-    );
-  }
-  async executeConditional({
-    workflowId,
-    runId,
-    entry,
-    prevOutput,
-    prevStep,
-    stepResults,
-    serializedStepGraph,
-    resume,
-    executionContext,
-    emitter,
-    abortController,
-    runtimeContext,
-    writableStream
-  }) {
-    let execResults;
-    const truthyIndexes = (await Promise.all(
-      entry.conditions.map(
-        (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) => {
-                if (!step?.id) {
-                  return null;
-                }
-                const result2 = stepResults[step.id];
-                if (result2?.status === "success") {
-                  return result2.output;
-                }
-                return null;
-              },
-              // TODO: this function shouldn't have suspend probably?
-              suspend: async (_suspendPayload) => {
-              },
-              bail: () => {
-              },
-              abort: () => {
-                abortController.abort();
-              },
-              [EMITTER_SYMBOL]: emitter,
-              engine: {
-                step: this.inngestStep
-              },
-              abortSignal: abortController.signal,
-              writer: new ToolStream(
-                {
-                  prefix: "step",
-                  callId: randomUUID(),
-                  name: "conditional",
-                  runId
-                },
-                writableStream
-              )
-            });
-            return result ? index : null;
-          } catch (e) {
-            return null;
-          }
-        })
-      )
-    )).filter((index) => index !== null);
-    const stepsToRun = entry.steps.filter((_, index) => truthyIndexes.includes(index));
-    const results = await Promise.all(
-      stepsToRun.map(
-        (step, index) => this.executeEntry({
-          workflowId,
-          runId,
-          entry: step,
-          prevStep,
-          stepResults,
-          resume,
-          serializedStepGraph,
-          executionContext: {
-            workflowId,
-            runId,
-            executionPath: [...executionContext.executionPath, index],
-            suspendedPaths: executionContext.suspendedPaths,
-            retryConfig: executionContext.retryConfig,
-            executionSpan: executionContext.executionSpan
-          },
-          emitter,
-          abortController,
-          runtimeContext,
-          writableStream
-        })
-      )
-    );
-    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.result.error };
-    } else if (hasSuspended) {
-      execResults = { status: "suspended", payload: hasSuspended.result.suspendPayload };
-    } else {
-      execResults = {
-        status: "success",
-        output: results.reduce((acc, result, index) => {
-          if (result.result.status === "success") {
-            acc[stepsToRun[index].step.id] = result.output;
-          }
-          return acc;
-        }, {})
-      };
-    }
-    return execResults;
-  }
-};
 
-export { InngestExecutionEngine, InngestRun, InngestWorkflow, createStep, init, serve };
+export { InngestExecutionEngine, InngestRun, InngestWorkflow, _compatibilityCheck, createStep, init, serve };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map