@mastra/inngest 0.0.0-ai-sdk-network-text-delta-20251017172601 → 0.0.0-alternative-angelfish-f7665c-20260119184917

package/dist/index.cjs

@@ -1,300 +1,1279 @@
 'use strict';
 
-var crypto = require('crypto');
-var realtime = require('@inngest/realtime');
-var aiTracing = require('@mastra/core/ai-tracing');
-var di = require('@mastra/core/di');
+var agent = require('@mastra/core/agent');
+var error = require('@mastra/core/error');
+var observability = require('@mastra/core/observability');
+var processors = require('@mastra/core/processors');
 var tools = require('@mastra/core/tools');
 var workflows = require('@mastra/core/workflows');
 var _constants = require('@mastra/core/workflows/_constants');
+var zod = require('zod');
+var crypto$1 = require('crypto');
+var di = require('@mastra/core/di');
 var inngest = require('inngest');
+var realtime = require('@inngest/realtime');
+var events = require('@mastra/core/events');
+var web = require('stream/web');
+var stream = require('@mastra/core/stream');
 var hono = require('inngest/hono');
-var zod = require('zod');
 
 // src/index.ts
-function serve({
-  mastra,
-  inngest,
-  functions: userFunctions = [],
-  registerOptions
-}) {
-  const wfs = mastra.getWorkflows();
-  const workflowFunctions = Array.from(
-    new Set(
-      Object.values(wfs).flatMap((wf) => {
-        if (wf instanceof InngestWorkflow) {
-          wf.__registerMastra(mastra);
-          return wf.getFunctions();
-        }
-        return [];
-      })
-    )
-  );
-  return hono.serve({
-    ...registerOptions,
-    client: inngest,
-    functions: [...workflowFunctions, ...userFunctions]
-  });
-}
-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;
+var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
+  inngestStep;
+  inngestAttempts;
+  constructor(mastra, inngestStep, inngestAttempts = 0, options) {
+    super({ mastra, options });
+    this.inngestStep = inngestStep;
+    this.inngestAttempts = inngestAttempts;
   }
-  async getRuns(eventId) {
-    const response = await fetch(`${this.inngest.apiBaseUrl ?? "https://api.inngest.com"}/v1/events/${eventId}/runs`, {
-      headers: {
-        Authorization: `Bearer ${process.env.INNGEST_SIGNING_KEY}`
-      }
+  // =============================================================================
+  // Hook Overrides
+  // =============================================================================
+  /**
+   * Format errors while preserving Error instances and their custom properties.
+   * Uses getErrorFromUnknown to ensure all error properties are preserved.
+   */
+  formatResultError(error$1, lastOutput) {
+    const outputError = lastOutput?.error;
+    const errorSource = error$1 || outputError;
+    const errorInstance = error.getErrorFromUnknown(errorSource, {
+      serializeStack: true,
+      // Include stack in JSON for better debugging in Inngest
+      fallbackMessage: "Unknown workflow error"
     });
-    const json = await response.json();
-    return json.data;
+    return errorInstance.toJSON();
   }
-  async getRunOutput(eventId) {
-    let runs = await this.getRuns(eventId);
-    while (runs?.[0]?.status !== "Completed" || runs?.[0]?.event_id !== eventId) {
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      runs = await this.getRuns(eventId);
-      if (runs?.[0]?.status === "Failed") {
-        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
-          workflowName: this.workflowId,
-          runId: this.runId
-        });
-        return {
-          output: { result: { steps: snapshot?.context, status: "failed", error: runs?.[0]?.output?.message } }
-        };
+  /**
+   * 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) {
+    for (let i = 0; i < params.retries + 1; i++) {
+      if (i > 0 && params.delay) {
+        await new Promise((resolve) => setTimeout(resolve, params.delay));
       }
-      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" } } };
+      try {
+        const result = await this.wrapDurableOperation(stepId, runStep);
+        return { ok: true, result };
+      } catch (e) {
+        if (i === params.retries) {
+          const cause = e?.cause;
+          if (cause?.status === "failed") {
+            params.stepSpan?.error({
+              error: e,
+              attributes: { status: "failed" }
+            });
+            if (cause.error && !(cause.error instanceof Error)) {
+              cause.error = error.getErrorFromUnknown(cause.error, { serializeStack: false });
+            }
+            return { ok: false, error: cause };
+          }
+          const errorInstance = error.getErrorFromUnknown(e, {
+            serializeStack: false,
+            fallbackMessage: "Unknown step execution error"
+          });
+          params.stepSpan?.error({
+            error: errorInstance,
+            attributes: { status: "failed" }
+          });
+          return {
+            ok: false,
+            error: {
+              status: "failed",
+              error: errorInstance,
+              endedAt: Date.now()
+            }
+          };
+        }
       }
     }
-    return runs?.[0];
+    return { ok: false, error: { status: "failed", error: new Error("Unknown error"), endedAt: Date.now() } };
   }
-  async sendEvent(event, data) {
-    await this.inngest.send({
-      name: `user-event-${event}`,
-      data
-    });
+  /**
+   * Use Inngest's sleep primitive for durability
+   */
+  async executeSleepDuration(duration, sleepId, workflowId) {
+    await this.inngestStep.sleep(`workflow.${workflowId}.sleep.${sleepId}`, duration < 0 ? 0 : duration);
   }
-  async cancel() {
-    await this.inngest.send({
-      name: `cancel.workflow.${this.workflowId}`,
-      data: {
-        runId: this.runId
+  /**
+   * 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.
+   *
+   * IMPORTANT: Errors are wrapped with a cause structure before throwing.
+   * This is necessary because Inngest's error serialization (serialize-error-cjs)
+   * only captures standard Error properties (message, name, stack, code, cause).
+   * Custom properties like statusCode, responseHeaders from AI SDK errors would
+   * be lost. By putting our serialized error (via getErrorFromUnknown with toJSON())
+   * in the cause property, we ensure custom properties survive serialization.
+   * The cause property is in serialize-error-cjs's allowlist, and when the cause
+   * object is finally JSON.stringify'd, our error's toJSON() is called.
+   */
+  async wrapDurableOperation(operationId, operationFn) {
+    return this.inngestStep.run(operationId, async () => {
+      try {
+        return await operationFn();
+      } catch (e) {
+        const errorInstance = error.getErrorFromUnknown(e, {
+          serializeStack: false,
+          fallbackMessage: "Unknown step execution error"
+        });
+        throw new Error(errorInstance.message, {
+          cause: {
+            status: "failed",
+            error: errorInstance,
+            endedAt: Date.now()
+          }
+        });
       }
     });
-    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,
-        resourceId: this.resourceId,
-        snapshot: {
-          ...snapshot,
-          status: "canceled"
-        }
+  }
+  /**
+   * Provide Inngest step primitive in engine context
+   */
+  getEngineContext() {
+    return { step: this.inngestStep };
+  }
+  /**
+   * For Inngest, lifecycle callbacks are invoked in the workflow's finalize step
+   * (wrapped in step.run for durability), not in execute(). Override to skip.
+   */
+  async invokeLifecycleCallbacks(_result) {
+  }
+  /**
+   * Actually invoke the lifecycle callbacks. Called from workflow.ts finalize step.
+   */
+  async invokeLifecycleCallbacksInternal(result) {
+    return super.invokeLifecycleCallbacks(result);
+  }
+  // =============================================================================
+  // Durable Span Lifecycle Hooks
+  // =============================================================================
+  /**
+   * Create a step span durably - on first execution, creates and exports span.
+   * On replay, returns cached span data without re-creating.
+   */
+  async createStepSpan(params) {
+    const { executionContext, operationId, options, parentSpan } = params;
+    const parentSpanId = parentSpan?.id ?? executionContext.tracingIds?.workflowSpanId;
+    const exportedSpan = await this.wrapDurableOperation(operationId, async () => {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      if (!observability) return void 0;
+      const span = observability.startSpan({
+        ...options,
+        entityType: options.entityType,
+        traceId: executionContext.tracingIds?.traceId,
+        parentSpanId
       });
+      return span?.exportSpan();
+    });
+    if (exportedSpan) {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      return observability?.rebuildSpan(exportedSpan);
     }
+    return void 0;
   }
-  async start({
-    inputData,
-    initialState
-  }) {
-    await this.#mastra.getStorage()?.persistWorkflowSnapshot({
-      workflowName: this.workflowId,
-      runId: this.runId,
-      resourceId: this.resourceId,
-      snapshot: {
-        runId: this.runId,
-        serializedStepGraph: this.serializedStepGraph,
-        value: {},
-        context: {},
-        activePaths: [],
-        suspendedPaths: {},
-        resumeLabels: {},
-        waitingPaths: {},
-        timestamp: Date.now(),
-        status: "running"
-      }
+  /**
+   * End a step span durably.
+   */
+  async endStepSpan(params) {
+    const { span, operationId, endOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.end(endOptions);
     });
-    const inputDataToUse = await this._validateInput(inputData);
-    const initialStateToUse = await this._validateInitialState(initialState ?? {});
-    const eventOutput = await this.inngest.send({
-      name: `workflow.${this.workflowId}`,
-      data: {
-        inputData: inputDataToUse,
-        initialState: initialStateToUse,
-        runId: this.runId,
-        resourceId: this.resourceId
-      }
+  }
+  /**
+   * Record error on step span durably.
+   */
+  async errorStepSpan(params) {
+    const { span, operationId, errorOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.error(errorOptions);
     });
-    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);
-    }
-    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;
+  /**
+   * Create a generic child span durably (for control-flow operations).
+   * On first execution, creates and exports span. On replay, returns cached span data.
+   */
+  async createChildSpan(params) {
+    const { executionContext, operationId, options, parentSpan } = params;
+    const parentSpanId = parentSpan?.id ?? executionContext.tracingIds?.workflowSpanId;
+    const exportedSpan = await this.wrapDurableOperation(operationId, async () => {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      if (!observability) return void 0;
+      const span = observability.startSpan({
+        ...options,
+        traceId: executionContext.tracingIds?.traceId,
+        parentSpanId
+      });
+      return span?.exportSpan();
     });
-    this.executionResults = p;
-    return p;
+    if (exportedSpan) {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      return observability?.rebuildSpan(exportedSpan);
+    }
+    return void 0;
   }
-  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({
-      workflowName: this.workflowId,
-      runId: this.runId
+  /**
+   * End a generic child span durably (for control-flow operations).
+   */
+  async endChildSpan(params) {
+    const { span, operationId, endOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.end(endOptions);
     });
-    const suspendedStep = this.workflowSteps[steps?.[0] ?? ""];
-    const resumeDataToUse = await this._validateResumeData(params.resumeData, suspendedStep);
-    const eventOutput = await this.inngest.send({
-      name: `workflow.${this.workflowId}`,
-      data: {
-        inputData: resumeDataToUse,
-        initialState: snapshot?.value ?? {},
-        runId: this.runId,
-        workflowId: this.workflowId,
-        stepResults: snapshot?.context,
-        resume: {
-          steps,
-          stepResults: snapshot?.context,
-          resumePayload: resumeDataToUse,
-          // @ts-ignore
-          resumePath: snapshot?.suspendedPaths?.[steps?.[0]]
-        }
-      }
+  }
+  /**
+   * Record error on a generic child span durably (for control-flow operations).
+   */
+  async errorChildSpan(params) {
+    const { span, operationId, errorOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.error(errorOptions);
     });
-    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;
   }
-  watch(cb, type = "watch") {
-    let active = true;
-    const streamPromise = realtime.subscribe(
-      {
-        channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: [type],
-        app: this.inngest
-      },
-      (message) => {
-        if (active) {
-          cb(message.data);
-        }
+  /**
+   * 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,
+      pubsub,
+      startedAt,
+      perStep,
+      stepSpan
+    } = params;
+    const nestedTracingContext = executionContext.tracingIds?.traceId ? {
+      traceId: executionContext.tracingIds.traceId,
+      parentSpanId: stepSpan?.id
+    } : void 0;
+    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 ?? crypto$1.randomUUID();
+        const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
+        const snapshot = await workflowsStore?.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 },
+            perStep,
+            tracingOptions: nestedTracingContext
+          }
+        });
+        result = invokeResp.result;
+        runId = invokeResp.runId;
+        executionContext.state = invokeResp.result.state;
+      } else if (isTimeTravel) {
+        const workflowsStoreForTimeTravel = await this.mastra?.getStorage()?.getStore("workflows");
+        const snapshot = await workflowsStoreForTimeTravel?.loadWorkflowSnapshot({
+          workflowName: step.id,
+          runId: executionContext.runId
+        }) ?? { context: {} };
+        const timeTravelParams = workflows.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 },
+            perStep,
+            tracingOptions: nestedTracingContext
+          }
+        });
+        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 },
+            perStep,
+            tracingOptions: nestedTracingContext
+          }
+        });
+        result = invokeResp.result;
+        runId = invokeResp.runId;
+        executionContext.state = invokeResp.result.state;
       }
-    );
-    return () => {
-      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 {
-        const e = {
-          ...event,
-          type: event.type.replace("workflow-", "")
+    } catch (e) {
+      const errorCause = e?.cause;
+      if (errorCause && typeof errorCause === "object") {
+        result = errorCause;
+        runId = errorCause.runId || crypto$1.randomUUID();
+      } else {
+        runId = crypto$1.randomUUID();
+        result = {
+          status: "failed",
+          error: e instanceof Error ? e : new Error(String(e)),
+          steps: {},
+          input: inputData
         };
-        await writer.write(e);
-      } catch {
       }
-    }, "watch-v2");
-    this.closeStreamAction = async () => {
-      unwatch();
-      try {
-        await writer.close();
+    }
+    const res = await this.inngestStep.run(
+      `workflow.${executionContext.workflowId}.step.${step.id}.nestedwf-results`,
+      async () => {
+        if (result.status === "failed") {
+          await pubsub.publish(`workflow.events.v2.${executionContext.runId}`, {
+            type: "watch",
+            runId: executionContext.runId,
+            data: {
+              type: "workflow-step-result",
+              payload: {
+                id: step.id,
+                status: "failed",
+                error: result?.error,
+                payload: prevOutput
+              }
+            }
+          });
+          return { executionContext, result: { status: "failed", error: result?.error, endedAt: Date.now() } };
+        } 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 pubsub.publish(`workflow.events.v2.${executionContext.runId}`, {
+              type: "watch",
+              runId: executionContext.runId,
+              data: {
+                type: "workflow-step-suspended",
+                payload: {
+                  id: step.id,
+                  status: "suspended"
+                }
+              }
+            });
+            return {
+              executionContext,
+              result: {
+                status: "suspended",
+                suspendedAt: Date.now(),
+                payload: stepResult.payload,
+                suspendPayload: {
+                  ...stepResult?.suspendPayload,
+                  __workflow_meta: { runId, path: suspendPath }
+                }
+              }
+            };
+          }
+          return {
+            executionContext,
+            result: {
+              status: "suspended",
+              suspendedAt: Date.now(),
+              payload: {}
+            }
+          };
+        } else if (result.status === "tripwire") {
+          await pubsub.publish(`workflow.events.v2.${executionContext.runId}`, {
+            type: "watch",
+            runId: executionContext.runId,
+            data: {
+              type: "workflow-step-result",
+              payload: {
+                id: step.id,
+                status: "tripwire",
+                error: result?.tripwire?.reason,
+                payload: prevOutput
+              }
+            }
+          });
+          return {
+            executionContext,
+            result: {
+              status: "tripwire",
+              tripwire: result?.tripwire,
+              endedAt: Date.now()
+            }
+          };
+        } else if (perStep || result.status === "paused") {
+          await pubsub.publish(`workflow.events.v2.${executionContext.runId}`, {
+            type: "watch",
+            runId: executionContext.runId,
+            data: {
+              type: "workflow-step-result",
+              payload: {
+                id: step.id,
+                status: "paused"
+              }
+            }
+          });
+          await pubsub.publish(`workflow.events.v2.${executionContext.runId}`, {
+            type: "watch",
+            runId: executionContext.runId,
+            data: {
+              type: "workflow-step-finish",
+              payload: {
+                id: step.id,
+                metadata: {}
+              }
+            }
+          });
+          return { executionContext, result: { status: "paused" } };
+        }
+        await pubsub.publish(`workflow.events.v2.${executionContext.runId}`, {
+          type: "watch",
+          runId: executionContext.runId,
+          data: {
+            type: "workflow-step-result",
+            payload: {
+              id: step.id,
+              status: "success",
+              output: result?.result
+            }
+          }
+        });
+        await pubsub.publish(`workflow.events.v2.${executionContext.runId}`, {
+          type: "watch",
+          runId: executionContext.runId,
+          data: {
+            type: "workflow-step-finish",
+            payload: {
+              id: step.id,
+              metadata: {}
+            }
+          }
+        });
+        return { executionContext, result: { status: "success", output: result?.result, endedAt: Date.now() } };
+      }
+    );
+    Object.assign(executionContext, res.executionContext);
+    return {
+      ...res.result,
+      startedAt,
+      payload: inputData,
+      resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
+      resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+    };
+  }
+};
+var InngestPubSub = class extends events.PubSub {
+  inngest;
+  workflowId;
+  publishFn;
+  subscriptions = /* @__PURE__ */ new Map();
+  constructor(inngest, workflowId, publishFn) {
+    super();
+    this.inngest = inngest;
+    this.workflowId = workflowId;
+    this.publishFn = publishFn;
+  }
+  /**
+   * Publish an event to Inngest's realtime system.
+   *
+   * Topic format: "workflow.events.v2.{runId}"
+   * Maps to Inngest channel: "workflow:{workflowId}:{runId}"
+   */
+  async publish(topic, event) {
+    if (!this.publishFn) {
+      return;
+    }
+    const match = topic.match(/^workflow\.events\.v2\.(.+)$/);
+    if (!match) {
+      return;
+    }
+    const runId = match[1];
+    try {
+      await this.publishFn({
+        channel: `workflow:${this.workflowId}:${runId}`,
+        topic: "watch",
+        data: event.data
+      });
+    } catch (err) {
+      console.error("InngestPubSub publish error:", err?.message ?? err);
+    }
+  }
+  /**
+   * Subscribe to events from Inngest's realtime system.
+   *
+   * Topic format: "workflow.events.v2.{runId}"
+   * Maps to Inngest channel: "workflow:{workflowId}:{runId}"
+   */
+  async subscribe(topic, cb) {
+    const match = topic.match(/^workflow\.events\.v2\.(.+)$/);
+    if (!match || !match[1]) {
+      return;
+    }
+    const runId = match[1];
+    if (this.subscriptions.has(topic)) {
+      this.subscriptions.get(topic).callbacks.add(cb);
+      return;
+    }
+    const callbacks = /* @__PURE__ */ new Set([cb]);
+    const channel = `workflow:${this.workflowId}:${runId}`;
+    const streamPromise = realtime.subscribe(
+      {
+        channel,
+        topics: ["watch"],
+        app: this.inngest
+      },
+      (message) => {
+        const event = {
+          id: crypto.randomUUID(),
+          type: "watch",
+          runId,
+          data: message.data,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        for (const callback of callbacks) {
+          callback(event);
+        }
+      }
+    );
+    this.subscriptions.set(topic, {
+      unsubscribe: () => {
+        streamPromise.then((stream) => stream.cancel()).catch((err) => {
+          console.error("InngestPubSub unsubscribe error:", err);
+        });
+      },
+      callbacks
+    });
+  }
+  /**
+   * Unsubscribe a callback from a topic.
+   * If no callbacks remain, the underlying Inngest subscription is cancelled.
+   */
+  async unsubscribe(topic, cb) {
+    const sub = this.subscriptions.get(topic);
+    if (!sub) {
+      return;
+    }
+    sub.callbacks.delete(cb);
+    if (sub.callbacks.size === 0) {
+      sub.unsubscribe();
+      this.subscriptions.delete(topic);
+    }
+  }
+  /**
+   * Flush any pending operations. No-op for Inngest.
+   */
+  async flush() {
+  }
+  /**
+   * Clean up all subscriptions during graceful shutdown.
+   */
+  async close() {
+    for (const [, sub] of this.subscriptions) {
+      sub.unsubscribe();
+    }
+    this.subscriptions.clear();
+  }
+};
+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 maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const response = await fetch(
+          `${this.inngest.apiBaseUrl ?? "https://api.inngest.com"}/v1/events/${eventId}/runs`,
+          {
+            headers: {
+              Authorization: `Bearer ${process.env.INNGEST_SIGNING_KEY}`
+            }
+          }
+        );
+        if (response.status === 429) {
+          const retryAfter = parseInt(response.headers.get("retry-after") || "2", 10);
+          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1e3));
+          continue;
+        }
+        if (!response.ok) {
+          throw new Error(`Inngest API error: ${response.status} ${response.statusText}`);
+        }
+        const text = await response.text();
+        if (!text) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3 * (attempt + 1)));
+          continue;
+        }
+        const json = JSON.parse(text);
+        return json.data;
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxRetries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
+        }
+      }
+    }
+    throw new inngest.NonRetriableError(`Failed to get runs after ${maxRetries} attempts: ${lastError?.message}`);
+  }
+  async getRunOutput(eventId, maxWaitMs = 3e5) {
+    const startTime = Date.now();
+    const storage = this.#mastra?.getStorage();
+    const workflowsStore = await storage?.getStore("workflows");
+    while (Date.now() - startTime < maxWaitMs) {
+      let runs;
+      try {
+        runs = await this.getRuns(eventId);
+      } catch (error) {
+        if (error instanceof inngest.NonRetriableError) {
+          throw error;
+        }
+        throw new inngest.NonRetriableError(
+          `Failed to poll workflow status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (runs?.[0]?.status === "Completed" && runs?.[0]?.event_id === eventId) {
+        return runs[0];
+      }
+      if (runs?.[0]?.status === "Failed") {
+        const snapshot = await workflowsStore?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId
+        });
+        if (snapshot?.context) {
+          snapshot.context = workflows.hydrateSerializedStepErrors(snapshot.context);
+        }
+        return {
+          output: {
+            result: {
+              steps: snapshot?.context,
+              status: "failed",
+              // Get the original error from NonRetriableError's cause (which contains the workflow result)
+              error: error.getErrorFromUnknown(runs?.[0]?.output?.cause?.error, { serializeStack: false })
+            }
+          }
+        };
+      }
+      if (runs?.[0]?.status === "Cancelled") {
+        const snapshot = await workflowsStore?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId
+        });
+        return { output: { result: { steps: snapshot?.context, status: "canceled" } } };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1e3 + Math.random() * 1e3));
+    }
+    throw new inngest.NonRetriableError(`Workflow did not complete within ${maxWaitMs}ms`);
+  }
+  async cancel() {
+    const storage = this.#mastra?.getStorage();
+    await this.inngest.send({
+      name: `cancel.workflow.${this.workflowId}`,
+      data: {
+        runId: this.runId
+      }
+    });
+    const workflowsStore = await storage?.getStore("workflows");
+    const snapshot = await workflowsStore?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (snapshot) {
+      await workflowsStore?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        snapshot: {
+          ...snapshot,
+          status: "canceled",
+          value: snapshot.value
+        }
+      });
+    }
+  }
+  async start(args) {
+    return this._start(args);
+  }
+  /**
+   * Starts the workflow execution without waiting for completion (fire-and-forget).
+   * Returns immediately with the runId after sending the event to Inngest.
+   * The workflow executes independently in Inngest.
+   * Use this when you don't need to wait for the result or want to avoid polling failures.
+   */
+  async startAsync(args) {
+    const workflowsStore = await this.#mastra.getStorage()?.getStore("workflows");
+    await workflowsStore?.persistWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId,
+      resourceId: this.resourceId,
+      snapshot: {
+        runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
+        status: "running",
+        value: {},
+        context: {},
+        activePaths: [],
+        suspendedPaths: {},
+        activeStepsPath: {},
+        resumeLabels: {},
+        waitingPaths: {},
+        timestamp: Date.now()
+      }
+    });
+    const inputDataToUse = await this._validateInput(args.inputData);
+    const initialStateToUse = await this._validateInitialState(args.initialState ?? {});
+    const eventOutput = await this.inngest.send({
+      name: `workflow.${this.workflowId}`,
+      data: {
+        inputData: inputDataToUse,
+        initialState: initialStateToUse,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        outputOptions: args.outputOptions,
+        tracingOptions: args.tracingOptions,
+        requestContext: args.requestContext ? Object.fromEntries(args.requestContext.entries()) : {},
+        perStep: args.perStep
+      }
+    });
+    const eventId = eventOutput.ids[0];
+    if (!eventId) {
+      throw new Error("Event ID is not set");
+    }
+    return { runId: this.runId };
+  }
+  async _start({
+    inputData,
+    initialState,
+    outputOptions,
+    tracingOptions,
+    format,
+    requestContext,
+    perStep
+  }) {
+    const workflowsStore = await this.#mastra.getStorage()?.getStore("workflows");
+    await workflowsStore?.persistWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId,
+      resourceId: this.resourceId,
+      snapshot: {
+        runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
+        status: "running",
+        value: {},
+        context: {},
+        activePaths: [],
+        suspendedPaths: {},
+        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: inputDataToUse,
+        initialState: initialStateToUse,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        outputOptions,
+        tracingOptions,
+        format,
+        requestContext: requestContext ? Object.fromEntries(requestContext.entries()) : {},
+        perStep
+      }
+    });
+    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;
+    this.hydrateFailedResult(result);
+    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 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 workflowsStore = await storage?.getStore("workflows");
+    const snapshot = await workflowsStore?.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: resumeDataToUse,
+        initialState: snapshot?.value ?? {},
+        runId: this.runId,
+        workflowId: this.workflowId,
+        stepResults: snapshot?.context,
+        resume: {
+          steps,
+          stepResults: snapshot?.context,
+          resumePayload: resumeDataToUse,
+          resumePath: steps?.[0] ? snapshot?.suspendedPaths?.[steps?.[0]] : void 0
+        },
+        requestContext: mergedRequestContext,
+        perStep: params.perStep
+      }
+    });
+    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;
+    this.hydrateFailedResult(result);
+    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 workflowsStore = await storage?.getStore("workflows");
+    const snapshot = await workflowsStore?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (!snapshot) {
+      await workflowsStore?.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 = workflows.createTimeTravelExecutionParams({
+      steps,
+      inputData: inputDataToUse,
+      resumeData: params.resumeData,
+      context: params.context,
+      nestedStepsContext: params.nestedStepsContext,
+      snapshot: snapshot ?? { context: {} },
+      graph: this.executionGraph,
+      initialState: params.initialState,
+      perStep: params.perStep
+    });
+    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()) : {},
+        perStep: params.perStep
+      }
+    });
+    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;
+    this.hydrateFailedResult(result);
+    return result;
+  }
+  watch(cb) {
+    let active = true;
+    const streamPromise = realtime.subscribe(
+      {
+        channel: `workflow:${this.workflowId}:${this.runId}`,
+        topics: ["watch"],
+        app: this.inngest
+      },
+      (message) => {
+        if (active) {
+          cb(message.data);
+        }
+      }
+    );
+    return () => {
+      active = false;
+      streamPromise.then(async (stream) => {
+        return stream.cancel();
+      }).catch((err) => {
+        console.error(err);
+      });
+    };
+  }
+  streamLegacy({ inputData, requestContext } = {}) {
+    const { readable, writable } = new TransformStream();
+    const writer = writable.getWriter();
+    void writer.write({
+      // @ts-ignore
+      type: "start",
+      // @ts-ignore
+      payload: { runId: this.runId }
+    });
+    const unwatch = this.watch(async (event) => {
+      try {
+        const e = {
+          ...event,
+          type: event.type.replace("workflow-", "")
+        };
+        if (e.type === "step-output") {
+          e.type = e.payload.output.type;
+          e.payload = e.payload.output.payload;
+        }
+        await writer.write(e);
+      } catch {
+      }
+    });
+    this.closeStreamAction = async () => {
+      await writer.write({
+        type: "finish",
+        // @ts-ignore
+        payload: { runId: this.runId }
+      });
+      unwatch();
+      try {
+        await writer.close();
       } catch (err) {
         console.error("Error closing stream:", err);
       } finally {
         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(() => {
         });
       }
-      return result;
+      return result;
+    });
+    return {
+      stream: readable,
+      getWorkflowState: () => this.executionResults
+    };
+  }
+  stream({
+    inputData,
+    requestContext,
+    tracingOptions,
+    closeOnSuspend = true,
+    initialState,
+    outputOptions,
+    perStep
+  } = {}) {
+    if (this.closeStreamAction && this.streamOutput) {
+      return this.streamOutput;
+    }
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream$1 = new web.ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = stream.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",
+          perStep
+        });
+        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 stream.WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream: stream$1
+    });
+    return this.streamOutput;
+  }
+  timeTravelStream({
+    inputData,
+    resumeData,
+    initialState,
+    step,
+    context,
+    nestedStepsContext,
+    requestContext,
+    // tracingContext,
+    tracingOptions,
+    outputOptions,
+    perStep
+  }) {
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream$1 = new web.ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = stream.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,
+          perStep
+        });
+        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(() => {
+          });
+        }
+      }
     });
-    return {
-      stream: readable,
-      getWorkflowState: () => this.executionResults
-    };
+    this.streamOutput = new stream.WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream: stream$1
+    });
+    return this.streamOutput;
+  }
+  /**
+   * Hydrates errors in a failed workflow result back to proper Error instances.
+   * This ensures error.cause chains and custom properties are preserved.
+   */
+  hydrateFailedResult(result) {
+    if (result.status === "failed") {
+      result.error = error.getErrorFromUnknown(result.error, { serializeStack: false });
+      if (result.steps) {
+        workflows.hydrateSerializedStepErrors(result.steps);
+      }
+    }
   }
 };
+
+// src/workflow.ts
 var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
   #mastra;
   inngest;
   function;
+  cronFunction;
   flowControlConfig;
+  cronConfig;
   constructor(params, inngest) {
-    const { concurrency, rateLimit, throttle, debounce, priority, ...workflowParams } = params;
+    const { concurrency, rateLimit, throttle, debounce, priority, cron, inputData, initialState, ...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;
+    if (cron) {
+      this.cronConfig = { cron, inputData, initialState };
+    }
   }
-  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 ?? {} });
-  }
-  async getWorkflowRunById(runId) {
-    const storage = this.#mastra?.getStorage();
-    if (!storage) {
-      this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
-      return this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null;
+    const workflowsStore = await storage.getStore("workflows");
+    if (!workflowsStore) {
+      return { runs: [], total: 0 };
     }
-    const run = await storage.getWorkflowRunById({ runId, workflowName: this.id });
-    return run ?? (this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null);
+    return workflowsStore.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
   __registerMastra(mastra) {
+    super.__registerMastra(mastra);
     this.#mastra = mastra;
     this.executionEngine.__registerMastra(mastra);
     const updateNested = (step) => {
@@ -312,18 +1291,10 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       }
     }
   }
-  /**
-   * @deprecated Use createRunAsync() instead.
-   * @throws {Error} Always throws an error directing users to use createRunAsync()
-   */
-  createRun(_options) {
-    throw new Error(
-      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = workflow.createRun();\n  After:  const run = await workflow.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
-    );
-  }
-  async createRunAsync(options) {
-    const runIdToUse = options?.runId || crypto.randomUUID();
-    const run = this.runs.get(runIdToUse) ?? new InngestRun(
+  async createRun(options) {
+    const runIdToUse = options?.runId || crypto$1.randomUUID();
+    const existingInMemoryRun = this.runs.get(runIdToUse);
+    const newRun = new InngestRun(
       {
         workflowId: this.id,
         runId: runIdToUse,
@@ -334,18 +1305,25 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
         mastra: this.#mastra,
         retryConfig: this.retryConfig,
         cleanup: () => this.runs.delete(runIdToUse),
-        workflowSteps: this.steps
+        workflowSteps: this.steps,
+        workflowEngineType: this.engineType,
+        validateInputs: this.options.validateInputs
       },
       this.inngest
     );
+    const run = existingInMemoryRun ?? newRun;
     this.runs.set(runIdToUse, run);
     const shouldPersistSnapshot = this.options.shouldPersistSnapshot({
       workflowStatus: run.workflowRunStatus,
       stepResults: {}
     });
-    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, false);
-    if (!workflowSnapshotInStorage && shouldPersistSnapshot) {
-      await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+    const existingStoredRun = await this.getWorkflowRunById(runIdToUse, {
+      withNestedWorkflows: false
+    });
+    const existsInStorage = existingStoredRun && !existingStoredRun.isFromInMemory;
+    if (!existsInStorage && shouldPersistSnapshot) {
+      const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
+      await workflowsStore?.persistWorkflowSnapshot({
         workflowName: this.id,
         runId: runIdToUse,
         resourceId: options?.resourceId,
@@ -355,19 +1333,43 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
           value: {},
           context: {},
           activePaths: [],
+          activeStepsPath: {},
           waitingPaths: {},
           serializedStepGraph: this.serializedStepGraph,
           suspendedPaths: {},
           resumeLabels: {},
           result: void 0,
           error: void 0,
-          // @ts-ignore
           timestamp: Date.now()
         }
       });
     }
     return run;
   }
+  //createCronFunction is only called if cronConfig.cron is defined.
+  createCronFunction() {
+    if (this.cronFunction) {
+      return this.cronFunction;
+    }
+    this.cronFunction = this.inngest.createFunction(
+      {
+        id: `workflow.${this.id}.cron`,
+        retries: 0,
+        cancelOn: [{ event: `cancel.workflow.${this.id}` }],
+        ...this.flowControlConfig
+      },
+      { cron: this.cronConfig?.cron ?? "" },
+      async () => {
+        const run = await this.createRun();
+        const result = await run.start({
+          inputData: this.cronConfig?.inputData,
+          initialState: this.cronConfig?.initialState
+        });
+        return { result, runId: run.runId };
+      }
+    );
+    return this.cronFunction;
+  }
   getFunction() {
     if (this.function) {
       return this.function;
@@ -375,62 +1377,128 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     this.function = this.inngest.createFunction(
       {
         id: `workflow.${this.id}`,
-        // @ts-ignore
-        retries: this.retryConfig?.attempts ?? 0,
+        retries: 0,
         cancelOn: [{ event: `cancel.workflow.${this.id}` }],
         // Spread flow control configuration
         ...this.flowControlConfig
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, initialState, runId, resourceId, resume, outputOptions } = event.data;
+        let {
+          inputData,
+          initialState,
+          runId,
+          resourceId,
+          resume,
+          outputOptions,
+          format,
+          timeTravel,
+          perStep,
+          tracingOptions
+        } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
-            return crypto.randomUUID();
+            return crypto$1.randomUUID();
           });
         }
-        const emitter = {
-          emit: async (event2, data) => {
-            if (!publish) {
-              return;
+        const pubsub = new InngestPubSub(this.inngest, this.id, publish);
+        const requestContext = new di.RequestContext(Object.entries(event.data.requestContext ?? {}));
+        const mastra = this.#mastra;
+        const tracingPolicy = this.options.tracingPolicy;
+        const workflowSpanData = await step.run(`workflow.${this.id}.span.start`, async () => {
+          const observability$1 = mastra?.observability?.getSelectedInstance({ requestContext });
+          if (!observability$1) return void 0;
+          const span = observability$1.startSpan({
+            type: observability.SpanType.WORKFLOW_RUN,
+            name: `workflow run: '${this.id}'`,
+            entityType: observability.EntityType.WORKFLOW_RUN,
+            entityId: this.id,
+            input: inputData,
+            metadata: {
+              resourceId,
+              runId
+            },
+            tracingPolicy,
+            tracingOptions,
+            requestContext
+          });
+          return span?.exportSpan();
+        });
+        const engine = new InngestExecutionEngine(this.#mastra, step, attempt, this.options);
+        let result;
+        try {
+          result = await engine.execute({
+            workflowId: this.id,
+            runId,
+            resourceId,
+            graph: this.executionGraph,
+            serializedStepGraph: this.serializedStepGraph,
+            input: inputData,
+            initialState,
+            pubsub,
+            retryConfig: this.retryConfig,
+            requestContext,
+            resume,
+            timeTravel,
+            perStep,
+            format,
+            abortController: new AbortController(),
+            // For Inngest, we don't pass workflowSpan - step spans use tracingIds instead
+            workflowSpan: void 0,
+            // Pass tracing IDs for durable span operations
+            tracingIds: workflowSpanData ? {
+              traceId: workflowSpanData.traceId,
+              workflowSpanId: workflowSpanData.id
+            } : void 0,
+            outputOptions,
+            outputWriter: async (chunk) => {
+              try {
+                await pubsub.publish(`workflow.events.v2.${runId}`, {
+                  type: "watch",
+                  runId,
+                  data: chunk
+                });
+              } catch (err) {
+                this.logger.debug?.("Failed to publish watch event:", err);
+              }
             }
-            try {
-              await publish({
-                channel: `workflow:${this.id}:${runId}`,
-                topic: event2,
-                data
-              });
-            } catch (err) {
-              this.logger.error("Error emitting event: " + (err?.stack ?? err?.message ?? err));
+          });
+        } catch (error) {
+          throw error;
+        }
+        await step.run(`workflow.${this.id}.finalize`, async () => {
+          if (result.status !== "paused") {
+            await engine.invokeLifecycleCallbacksInternal({
+              status: result.status,
+              result: "result" in result ? result.result : void 0,
+              error: "error" in result ? result.error : void 0,
+              steps: result.steps,
+              tripwire: "tripwire" in result ? result.tripwire : void 0,
+              runId,
+              workflowId: this.id,
+              resourceId,
+              input: inputData,
+              requestContext,
+              state: result.state ?? initialState ?? {}
+            });
+          }
+          if (workflowSpanData) {
+            const observability = mastra?.observability?.getSelectedInstance({ requestContext });
+            if (observability) {
+              const workflowSpan = observability.rebuildSpan(workflowSpanData);
+              if (result.status === "failed") {
+                workflowSpan.error({
+                  error: result.error instanceof Error ? result.error : new Error(String(result.error)),
+                  attributes: { status: "failed" }
+                });
+              } else {
+                workflowSpan.end({
+                  output: result.status === "success" ? result.result : void 0,
+                  attributes: { status: result.status }
+                });
+              }
             }
-          },
-          on: (_event, _callback) => {
-          },
-          off: (_event, _callback) => {
-          },
-          once: (_event, _callback) => {
           }
-        };
-        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 di.RuntimeContext(),
-          // TODO
-          resume,
-          abortController: new AbortController(),
-          currentSpan: void 0,
-          // TODO: Pass actual parent AI span from workflow execution context
-          outputOptions
-        });
-        await step.run(`workflow.${this.id}.finalize`, async () => {
           if (result.status === "failed") {
             throw new inngest.NonRetriableError(`Workflow failed`, {
               cause: result
@@ -457,1089 +1525,731 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     });
   }
   getFunctions() {
-    return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
+    return [
+      this.getFunction(),
+      ...this.cronConfig?.cron ? [this.createCronFunction()] : [],
+      ...this.getNestedFunctions(this.executionGraph.steps)
+    ];
   }
 };
-function isAgent(params) {
-  return params?.component === "AGENT";
+function prepareServeOptions({ 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 {
+    ...registerOptions,
+    client: inngest,
+    functions: [...workflowFunctions, ...userFunctions]
+  };
+}
+function createServe(adapter) {
+  return (options) => {
+    const serveOptions = prepareServeOptions(options);
+    return adapter(serveOptions);
+  };
+}
+var serve = createServe(hono.serve);
+
+// src/types.ts
+var _compatibilityCheck = true;
+
+// src/index.ts
+function isInngestWorkflow(input) {
+  return input instanceof InngestWorkflow;
+}
+function isAgent(input) {
+  return input instanceof agent.Agent;
+}
+function isToolStep(input) {
+  return input instanceof tools.Tool;
 }
-function isTool(params) {
-  return params instanceof tools.Tool;
+function isStepParams(input) {
+  return input !== null && typeof input === "object" && "id" in input && "execute" in input && !(input instanceof agent.Agent) && !(input instanceof tools.Tool) && !(input instanceof InngestWorkflow);
 }
-function createStep(params) {
+function isProcessor(obj) {
+  return obj !== null && typeof obj === "object" && "id" in obj && typeof obj.id === "string" && !(obj instanceof agent.Agent) && !(obj instanceof tools.Tool) && !(obj instanceof InngestWorkflow) && (typeof obj.processInput === "function" || typeof obj.processInputStep === "function" || typeof obj.processOutputStream === "function" || typeof obj.processOutputResult === "function" || typeof obj.processOutputStep === "function");
+}
+function createStep(params, agentOrToolOptions) {
+  if (isInngestWorkflow(params)) {
+    return params;
+  }
   if (isAgent(params)) {
-    return {
-      id: params.name,
-      description: params.getDescription(),
-      // @ts-ignore
-      inputSchema: zod.z.object({
-        prompt: zod.z.string()
-      }),
-      // @ts-ignore
-      outputSchema: zod.z.object({
-        text: zod.z.string()
-      }),
-      execute: async ({ inputData, [_constants.EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort, tracingContext }) => {
-        let streamPromise = {};
-        streamPromise.promise = new Promise((resolve, reject) => {
-          streamPromise.resolve = resolve;
-          streamPromise.reject = reject;
-        });
-        const toolData = {
-          name: params.name,
-          args: inputData
-        };
-        if ((await params.getLLM()).getModel().specificationVersion === `v2`) {
-          const { fullStream } = await params.stream(inputData.prompt, {
-            runtimeContext,
-            tracingContext,
-            onFinish: (result) => {
-              streamPromise.resolve(result.text);
-            },
-            abortSignal
-          });
-          if (abortSignal.aborted) {
-            return abort();
-          }
-          await emitter.emit("watch-v2", {
-            type: "tool-call-streaming-start",
-            ...toolData ?? {}
-          });
-          for await (const chunk of fullStream) {
-            if (chunk.type === "text-delta") {
-              await emitter.emit("watch-v2", {
-                type: "tool-call-delta",
-                ...toolData ?? {},
-                argsTextDelta: chunk.payload.text
-              });
-            }
-          }
-        } else {
-          const { fullStream } = await params.streamLegacy(inputData.prompt, {
-            runtimeContext,
-            tracingContext,
-            onFinish: (result) => {
-              streamPromise.resolve(result.text);
-            },
-            abortSignal
-          });
-          if (abortSignal.aborted) {
-            return abort();
-          }
-          await emitter.emit("watch-v2", {
-            type: "tool-call-streaming-start",
-            ...toolData ?? {}
-          });
-          for await (const chunk of fullStream) {
-            if (chunk.type === "text-delta") {
-              await emitter.emit("watch-v2", {
-                type: "tool-call-delta",
-                ...toolData ?? {},
-                argsTextDelta: chunk.textDelta
-              });
-            }
-          }
-        }
-        await emitter.emit("watch-v2", {
-          type: "tool-call-streaming-finish",
-          ...toolData ?? {}
-        });
-        return {
-          text: await streamPromise.promise
-        };
-      },
-      component: params.component
-    };
+    return createStepFromAgent(params, agentOrToolOptions);
   }
-  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,
-      description: params.description,
-      inputSchema: params.inputSchema,
-      outputSchema: params.outputSchema,
-      execute: async ({ inputData, mastra, runtimeContext, tracingContext, suspend, resumeData }) => {
-        return params.execute({
-          context: inputData,
-          mastra: aiTracing.wrapMastra(mastra, tracingContext),
-          runtimeContext,
-          tracingContext,
-          suspend,
-          resumeData
-        });
-      },
-      component: "TOOL"
-    };
+  if (isToolStep(params)) {
+    return createStepFromTool(params, agentOrToolOptions);
+  }
+  if (isStepParams(params)) {
+    return createStepFromParams(params);
   }
+  if (isProcessor(params)) {
+    return createStepFromProcessor(params);
+  }
+  throw new Error("Invalid input: expected StepParams, Agent, ToolStep, Processor, or InngestWorkflow");
+}
+function createStepFromParams(params) {
   return {
     id: params.id,
     description: params.description,
     inputSchema: params.inputSchema,
+    stateSchema: params.stateSchema,
     outputSchema: params.outputSchema,
     resumeSchema: params.resumeSchema,
     suspendSchema: params.suspendSchema,
-    execute: params.execute
+    scorers: params.scorers,
+    retries: params.retries,
+    execute: params.execute.bind(params)
   };
 }
-function init(inngest) {
+function createStepFromAgent(params, agentOrToolOptions) {
+  const options = agentOrToolOptions ?? {};
+  const outputSchema = options?.structuredOutput?.schema ?? zod.z.object({ text: zod.z.string() });
+  const { retries, scorers, ...agentOptions } = options ?? {};
   return {
-    createWorkflow(params) {
-      return new InngestWorkflow(
-        params,
-        inngest
-      );
-    },
-    createStep,
-    cloneStep(step, opts) {
-      return {
-        id: opts.id,
-        description: step.description,
-        inputSchema: step.inputSchema,
-        outputSchema: step.outputSchema,
-        resumeSchema: step.resumeSchema,
-        suspendSchema: step.suspendSchema,
-        stateSchema: step.stateSchema,
-        execute: step.execute,
-        component: step.component
-      };
-    },
-    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 workflows.DefaultExecutionEngine {
-  inngestStep;
-  inngestAttempts;
-  constructor(mastra, inngestStep, inngestAttempts = 0, options) {
-    super({ mastra, options });
-    this.inngestStep = inngestStep;
-    this.inngestAttempts = inngestAttempts;
-  }
-  async execute(params) {
-    await params.emitter.emit("watch-v2", {
-      type: "workflow-start",
-      payload: { runId: params.runId }
-    });
-    const result = await super.execute(params);
-    await params.emitter.emit("watch-v2", {
-      type: "workflow-finish",
-      payload: { runId: params.runId }
-    });
-    return result;
-  }
-  async fmtReturnValue(executionSpan, emitter, stepResults, lastOutput, error) {
-    const base = {
-      status: lastOutput.status,
-      steps: stepResults
-    };
-    if (lastOutput.status === "success") {
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: lastOutput.output
-          }
-        },
-        eventTimestamp: Date.now()
-      });
-      base.result = lastOutput.output;
-    } else if (lastOutput.status === "failed") {
-      base.error = error instanceof Error ? error?.stack ?? error.message : lastOutput?.error instanceof Error ? lastOutput.error.message : lastOutput.error ?? error ?? "Unknown error";
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: null,
-            error: base.error
-          }
-        },
-        eventTimestamp: Date.now()
-      });
-    } else if (lastOutput.status === "suspended") {
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: null,
-            error: null
-          }
-        },
-        eventTimestamp: Date.now()
-      });
-      const suspendedStepIds = Object.entries(stepResults).flatMap(([stepId, stepResult]) => {
-        if (stepResult?.status === "suspended") {
-          const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
-          return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
-        }
-        return [];
+    id: params.name,
+    description: params.getDescription(),
+    inputSchema: zod.z.object({
+      prompt: zod.z.string()
+    }),
+    outputSchema,
+    retries,
+    scorers,
+    execute: async ({
+      inputData,
+      runId,
+      [_constants.PUBSUB_SYMBOL]: pubsub,
+      [_constants.STREAM_FORMAT_SYMBOL]: streamFormat,
+      requestContext,
+      tracingContext,
+      abortSignal,
+      abort,
+      writer
+    }) => {
+      let streamPromise = {};
+      streamPromise.promise = new Promise((resolve, reject) => {
+        streamPromise.resolve = resolve;
+        streamPromise.reject = reject;
       });
-      base.suspended = suspendedStepIds;
-    }
-    executionSpan?.end();
-    return base;
-  }
-  // 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,
-    executionContext,
-    writableStream,
-    tracingContext
-  }) {
-    let { duration, fn } = entry;
-    const sleepSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: aiTracing.AISpanType.WORKFLOW_SLEEP,
-      name: `sleep: ${duration ? `${duration}ms` : "dynamic"}`,
-      attributes: {
-        durationMs: duration,
-        sleepType: fn ? "dynamic" : "fixed"
-      },
-      tracingPolicy: this.options?.tracingPolicy
-    });
-    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,
-          state: executionContext.state,
-          setState: (state) => {
-            executionContext.state = state;
-          },
-          runCount: -1,
-          tracingContext: {
-            currentSpan: sleepSpan
-          },
-          getInitData: () => stepResults?.input,
-          getStepResult: workflows.getStepResult.bind(this, stepResults),
-          // TODO: this function shouldn't have suspend probably?
-          suspend: async (_suspendPayload) => {
-          },
-          bail: () => {
+      let structuredResult = null;
+      const toolData = {
+        name: params.name,
+        args: inputData
+      };
+      let stream;
+      if ((await params.getModel()).specificationVersion === "v1") {
+        const { fullStream } = await params.streamLegacy(inputData.prompt, {
+          ...agentOptions ?? {},
+          requestContext,
+          tracingContext,
+          onFinish: (result) => {
+            const resultWithObject = result;
+            if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
+              structuredResult = resultWithObject.object;
+            }
+            streamPromise.resolve(result.text);
+            void agentOptions?.onFinish?.(result);
           },
-          abort: () => {
-            abortController?.abort();
+          abortSignal
+        });
+        stream = fullStream;
+      } else {
+        const modelOutput = await params.stream(inputData.prompt, {
+          ...agentOptions ?? {},
+          requestContext,
+          tracingContext,
+          onFinish: (result) => {
+            const resultWithObject = result;
+            if (agentOptions?.structuredOutput?.schema && resultWithObject.object) {
+              structuredResult = resultWithObject.object;
+            }
+            streamPromise.resolve(result.text);
+            void agentOptions?.onFinish?.(result);
           },
-          [_constants.EMITTER_SYMBOL]: emitter,
-          // TODO: add streamVNext support
-          [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
-          engine: { step: this.inngestStep },
-          abortSignal: abortController?.signal,
-          writer: new tools.ToolStream(
-            {
-              prefix: "workflow-step",
-              callId: stepCallId,
-              name: "sleep",
-              runId
-            },
-            writableStream
-          )
+          abortSignal
         });
-      });
-      sleepSpan?.update({
-        attributes: {
-          durationMs: duration
+        stream = modelOutput.fullStream;
+      }
+      if (streamFormat === "legacy") {
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
+          runId,
+          data: { type: "tool-call-streaming-start", ...toolData ?? {} }
+        });
+        for await (const chunk of stream) {
+          if (chunk.type === "text-delta") {
+            await pubsub.publish(`workflow.events.v2.${runId}`, {
+              type: "watch",
+              runId,
+              data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
+            });
+          }
         }
-      });
-    }
-    try {
-      await this.inngestStep.sleep(entry.id, !duration || duration < 0 ? 0 : duration);
-      sleepSpan?.end();
-    } catch (e) {
-      sleepSpan?.error({ error: e });
-      throw e;
-    }
-  }
-  async executeSleepUntil({
-    workflowId,
-    runId,
-    entry,
-    prevOutput,
-    stepResults,
-    emitter,
-    abortController,
-    runtimeContext,
-    executionContext,
-    writableStream,
-    tracingContext
-  }) {
-    let { date, fn } = entry;
-    const sleepUntilSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: aiTracing.AISpanType.WORKFLOW_SLEEP,
-      name: `sleepUntil: ${date ? date.toISOString() : "dynamic"}`,
-      attributes: {
-        untilDate: date,
-        durationMs: date ? Math.max(0, date.getTime() - Date.now()) : void 0,
-        sleepType: fn ? "dynamic" : "fixed"
-      },
-      tracingPolicy: this.options?.tracingPolicy
-    });
-    if (fn) {
-      date = await this.inngestStep.run(`workflow.${workflowId}.sleepUntil.${entry.id}`, async () => {
-        const stepCallId = crypto.randomUUID();
-        return await fn({
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
           runId,
-          workflowId,
-          mastra: this.mastra,
-          runtimeContext,
-          inputData: prevOutput,
-          state: executionContext.state,
-          setState: (state) => {
-            executionContext.state = state;
-          },
-          runCount: -1,
-          tracingContext: {
-            currentSpan: sleepUntilSpan
-          },
-          getInitData: () => stepResults?.input,
-          getStepResult: workflows.getStepResult.bind(this, stepResults),
-          // TODO: this function shouldn't have suspend probably?
-          suspend: async (_suspendPayload) => {
-          },
-          bail: () => {
-          },
-          abort: () => {
-            abortController?.abort();
-          },
-          [_constants.EMITTER_SYMBOL]: emitter,
-          [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
-          // TODO: add streamVNext support
-          engine: { step: this.inngestStep },
-          abortSignal: abortController?.signal,
-          writer: new tools.ToolStream(
-            {
-              prefix: "workflow-step",
-              callId: stepCallId,
-              name: "sleep",
-              runId
-            },
-            writableStream
-          )
+          data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
         });
-      });
-      if (date && !(date instanceof Date)) {
-        date = new Date(date);
+      } else {
+        for await (const chunk of stream) {
+          await writer.write(chunk);
+        }
       }
-      const time = !date ? 0 : date.getTime() - Date.now();
-      sleepUntilSpan?.update({
-        attributes: {
-          durationMs: Math.max(0, time)
+      if (abortSignal.aborted) {
+        return abort();
+      }
+      if (structuredResult !== null) {
+        return structuredResult;
+      }
+      return {
+        text: await streamPromise.promise
+      };
+    },
+    component: params.component
+  };
+}
+function createStepFromTool(params, agentOrToolOptions) {
+  const toolOpts = agentOrToolOptions;
+  if (!params.inputSchema || !params.outputSchema) {
+    throw new Error("Tool must have input and output schemas defined");
+  }
+  return {
+    id: params.id,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    retries: toolOpts?.retries,
+    scorers: toolOpts?.scorers,
+    execute: async ({
+      inputData,
+      mastra,
+      requestContext,
+      tracingContext,
+      suspend,
+      resumeData,
+      runId,
+      workflowId,
+      state,
+      setState
+    }) => {
+      const toolContext = {
+        mastra,
+        requestContext,
+        tracingContext,
+        workflow: {
+          runId,
+          resumeData,
+          suspend,
+          workflowId,
+          state,
+          setState
         }
-      });
-    }
-    if (!(date instanceof Date)) {
-      sleepUntilSpan?.end();
-      return;
+      };
+      return params.execute(inputData, toolContext);
+    },
+    component: "TOOL"
+  };
+}
+function createStepFromProcessor(processor) {
+  const getProcessorEntityType = (phase) => {
+    switch (phase) {
+      case "input":
+        return observability.EntityType.INPUT_PROCESSOR;
+      case "inputStep":
+        return observability.EntityType.INPUT_STEP_PROCESSOR;
+      case "outputStream":
+      case "outputResult":
+        return observability.EntityType.OUTPUT_PROCESSOR;
+      case "outputStep":
+        return observability.EntityType.OUTPUT_STEP_PROCESSOR;
+      default:
+        return observability.EntityType.OUTPUT_PROCESSOR;
     }
-    try {
-      await this.inngestStep.sleepUntil(entry.id, date);
-      sleepUntilSpan?.end();
-    } catch (e) {
-      sleepUntilSpan?.error({ error: e });
-      throw e;
+  };
+  const getSpanNamePrefix = (phase) => {
+    switch (phase) {
+      case "input":
+        return "input processor";
+      case "inputStep":
+        return "input step processor";
+      case "outputStream":
+        return "output stream processor";
+      case "outputResult":
+        return "output processor";
+      case "outputStep":
+        return "output step processor";
+      default:
+        return "processor";
     }
-  }
-  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";
+  };
+  const hasPhaseMethod = (phase) => {
+    switch (phase) {
+      case "input":
+        return !!processor.processInput;
+      case "inputStep":
+        return !!processor.processInputStep;
+      case "outputStream":
+        return !!processor.processOutputStream;
+      case "outputResult":
+        return !!processor.processOutputResult;
+      case "outputStep":
+        return !!processor.processOutputStep;
+      default:
+        return false;
     }
-    return eventData?.data;
-  }
-  async executeStep({
-    step,
-    stepResults,
-    executionContext,
-    resume,
-    prevOutput,
-    emitter,
-    abortController,
-    runtimeContext,
-    tracingContext,
-    writableStream,
-    disableScorers
-  }) {
-    const stepAISpan = tracingContext?.currentSpan?.createChildSpan({
-      name: `workflow step: '${step.id}'`,
-      type: aiTracing.AISpanType.WORKFLOW_STEP,
-      input: prevOutput,
-      attributes: {
-        stepId: step.id
-      },
-      tracingPolicy: this.options?.tracingPolicy
-    });
-    const { inputData, validationError } = await workflows.validateStepInput({
-      prevOutput,
-      step,
-      validateInputs: this.options?.validateInputs ?? false
-    });
-    const startedAt = await this.inngestStep.run(
-      `workflow.${executionContext.workflowId}.run.${executionContext.runId}.step.${step.id}.running_ev`,
-      async () => {
-        const startedAt2 = Date.now();
-        await emitter.emit("watch", {
-          type: "watch",
-          payload: {
-            currentStep: {
-              id: step.id,
-              status: "running"
-            },
-            workflowState: {
-              status: "running",
-              steps: {
-                ...stepResults,
-                [step.id]: {
-                  status: "running"
-                }
-              },
-              result: null,
-              error: null
-            }
-          },
-          eventTimestamp: Date.now()
-        });
-        await emitter.emit("watch-v2", {
-          type: "workflow-step-start",
-          payload: {
-            id: step.id,
-            status: "running",
-            payload: inputData,
-            startedAt: startedAt2
-          }
-        });
-        return startedAt2;
+  };
+  return {
+    id: `processor:${processor.id}`,
+    description: processor.name ?? `Processor ${processor.id}`,
+    inputSchema: processors.ProcessorStepSchema,
+    outputSchema: processors.ProcessorStepOutputSchema,
+    execute: async ({ inputData, requestContext, tracingContext }) => {
+      const input = inputData;
+      const {
+        phase,
+        messages,
+        messageList,
+        stepNumber,
+        systemMessages,
+        part,
+        streamParts,
+        state,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps
+      } = input;
+      const abort = (reason, options) => {
+        throw new agent.TripWire(reason || `Tripwire triggered by ${processor.id}`, options, processor.id);
+      };
+      if (!hasPhaseMethod(phase)) {
+        return input;
       }
-    );
-    if (step instanceof InngestWorkflow) {
-      const isResume = !!resume?.steps?.length;
-      let result;
-      let runId;
-      try {
-        if (isResume) {
-          runId = stepResults[resume?.steps?.[0]]?.suspendPayload?.__workflow_meta?.runId ?? crypto.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,
-                // @ts-ignore
-                resumePath: snapshot?.suspendedPaths?.[resume.steps?.[1]]
-              },
-              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;
+      const currentSpan = tracingContext?.currentSpan;
+      const parentSpan = phase === "inputStep" || phase === "outputStep" ? currentSpan?.findParent(observability.SpanType.MODEL_STEP) || currentSpan : currentSpan?.findParent(observability.SpanType.AGENT_RUN) || currentSpan;
+      const processorSpan = phase !== "outputStream" ? parentSpan?.createChildSpan({
+        type: observability.SpanType.PROCESSOR_RUN,
+        name: `${getSpanNamePrefix(phase)}: ${processor.id}`,
+        entityType: getProcessorEntityType(phase),
+        entityId: processor.id,
+        entityName: processor.name ?? processor.id,
+        input: { phase, messageCount: messages?.length },
+        attributes: {
+          processorExecutor: "workflow",
+          // Read processorIndex from processor (set in combineProcessorsIntoWorkflow)
+          processorIndex: processor.processorIndex
         }
-      } catch (e) {
-        const errorCause = e?.cause;
-        if (errorCause && typeof errorCause === "object") {
-          result = errorCause;
-          runId = errorCause.runId || crypto.randomUUID();
-        } else {
-          runId = crypto.randomUUID();
-          result = {
-            status: "failed",
-            error: e instanceof Error ? e : new Error(String(e)),
-            steps: {},
-            input: inputData
-          };
+      }) : void 0;
+      const processorTracingContext = processorSpan ? { currentSpan: processorSpan } : tracingContext;
+      const baseContext = {
+        abort,
+        retryCount: retryCount ?? 0,
+        requestContext,
+        tracingContext: processorTracingContext
+      };
+      const passThrough = {
+        phase,
+        // Auto-create MessageList from messages if not provided
+        // This enables running processor workflows from the UI where messageList can't be serialized
+        messageList: messageList ?? (Array.isArray(messages) ? new agent.MessageList().add(messages, "input").addSystem(systemMessages ?? []) : void 0),
+        stepNumber,
+        systemMessages,
+        streamParts,
+        state,
+        finishReason,
+        toolCalls,
+        text,
+        retryCount,
+        // inputStep phase fields for model/tools configuration
+        model,
+        tools,
+        toolChoice,
+        activeTools,
+        providerOptions,
+        modelSettings,
+        structuredOutput,
+        steps
+      };
+      const executePhaseWithSpan = async (fn) => {
+        try {
+          const result = await fn();
+          processorSpan?.end({ output: result });
+          return result;
+        } catch (error) {
+          if (error instanceof agent.TripWire) {
+            processorSpan?.end({ output: { tripwire: error.message } });
+          } else {
+            processorSpan?.error({ error, endSpan: true });
+          }
+          throw error;
         }
-      }
-      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: "workflow-step-result",
-              payload: {
-                id: step.id,
-                status: "failed",
-                error: result?.error,
-                payload: prevOutput
+      };
+      return executePhaseWithSpan(async () => {
+        switch (phase) {
+          case "input": {
+            if (processor.processInput) {
+              if (!passThrough.messageList) {
+                throw new error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.MASTRA_WORKFLOW,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processInput phase`
+                });
               }
-            });
-            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?.suspendPayload?.__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,
-                    suspendPayload: {
-                      ...stepResult?.suspendPayload,
-                      __workflow_meta: { runId, path: suspendPath }
-                    }
-                  },
-                  workflowState: {
-                    status: "running",
-                    steps: stepResults,
-                    result: null,
-                    error: null
-                  }
-                },
-                eventTimestamp: Date.now()
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processInput({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                systemMessages: systemMessages ?? []
               });
-              await emitter.emit("watch-v2", {
-                type: "workflow-step-suspended",
-                payload: {
-                  id: step.id,
-                  status: "suspended"
+              if (result instanceof agent.MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new error.MastraError({
+                    category: error.ErrorCategory.USER,
+                    domain: error.ErrorDomain.MASTRA_WORKFLOW,
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
+                  });
                 }
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "input"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
+              }
+              return { ...passThrough, messages };
+            }
+            return { ...passThrough, messages };
+          }
+          case "inputStep": {
+            if (processor.processInputStep) {
+              if (!passThrough.messageList) {
+                throw new error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.MASTRA_WORKFLOW,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processInputStep phase`
+                });
+              }
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processInputStep({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                stepNumber: stepNumber ?? 0,
+                systemMessages: systemMessages ?? [],
+                // Pass model/tools configuration fields - types match ProcessInputStepArgs
+                model,
+                tools,
+                toolChoice,
+                activeTools,
+                providerOptions,
+                modelSettings,
+                structuredOutput,
+                steps: steps ?? []
               });
-              return {
-                executionContext,
-                result: {
-                  status: "suspended",
-                  payload: stepResult.payload,
-                  suspendPayload: {
-                    ...stepResult?.suspendPayload,
-                    __workflow_meta: { runId, path: suspendPath }
+              const validatedResult = await processors.ProcessorRunner.validateAndFormatProcessInputStepResult(result, {
+                messageList: passThrough.messageList,
+                processor,
+                stepNumber: stepNumber ?? 0
+              });
+              if (validatedResult.messages) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  validatedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check
+                );
+              }
+              if (validatedResult.systemMessages) {
+                passThrough.messageList.replaceAllSystemMessages(validatedResult.systemMessages);
+              }
+              return { ...passThrough, messages, ...validatedResult };
+            }
+            return { ...passThrough, messages };
+          }
+          case "outputStream": {
+            if (processor.processOutputStream) {
+              const spanKey = `__outputStreamSpan_${processor.id}`;
+              const mutableState = state ?? {};
+              let processorSpan2 = mutableState[spanKey];
+              if (!processorSpan2 && parentSpan) {
+                processorSpan2 = parentSpan.createChildSpan({
+                  type: observability.SpanType.PROCESSOR_RUN,
+                  name: `output stream processor: ${processor.id}`,
+                  entityType: observability.EntityType.OUTPUT_PROCESSOR,
+                  entityId: processor.id,
+                  entityName: processor.name ?? processor.id,
+                  input: { phase, streamParts: [] },
+                  attributes: {
+                    processorExecutor: "workflow",
+                    processorIndex: processor.processorIndex
                   }
+                });
+                mutableState[spanKey] = processorSpan2;
+              }
+              if (processorSpan2) {
+                processorSpan2.input = {
+                  phase,
+                  streamParts: streamParts ?? [],
+                  totalChunks: (streamParts ?? []).length
+                };
+              }
+              const processorTracingContext2 = processorSpan2 ? { currentSpan: processorSpan2 } : baseContext.tracingContext;
+              let result;
+              try {
+                result = await processor.processOutputStream({
+                  ...baseContext,
+                  tracingContext: processorTracingContext2,
+                  part,
+                  streamParts: streamParts ?? [],
+                  state: mutableState,
+                  messageList: passThrough.messageList
+                  // Optional for stream processing
+                });
+                if (part && part.type === "finish") {
+                  processorSpan2?.end({ output: result });
+                  delete mutableState[spanKey];
                 }
-              };
-            }
-            await emitter.emit("watch", {
-              type: "watch",
-              payload: {
-                currentStep: {
-                  id: step.id,
-                  status: "suspended",
-                  payload: {}
-                },
-                workflowState: {
-                  status: "running",
-                  steps: stepResults,
-                  result: null,
-                  error: null
+              } catch (error) {
+                if (error instanceof agent.TripWire) {
+                  processorSpan2?.end({ output: { tripwire: error.message } });
+                } else {
+                  processorSpan2?.error({ error, endSpan: true });
                 }
-              },
-              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
+                delete mutableState[spanKey];
+                throw error;
               }
-            },
-            eventTimestamp: Date.now()
-          });
-          await emitter.emit("watch-v2", {
-            type: "workflow-step-result",
-            payload: {
-              id: step.id,
-              status: "success",
-              output: result?.result
-            }
-          });
-          await emitter.emit("watch-v2", {
-            type: "workflow-step-finish",
-            payload: {
-              id: step.id,
-              metadata: {}
+              return { ...passThrough, state: mutableState, part: result };
             }
-          });
-          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
-      };
-    }
-    let stepRes;
-    try {
-      stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
-        let execResults;
-        let suspended;
-        let bailed;
-        try {
-          if (validationError) {
-            throw validationError;
+            return { ...passThrough, part };
           }
-          const result = await step.execute({
-            runId: executionContext.runId,
-            mastra: this.mastra,
-            runtimeContext,
-            writableStream,
-            state: executionContext?.state ?? {},
-            setState: (state) => {
-              executionContext.state = state;
-            },
-            inputData,
-            resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
-            tracingContext: {
-              currentSpan: stepAISpan
-            },
-            getInitData: () => stepResults?.input,
-            getStepResult: workflows.getStepResult.bind(this, stepResults),
-            suspend: async (suspendPayload, suspendOptions) => {
-              executionContext.suspendedPaths[step.id] = executionContext.executionPath;
-              if (suspendOptions?.resumeLabel) {
-                executionContext.resumeLabels[suspendOptions.resumeLabel] = step.id;
+          case "outputResult": {
+            if (processor.processOutputResult) {
+              if (!passThrough.messageList) {
+                throw new error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.MASTRA_WORKFLOW,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processOutputResult phase`
+                });
               }
-              suspended = { payload: suspendPayload };
-            },
-            bail: (result2) => {
-              bailed = { payload: result2 };
-            },
-            resume: {
-              steps: resume?.steps?.slice(1) || [],
-              resumePayload: resume?.resumePayload,
-              // @ts-ignore
-              runId: stepResults[step.id]?.suspendPayload?.__workflow_meta?.runId
-            },
-            [_constants.EMITTER_SYMBOL]: emitter,
-            engine: {
-              step: this.inngestStep
-            },
-            abortSignal: abortController.signal
-          });
-          const endedAt = Date.now();
-          execResults = {
-            status: "success",
-            output: result,
-            startedAt,
-            endedAt,
-            payload: inputData,
-            resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
-            resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
-          };
-        } catch (e) {
-          const stepFailure = {
-            status: "failed",
-            payload: inputData,
-            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
-          };
-          execResults = stepFailure;
-          const fallbackErrorMessage = `Step ${step.id} failed`;
-          stepAISpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
-          throw new inngest.RetryAfterError(execResults.error ?? fallbackErrorMessage, executionContext.retryConfig.delay, {
-            cause: execResults
-          });
-        }
-        if (suspended) {
-          execResults = {
-            status: "suspended",
-            suspendPayload: suspended.payload,
-            payload: inputData,
-            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: inputData,
-            endedAt: Date.now(),
-            startedAt
-          };
-        }
-        await emitter.emit("watch", {
-          type: "watch",
-          payload: {
-            currentStep: {
-              id: step.id,
-              ...execResults
-            },
-            workflowState: {
-              status: "running",
-              steps: { ...stepResults, [step.id]: execResults },
-              result: null,
-              error: null
-            }
-          },
-          eventTimestamp: Date.now()
-        });
-        if (execResults.status === "suspended") {
-          await emitter.emit("watch-v2", {
-            type: "workflow-step-suspended",
-            payload: {
-              id: step.id,
-              ...execResults
-            }
-          });
-        } else {
-          await emitter.emit("watch-v2", {
-            type: "workflow-step-result",
-            payload: {
-              id: step.id,
-              ...execResults
-            }
-          });
-          await emitter.emit("watch-v2", {
-            type: "workflow-step-finish",
-            payload: {
-              id: step.id,
-              metadata: {}
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processOutputResult({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList
+              });
+              if (result instanceof agent.MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new error.MastraError({
+                    category: error.ErrorCategory.USER,
+                    domain: error.ErrorDomain.MASTRA_WORKFLOW,
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
+                  });
+                }
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
+              }
+              return { ...passThrough, messages };
             }
-          });
-        }
-        stepAISpan?.end({ output: execResults });
-        return { result: execResults, executionContext, stepResults };
-      });
-    } catch (e) {
-      const stepFailure = e instanceof Error ? e?.cause : {
-        status: "failed",
-        error: e instanceof Error ? e.message : String(e),
-        payload: inputData,
-        startedAt,
-        endedAt: Date.now()
-      };
-      stepRes = {
-        result: stepFailure,
-        executionContext,
-        stepResults: {
-          ...stepResults,
-          [step.id]: stepFailure
-        }
-      };
-    }
-    if (disableScorers !== false && stepRes.result.status === "success") {
-      await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}.score`, async () => {
-        if (step.scorers) {
-          await this.runScorers({
-            scorers: step.scorers,
-            runId: executionContext.runId,
-            input: inputData,
-            output: stepRes.result,
-            workflowId: executionContext.workflowId,
-            stepId: step.id,
-            runtimeContext,
-            disableScorers,
-            tracingContext: { currentSpan: stepAISpan }
-          });
-        }
-      });
-    }
-    Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
-    Object.assign(stepResults, stepRes.stepResults);
-    executionContext.state = stepRes.executionContext.state;
-    return stepRes.result;
-  }
-  async persistStepUpdate({
-    workflowId,
-    runId,
-    stepResults,
-    resourceId,
-    executionContext,
-    serializedStepGraph,
-    workflowStatus,
-    result,
-    error
-  }) {
-    await this.inngestStep.run(
-      `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
-      async () => {
-        const shouldPersistSnapshot = this.options.shouldPersistSnapshot({ stepResults, workflowStatus });
-        if (!shouldPersistSnapshot) {
-          return;
-        }
-        await this.mastra?.getStorage()?.persistWorkflowSnapshot({
-          workflowName: workflowId,
-          runId,
-          resourceId,
-          snapshot: {
-            runId,
-            value: executionContext.state,
-            context: stepResults,
-            activePaths: [],
-            suspendedPaths: executionContext.suspendedPaths,
-            resumeLabels: executionContext.resumeLabels,
-            waitingPaths: {},
-            serializedStepGraph,
-            status: workflowStatus,
-            result,
-            error,
-            // @ts-ignore
-            timestamp: Date.now()
+            return { ...passThrough, messages };
           }
-        });
-      }
-    );
-  }
-  async executeConditional({
-    workflowId,
-    runId,
-    entry,
-    prevOutput,
-    prevStep,
-    stepResults,
-    serializedStepGraph,
-    resume,
-    executionContext,
-    emitter,
-    abortController,
-    runtimeContext,
-    writableStream,
-    disableScorers,
-    tracingContext
-  }) {
-    const conditionalSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: aiTracing.AISpanType.WORKFLOW_CONDITIONAL,
-      name: `conditional: '${entry.conditions.length} conditions'`,
-      input: prevOutput,
-      attributes: {
-        conditionCount: entry.conditions.length
-      },
-      tracingPolicy: this.options?.tracingPolicy
-    });
-    let execResults;
-    const truthyIndexes = (await Promise.all(
-      entry.conditions.map(
-        (cond, index) => this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
-          const evalSpan = conditionalSpan?.createChildSpan({
-            type: aiTracing.AISpanType.WORKFLOW_CONDITIONAL_EVAL,
-            name: `condition: '${index}'`,
-            input: prevOutput,
-            attributes: {
-              conditionIndex: index
-            },
-            tracingPolicy: this.options?.tracingPolicy
-          });
-          try {
-            const result = await cond({
-              runId,
-              workflowId,
-              mastra: this.mastra,
-              runtimeContext,
-              runCount: -1,
-              inputData: prevOutput,
-              state: executionContext.state,
-              setState: (state) => {
-                executionContext.state = state;
-              },
-              tracingContext: {
-                currentSpan: evalSpan
-              },
-              getInitData: () => stepResults?.input,
-              getStepResult: workflows.getStepResult.bind(this, stepResults),
-              // TODO: this function shouldn't have suspend probably?
-              suspend: async (_suspendPayload) => {
-              },
-              bail: () => {
-              },
-              abort: () => {
-                abortController.abort();
-              },
-              [_constants.EMITTER_SYMBOL]: emitter,
-              [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
-              // TODO: add streamVNext support
-              engine: {
-                step: this.inngestStep
-              },
-              abortSignal: abortController.signal,
-              writer: new tools.ToolStream(
-                {
-                  prefix: "workflow-step",
-                  callId: crypto.randomUUID(),
-                  name: "conditional",
-                  runId
-                },
-                writableStream
-              )
-            });
-            evalSpan?.end({
-              output: result,
-              attributes: {
-                result: !!result
+          case "outputStep": {
+            if (processor.processOutputStep) {
+              if (!passThrough.messageList) {
+                throw new error.MastraError({
+                  category: error.ErrorCategory.USER,
+                  domain: error.ErrorDomain.MASTRA_WORKFLOW,
+                  id: "PROCESSOR_MISSING_MESSAGE_LIST",
+                  text: `Processor ${processor.id} requires messageList or messages for processOutputStep phase`
+                });
               }
-            });
-            return result ? index : null;
-          } catch (e) {
-            evalSpan?.error({
-              error: e instanceof Error ? e : new Error(String(e)),
-              attributes: {
-                result: false
+              const idsBeforeProcessing = messages.map((m) => m.id);
+              const check = passThrough.messageList.makeMessageSourceChecker();
+              const result = await processor.processOutputStep({
+                ...baseContext,
+                messages,
+                messageList: passThrough.messageList,
+                stepNumber: stepNumber ?? 0,
+                finishReason,
+                toolCalls,
+                text,
+                systemMessages: systemMessages ?? [],
+                steps: steps ?? []
+              });
+              if (result instanceof agent.MessageList) {
+                if (result !== passThrough.messageList) {
+                  throw new error.MastraError({
+                    category: error.ErrorCategory.USER,
+                    domain: error.ErrorDomain.MASTRA_WORKFLOW,
+                    id: "PROCESSOR_RETURNED_EXTERNAL_MESSAGE_LIST",
+                    text: `Processor ${processor.id} returned a MessageList instance other than the one passed in. Use the messageList argument instead.`
+                  });
+                }
+                return {
+                  ...passThrough,
+                  messages: result.get.all.db(),
+                  systemMessages: result.getAllSystemMessages()
+                };
+              } else if (Array.isArray(result)) {
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  result,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                return { ...passThrough, messages: result };
+              } else if (result && "messages" in result && "systemMessages" in result) {
+                const typedResult = result;
+                processors.ProcessorRunner.applyMessagesToMessageList(
+                  typedResult.messages,
+                  passThrough.messageList,
+                  idsBeforeProcessing,
+                  check,
+                  "response"
+                );
+                passThrough.messageList.replaceAllSystemMessages(typedResult.systemMessages);
+                return {
+                  ...passThrough,
+                  messages: typedResult.messages,
+                  systemMessages: typedResult.systemMessages
+                };
               }
-            });
-            return null;
-          }
-        })
-      )
-    )).filter((index) => index !== null);
-    const stepsToRun = entry.steps.filter((_, index) => truthyIndexes.includes(index));
-    conditionalSpan?.update({
-      attributes: {
-        truthyIndexes,
-        selectedSteps: stepsToRun.map((s) => s.type === "step" ? s.step.id : `control-${s.type}`)
-      }
-    });
-    const results = await Promise.all(
-      stepsToRun.map(
-        (step, index) => this.executeEntry({
-          workflowId,
-          runId,
-          entry: step,
-          serializedStepGraph,
-          prevStep,
-          stepResults,
-          resume,
-          executionContext: {
-            workflowId,
-            runId,
-            executionPath: [...executionContext.executionPath, index],
-            suspendedPaths: executionContext.suspendedPaths,
-            resumeLabels: executionContext.resumeLabels,
-            retryConfig: executionContext.retryConfig,
-            executionSpan: executionContext.executionSpan,
-            state: executionContext.state
-          },
-          emitter,
-          abortController,
-          runtimeContext,
-          writableStream,
-          disableScorers,
-          tracingContext: {
-            currentSpan: conditionalSpan
-          }
-        })
-      )
-    );
-    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", suspendPayload: 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 { ...passThrough, messages };
+            }
+            return { ...passThrough, messages };
           }
-          return acc;
-        }, {})
-      };
-    }
-    if (execResults.status === "failed") {
-      conditionalSpan?.error({
-        error: new Error(execResults.error)
+          default:
+            return { ...passThrough, messages };
+        }
       });
-    } else {
-      conditionalSpan?.end({
-        output: execResults.output || execResults
+    },
+    component: "PROCESSOR"
+  };
+}
+function init(inngest) {
+  return {
+    createWorkflow(params) {
+      return new InngestWorkflow(
+        params,
+        inngest
+      );
+    },
+    createStep,
+    cloneStep(step, opts) {
+      return {
+        id: opts.id,
+        description: step.description,
+        inputSchema: step.inputSchema,
+        outputSchema: step.outputSchema,
+        resumeSchema: step.resumeSchema,
+        suspendSchema: step.suspendSchema,
+        stateSchema: step.stateSchema,
+        execute: step.execute,
+        retries: step.retries,
+        scorers: step.scorers,
+        component: step.component
+      };
+    },
+    cloneWorkflow(workflow, opts) {
+      const wf = new workflows.Workflow({
+        id: opts.id,
+        inputSchema: workflow.inputSchema,
+        outputSchema: workflow.outputSchema,
+        steps: workflow.stepDefs,
+        mastra: workflow.mastra,
+        options: workflow.options
       });
+      wf.setStepFlow(workflow.stepGraph);
+      wf.commit();
+      return wf;
     }
-    return execResults;
-  }
-};
+  };
+}
 
 exports.InngestExecutionEngine = InngestExecutionEngine;
+exports.InngestPubSub = InngestPubSub;
 exports.InngestRun = InngestRun;
 exports.InngestWorkflow = InngestWorkflow;
+exports._compatibilityCheck = _compatibilityCheck;
+exports.createServe = createServe;
 exports.createStep = createStep;
 exports.init = init;
 exports.serve = serve;