@cchevli/inngest 1.8.1-walton.0

package/dist/chunk-SE7QPBOX.js

@@ -0,0 +1,1970 @@
+import { randomUUID } from 'crypto';
+import { emitErrorEvent } from '@mastra/core/agent/durable';
+import { RequestContext } from '@mastra/core/di';
+import { EntityType, SpanType } from '@mastra/core/observability';
+import { DefaultExecutionEngine, createTimeTravelExecutionParams, Run, hydrateSerializedStepErrors, Workflow } from '@mastra/core/workflows';
+import { NonRetriableError } from 'inngest';
+import { getErrorFromUnknown } from '@mastra/core/error';
+import { PubSub } from '@mastra/core/events';
+import { subscribe } from 'inngest/realtime';
+import { ReadableStream } from 'stream/web';
+import { ChunkFrom, WorkflowRunOutput } from '@mastra/core/stream';
+
+// src/workflow.ts
+
+// src/nested-workflow-output.ts
+var NESTED_WORKFLOW_OUTPUT_MODE = {
+  DEFAULT: "default",
+  COMPACT: "compact"
+};
+function resolveNestedWorkflowOutputMode(mode = NESTED_WORKFLOW_OUTPUT_MODE.DEFAULT) {
+  return mode === NESTED_WORKFLOW_OUTPUT_MODE.COMPACT ? NESTED_WORKFLOW_OUTPUT_MODE.COMPACT : NESTED_WORKFLOW_OUTPUT_MODE.DEFAULT;
+}
+function compactNestedWorkflowResult(result) {
+  switch (result.status) {
+    case "success":
+      return { status: result.status, result: result.result, state: result.state };
+    case "failed":
+      return { status: result.status, error: result.error, state: result.state };
+    case "tripwire":
+      return { status: result.status, tripwire: result.tripwire, state: result.state };
+    case "suspended":
+      return { status: result.status, steps: result.steps, state: result.state };
+    case "paused":
+      return { status: result.status, state: result.state };
+  }
+}
+
+// src/execution-engine.ts
+var InngestExecutionEngine = class extends DefaultExecutionEngine {
+  inngestStep;
+  inngestAttempts;
+  constructor(mastra, inngestStep, inngestAttempts = 0, options) {
+    super({ mastra, options });
+    this.inngestStep = inngestStep;
+    this.inngestAttempts = inngestAttempts;
+  }
+  // =============================================================================
+  // Hook Overrides
+  // =============================================================================
+  /**
+   * Format errors while preserving Error instances and their custom properties.
+   * Uses getErrorFromUnknown to ensure all error properties are preserved.
+   */
+  formatResultError(error, lastOutput) {
+    const outputError = lastOutput?.error;
+    const errorSource = error || outputError;
+    const errorInstance = getErrorFromUnknown(errorSource, {
+      serializeStack: true,
+      // Include stack in JSON for better debugging in Inngest
+      fallbackMessage: "Unknown workflow error"
+    });
+    return errorInstance.toJSON();
+  }
+  /**
+   * 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));
+      }
+      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 = getErrorFromUnknown(cause.error, { serializeStack: false });
+            }
+            return { ok: false, error: cause };
+          }
+          const errorInstance = 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 { ok: false, error: { status: "failed", error: new Error("Unknown error"), endedAt: Date.now() } };
+  }
+  /**
+   * Use Inngest's sleep primitive for durability
+   */
+  async executeSleepDuration(duration, sleepId, workflowId) {
+    await this.inngestStep.sleep(`workflow.${workflowId}.sleep.${sleepId}`, duration < 0 ? 0 : duration);
+  }
+  /**
+   * Use Inngest's sleepUntil primitive for durability
+   */
+  async executeSleepUntilDate(date, sleepUntilId, workflowId) {
+    await this.inngestStep.sleepUntil(`workflow.${workflowId}.sleepUntil.${sleepUntilId}`, date);
+  }
+  /**
+   * Wrap durable operations in Inngest step.run() for durability.
+   *
+   * 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) {
+    const result = await this.inngestStep.run(operationId, async () => {
+      try {
+        const fnResult = await operationFn();
+        return fnResult;
+      } catch (e) {
+        const errorInstance = getErrorFromUnknown(e, {
+          serializeStack: false,
+          fallbackMessage: "Unknown step execution error"
+        });
+        throw new Error(errorInstance.message, {
+          cause: {
+            status: "failed",
+            error: errorInstance,
+            endedAt: Date.now()
+          }
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * End a step span durably.
+   */
+  async endStepSpan(params) {
+    const { span, operationId, endOptions } = params;
+    if (!span) return;
+    await this.wrapDurableOperation(operationId, async () => {
+      span.end(endOptions);
+    });
+  }
+  /**
+   * 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);
+    });
+  }
+  /**
+   * 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,
+        tracingPolicy: this.options?.tracingPolicy
+      });
+      return span?.exportSpan();
+    });
+    if (exportedSpan) {
+      const observability = this.mastra?.observability?.getSelectedInstance({});
+      return observability?.rebuildSpan(exportedSpan);
+    }
+    return void 0;
+  }
+  /**
+   * 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);
+    });
+  }
+  /**
+   * 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);
+    });
+  }
+  /**
+   * 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,
+      actor,
+      requestContext: parentRequestContext
+    } = params;
+    const forwardedRequestContext = parentRequestContext ? this.serializeRequestContext(parentRequestContext) : inputData?.requestContextEntries ?? {};
+    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 ?? 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 ?? {},
+            requestContext: forwardedRequestContext,
+            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 },
+            nestedWorkflowOutputMode: NESTED_WORKFLOW_OUTPUT_MODE.COMPACT,
+            perStep,
+            tracingOptions: nestedTracingContext,
+            actor
+          }
+        });
+        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 = 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 ?? {},
+            requestContext: forwardedRequestContext,
+            runId: executionContext.runId,
+            outputOptions: { includeState: true },
+            nestedWorkflowOutputMode: NESTED_WORKFLOW_OUTPUT_MODE.COMPACT,
+            perStep,
+            tracingOptions: nestedTracingContext,
+            actor
+          }
+        });
+        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 ?? {},
+            requestContext: forwardedRequestContext,
+            outputOptions: { includeState: true },
+            nestedWorkflowOutputMode: NESTED_WORKFLOW_OUTPUT_MODE.COMPACT,
+            perStep,
+            tracingOptions: nestedTracingContext,
+            actor
+          }
+        });
+        result = invokeResp.result;
+        runId = invokeResp.runId;
+        executionContext.state = invokeResp.result.state;
+      }
+    } catch (e) {
+      const errorCause = e && typeof e === "object" && "cause" in e ? e.cause : void 0;
+      if (errorCause && typeof errorCause === "object" && "status" in errorCause && errorCause.status === "failed") {
+        result = errorCause;
+        runId = "runId" in errorCause && typeof errorCause.runId === "string" ? errorCause.runId : randomUUID();
+      } else {
+        runId = randomUUID();
+        result = {
+          status: "failed",
+          error: e instanceof Error ? e : new Error(String(e))
+        };
+      }
+    }
+    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
+    };
+  }
+};
+function buildTopicRef(channel, topic) {
+  return { channel, topic, config: {} };
+}
+function parseTopic(topic) {
+  const workflowMatch = topic.match(/^workflow\.events\.v2\.(.+)$/);
+  if (workflowMatch && workflowMatch[1]) {
+    return { runId: workflowMatch[1], topicType: "workflow" };
+  }
+  const agentMatch = topic.match(/^agent\.stream\.(.+)$/);
+  if (agentMatch && agentMatch[1]) {
+    return { runId: agentMatch[1], topicType: "agent" };
+  }
+  return null;
+}
+var InngestPubSub = class extends PubSub {
+  inngest;
+  workflowId;
+  subscriptions = /* @__PURE__ */ new Map();
+  constructor(inngest, workflowId) {
+    super();
+    this.inngest = inngest;
+    this.workflowId = workflowId;
+  }
+  /**
+   * Publish an event to Inngest's realtime system.
+   *
+   * Supported topic formats:
+   * - "workflow.events.v2.{runId}" - workflow events
+   *   -> channel: "workflow:{workflowId}:{runId}", topic: "watch"
+   * - "agent.stream.{runId}" - agent stream events
+   *   -> channel: "agent:{runId}", topic: "agent-stream"
+   *   (Note: agent stream uses runId-only channel so nested workflows can publish to same channel)
+   */
+  async publish(topic, event) {
+    const parsed = parseTopic(topic);
+    if (!parsed) {
+      return;
+    }
+    const { runId, topicType } = parsed;
+    const inngestTopic = topicType === "agent" ? "agent-stream" : "watch";
+    const channel = topicType === "agent" ? `agent:${runId}` : `workflow:${this.workflowId}:${runId}`;
+    try {
+      const dataToSend = topicType === "agent" ? event : event.data;
+      await this.inngest.realtime.publish(buildTopicRef(channel, inngestTopic), dataToSend);
+    } catch (err) {
+      if (topicType === "agent" && (event.type === "finish" || event.type === "error")) {
+        throw err;
+      }
+      console.error("InngestPubSub publish error:", err?.message ?? err);
+    }
+  }
+  /**
+   * Subscribe to events from Inngest's realtime system.
+   *
+   * Supported topic formats:
+   * - "workflow.events.v2.{runId}" - workflow events
+   *   -> channel: "workflow:{workflowId}:{runId}", topic: "watch"
+   * - "agent.stream.{runId}" - agent stream events
+   *   -> channel: "agent:{runId}", topic: "agent-stream"
+   *   (Note: agent stream uses runId-only channel so nested workflows can publish to same channel)
+   */
+  async subscribe(topic, cb) {
+    const parsed = parseTopic(topic);
+    if (!parsed) {
+      return;
+    }
+    const { runId, topicType } = parsed;
+    if (this.subscriptions.has(topic)) {
+      this.subscriptions.get(topic).callbacks.add(cb);
+      return;
+    }
+    const callbacks = /* @__PURE__ */ new Set([cb]);
+    const inngestTopic = topicType === "agent" ? "agent-stream" : "watch";
+    const channel = topicType === "agent" ? `agent:${runId}` : `workflow:${this.workflowId}:${runId}`;
+    const stream = await subscribe(
+      {
+        channel,
+        topics: [inngestTopic],
+        app: this.inngest
+      },
+      (message) => {
+        let event;
+        if (topicType === "agent" && message.data?.type && message.data?.runId) {
+          event = {
+            id: crypto.randomUUID(),
+            createdAt: /* @__PURE__ */ new Date(),
+            ...message.data
+          };
+        } else {
+          event = {
+            id: crypto.randomUUID(),
+            type: inngestTopic,
+            runId,
+            data: message.data,
+            createdAt: /* @__PURE__ */ new Date()
+          };
+        }
+        for (const callback of callbacks) {
+          callback(event);
+        }
+      }
+    );
+    this.subscriptions.set(topic, {
+      unsubscribe: () => {
+        try {
+          void 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 Run {
+  inngest;
+  serializedStepGraph;
+  #mastra;
+  constructor(params, inngest) {
+    super(params);
+    this.inngest = inngest;
+    this.serializedStepGraph = params.serializedStepGraph;
+    this.#mastra = params.mastra;
+  }
+  /**
+   * Get run output using hybrid approach: realtime subscription + polling fallback.
+   * Resolves as soon as either method detects completion.
+   */
+  async getRunOutput(_eventId, maxWaitMs = 3e5) {
+    const storage = this.#mastra?.getStorage();
+    const workflowsStore = await storage?.getStore("workflows");
+    if (!workflowsStore) {
+      throw new NonRetriableError(`Workflow storage is required to retrieve output for run ${this.runId}`);
+    }
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      let unsubscribe = null;
+      let pollTimeoutId = null;
+      const cleanup = () => {
+        if (unsubscribe) {
+          try {
+            unsubscribe();
+          } catch {
+          }
+        }
+        if (pollTimeoutId) {
+          clearTimeout(pollTimeoutId);
+        }
+      };
+      const handleResult = (result, _source) => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          resolve(result);
+        }
+      };
+      const handleError = (error, _source) => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          reject(error);
+        }
+      };
+      let realtimeStreamPromise = null;
+      const startRealtimeSubscription = async () => {
+        try {
+          realtimeStreamPromise = subscribe(
+            {
+              channel: `workflow:${this.workflowId}:${this.runId}`,
+              topics: ["watch"],
+              app: this.inngest
+            },
+            async (message) => {
+              if (resolved) return;
+              const event = message.data;
+              if (event?.type === "workflow-finish") {
+                const snapshot = await workflowsStore?.loadWorkflowSnapshot({
+                  workflowName: this.workflowId,
+                  runId: this.runId
+                });
+                if (snapshot?.context) {
+                  snapshot.context = hydrateSerializedStepErrors(snapshot.context);
+                }
+                const realtimeResult = {
+                  steps: snapshot?.context,
+                  status: event.payload?.status ?? snapshot?.status,
+                  input: snapshot?.context?.input
+                };
+                const resultValue = event.payload?.result ?? snapshot?.result;
+                if (resultValue !== void 0) realtimeResult.result = resultValue;
+                const rawError = event.payload?.error ?? snapshot?.error;
+                if (rawError) {
+                  realtimeResult.error = getErrorFromUnknown(rawError, { serializeStack: false });
+                }
+                if (snapshot?.value !== void 0) realtimeResult.state = snapshot.value;
+                const result = { output: { result: realtimeResult } };
+                handleResult(result);
+              }
+            }
+          );
+          unsubscribe = () => {
+            realtimeStreamPromise?.then((stream) => stream.cancel().catch(() => {
+            })).catch(() => {
+            });
+          };
+          await realtimeStreamPromise;
+        } catch {
+        }
+      };
+      const startPolling = async () => {
+        const startTime = Date.now();
+        const poll = async () => {
+          if (resolved) {
+            return;
+          }
+          if (Date.now() - startTime >= maxWaitMs) {
+            handleError(new NonRetriableError(`Workflow did not complete within ${maxWaitMs}ms`));
+            return;
+          }
+          try {
+            const snapshot = await workflowsStore.loadWorkflowSnapshot({
+              workflowName: this.workflowId,
+              runId: this.runId
+            });
+            if (!snapshot || snapshot.status === "running" || snapshot.status === "waiting" || snapshot.status === "pending") {
+              pollTimeoutId = setTimeout(poll, 150 + Math.random() * 100);
+              return;
+            }
+            if (snapshot.context) {
+              snapshot.context = hydrateSerializedStepErrors(snapshot.context);
+            }
+            const pollingResult = {
+              steps: snapshot.context,
+              status: snapshot.status,
+              input: snapshot.context?.input
+            };
+            if (snapshot.result !== void 0) pollingResult.result = snapshot.result;
+            if (snapshot.error !== void 0) {
+              pollingResult.error = getErrorFromUnknown(snapshot.error, { serializeStack: false });
+            }
+            if (snapshot.value !== void 0) pollingResult.state = snapshot.value;
+            handleResult({ output: { result: pollingResult } });
+          } catch (error) {
+            if (error instanceof NonRetriableError) {
+              handleError(error);
+              return;
+            }
+            handleError(
+              new NonRetriableError(
+                `Failed to poll workflow status: ${error instanceof Error ? error.message : String(error)}`
+              ));
+          }
+        };
+        void poll();
+      };
+      void startRealtimeSubscription();
+      void startPolling();
+    });
+  }
+  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()) : {},
+        actor: args.actor,
+        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,
+    actor,
+    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 eventName = `workflow.${this.workflowId}`;
+    const eventOutput = await this.inngest.send({
+      name: eventName,
+      data: {
+        inputData: inputDataToUse,
+        initialState: initialStateToUse,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        outputOptions,
+        tracingOptions,
+        format,
+        requestContext: requestContext ? Object.fromEntries(requestContext.entries()) : {},
+        actor,
+        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 (!outputOptions?.includeState) {
+      delete result.state;
+    }
+    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;
+  }
+  /**
+   * Performs all resume preparation and dispatches the resume event to Inngest,
+   * but does NOT wait for the workflow result. Shared by `_resume()` (which polls
+   * for the result afterwards) and `resumeAsync()` (which returns immediately).
+   *
+   * Send-time failures (invalid resume data, event send failure) reject synchronously,
+   * and the snapshot is rolled back to its prior state on send failure.
+   */
+  async _resumeAndSendEvent(params) {
+    const storage = this.#mastra?.getStorage();
+    const workflowsStore = await storage?.getStore("workflows");
+    if (!workflowsStore) {
+      throw new NonRetriableError(`Workflow storage is required to resume run ${this.runId}`);
+    }
+    const snapshot = await workflowsStore.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (!snapshot) {
+      throw new NonRetriableError(`Cannot resume run ${this.runId}: snapshot not found`);
+    }
+    const snapshotResumeLabel = params.label ? snapshot.resumeLabels?.[params.label] : void 0;
+    const stepParam = snapshotResumeLabel?.stepId ?? params.step;
+    let steps = [];
+    if (stepParam) {
+      if (typeof stepParam === "string") {
+        steps = stepParam.split(".");
+      } else {
+        steps = (Array.isArray(stepParam) ? stepParam : [stepParam]).map(
+          (step) => typeof step === "string" ? step : step?.id
+        );
+      }
+    }
+    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 };
+    await workflowsStore.persistWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId,
+      resourceId: this.resourceId,
+      snapshot: {
+        ...snapshot,
+        status: "running",
+        result: void 0,
+        error: void 0,
+        timestamp: Date.now()
+      }
+    });
+    let eventOutput;
+    try {
+      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,
+          // `actor` is a per-call trust signal, not rehydrated from the snapshot like
+          // `requestContext` is above. This intentionally matches the default engine,
+          // which passes `actor: params.actor` on resume and never reads it from the
+          // snapshot (see packages/core/src/workflows/workflow.ts `_resume`). The caller
+          // (a trusted background system) re-supplies `actor` on each resume; we never
+          // persist a membership-bypass signal into durable storage.
+          actor: params.actor,
+          perStep: params.perStep
+        }
+      });
+    } catch (err) {
+      try {
+        await workflowsStore.persistWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId,
+          resourceId: this.resourceId,
+          snapshot
+        });
+      } catch (rollbackErr) {
+        console.error("Failed to rollback snapshot during resume error recovery:", rollbackErr);
+      }
+      throw err;
+    }
+    const eventId = eventOutput.ids[0];
+    if (!eventId) {
+      throw new Error("Event ID is not set");
+    }
+    return { eventId };
+  }
+  async _resume(params) {
+    const { eventId } = await this._resumeAndSendEvent(params);
+    const runOutput = await this.getRunOutput(eventId);
+    const result = runOutput?.output?.result;
+    this.hydrateFailedResult(result);
+    return result;
+  }
+  /**
+   * Resumes a suspended workflow without waiting for completion (fire-and-forget).
+   * Returns immediately with the runId after sending the resume event to Inngest.
+   * The workflow continues executing independently in Inngest.
+   *
+   * Mirrors `startAsync()`: send-time failures (invalid resume data, event send
+   * failure) still reject synchronously and roll back the snapshot, but the result
+   * is never polled via `getRunOutput()`. This avoids the polling-based 404 race when
+   * you don't need the resolved result inline.
+   *
+   * NOTE: this is exposed over HTTP / the client SDK as `resume-no-wait` / `resumeNoWait()`,
+   * not `resumeAsync`, because the existing `resumeAsync()` client/server surface awaits the
+   * full workflow result. TODO(v2): consolidate so `resumeAsync` consistently means
+   * fire-and-forget across core, client SDK and HTTP routes (breaking change deferred to v2).
+   */
+  async resumeAsync(params) {
+    await this._resumeAndSendEvent(params);
+    return { runId: this.runId };
+  }
+  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");
+    if (!workflowsStore) {
+      throw new NonRetriableError(`Workflow storage is required to time-travel run ${this.runId}`);
+    }
+    const snapshot = await workflowsStore.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    let snapshotForRollback = snapshot;
+    if (!snapshot) {
+      const pendingSnapshot = {
+        runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
+        status: "pending",
+        value: {},
+        context: {},
+        activePaths: [],
+        suspendedPaths: {},
+        activeStepsPath: {},
+        resumeLabels: {},
+        waitingPaths: {},
+        timestamp: Date.now()
+      };
+      await workflowsStore.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        snapshot: pendingSnapshot
+      });
+      snapshotForRollback = pendingSnapshot;
+    }
+    if (snapshot?.status === "running") {
+      throw new Error("This workflow run is still running, cannot time travel");
+    }
+    let inputDataToUse = params.inputData;
+    if (inputDataToUse && steps.length === 1) {
+      inputDataToUse = await this._validateTimetravelInputData(params.inputData, this.workflowSteps[steps[0]]);
+    }
+    const timeTravelData = createTimeTravelExecutionParams({
+      steps,
+      inputData: inputDataToUse,
+      resumeData: params.resumeData,
+      context: params.context,
+      nestedStepsContext: params.nestedStepsContext,
+      snapshot: snapshot ?? { context: {} },
+      graph: this.executionGraph,
+      initialState: params.initialState,
+      perStep: params.perStep
+    });
+    const previousSnapshot = snapshotForRollback;
+    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()
+      }
+    });
+    let eventOutput;
+    try {
+      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()) : {},
+          actor: params.actor,
+          perStep: params.perStep
+        }
+      });
+    } catch (err) {
+      if (previousSnapshot) {
+        try {
+          await workflowsStore.persistWorkflowSnapshot({
+            workflowName: this.workflowId,
+            runId: this.runId,
+            resourceId: this.resourceId,
+            snapshot: previousSnapshot
+          });
+        } catch (rollbackErr) {
+          console.error("Failed to rollback snapshot during time-travel error recovery:", rollbackErr);
+        }
+      }
+      throw err;
+    }
+    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 (!params.outputOptions?.includeState) {
+      delete result.state;
+    }
+    return result;
+  }
+  watch(cb) {
+    let active = true;
+    const streamPromise = 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,
+    actor
+  } = {}) {
+    const { readable, writable } = new TransformStream();
+    const writer = writable.getWriter();
+    void writer.write({
+      // @ts-expect-error - stream event type mismatch
+      type: "start",
+      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-expect-error - stream event type mismatch
+        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, requestContext, actor, format: "legacy" }).then((result) => {
+      if (result.status !== "suspended") {
+        this.closeStreamAction?.().catch(() => {
+        });
+      }
+      return result;
+    });
+    return {
+      stream: readable,
+      getWorkflowState: () => this.executionResults
+    };
+  }
+  stream({
+    inputData,
+    requestContext,
+    actor,
+    tracingOptions,
+    closeOnSuspend = true,
+    initialState,
+    outputOptions,
+    perStep
+  } = {}) {
+    if (this.closeStreamAction && this.streamOutput) {
+      return this.streamOutput;
+    }
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = ChunkFrom.WORKFLOW, payload }) => {
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            await controller.close();
+          } catch (err) {
+            console.error("Error closing stream:", err);
+          }
+        };
+        const executionResultsPromise = self._start({
+          inputData,
+          requestContext,
+          actor,
+          // 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 WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return this.streamOutput;
+  }
+  timeTravelStream({
+    inputData,
+    resumeData,
+    initialState,
+    step,
+    context,
+    nestedStepsContext,
+    requestContext,
+    actor,
+    // tracingContext,
+    tracingOptions,
+    outputOptions,
+    perStep
+  }) {
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = ChunkFrom.WORKFLOW, payload }) => {
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            controller.close();
+          } catch (err) {
+            console.error("Error closing stream:", err);
+          }
+        };
+        const executionResultsPromise = self._timeTravel({
+          inputData,
+          step,
+          context,
+          nestedStepsContext,
+          resumeData,
+          initialState,
+          requestContext,
+          actor,
+          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(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    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 = getErrorFromUnknown(result.error, { serializeStack: false });
+      if (result.steps) {
+        hydrateSerializedStepErrors(result.steps);
+      }
+    }
+  }
+};
+
+// src/workflow.ts
+var InngestWorkflow = class _InngestWorkflow extends Workflow {
+  #mastra;
+  inngest;
+  function;
+  cronFunction;
+  flowControlConfig;
+  cronConfig;
+  /**
+   * Optional override that lets a host (e.g. `createInngestAgent`) provide the
+   * PubSub instance used by workflow steps for publishing chunk/finish events.
+   * When set, the workflow function uses this factory instead of constructing
+   * a fresh `InngestPubSub`. This is what lets `DurableAgent.observe()` see
+   * cached history when the agent wraps its PubSub in a `CachingPubSub`.
+   */
+  #pubsubFactory;
+  constructor(params, inngest) {
+    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 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 };
+    }
+    const workflowsStore = await storage.getStore("workflows");
+    if (!workflowsStore) {
+      return { runs: [], total: 0 };
+    }
+    return workflowsStore.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
+  }
+  /**
+   * Override the PubSub used inside the durable workflow function. Callers like
+   * `createInngestAgent` use this to route workflow event publishes through the
+   * agent's `CachingPubSub`, so `observe()` can replay cached history.
+   *
+   * The factory receives the workflow's own default `InngestPubSub` (constructed
+   * with this workflow's id) as input. Hosts should wrap that instance rather
+   * than substitute it, so workflow-event channels (which encode the workflow
+   * id) remain workflow-local. Returning a `CachingPubSub` wrapping the default
+   * is the canonical pattern.
+   *
+   * The factory is propagated to every nested `InngestWorkflow` in the step
+   * graph. Nested workflows run as their own Inngest functions and resolve
+   * their own pubsub at runtime; each invocation passes its own workflow-local
+   * default into the same factory, so the host can share cross-workflow state
+   * (e.g. a single agent-scoped cache) without collapsing per-workflow channel
+   * isolation.
+   */
+  __setPubsubFactory(factory) {
+    this.#pubsubFactory = factory;
+    const updateNested = (step) => {
+      if ((step.type === "step" || step.type === "loop" || step.type === "foreach") && step.step instanceof _InngestWorkflow) {
+        step.step.__setPubsubFactory(factory);
+      } else if (step.type === "parallel" || step.type === "conditional") {
+        for (const subStep of step.steps) {
+          updateNested(subStep);
+        }
+      }
+    };
+    for (const step of this.executionGraph.steps) {
+      updateNested(step);
+    }
+  }
+  /**
+   * Test-only accessor for the configured pubsub factory. Lets tests verify that
+   * a host (e.g. `createInngestAgent`) wired the workflow to its agent pubsub
+   * without having to drive a real Inngest invocation.
+   */
+  __getPubsubFactory() {
+    return this.#pubsubFactory;
+  }
+  __registerMastra(mastra) {
+    super.__registerMastra(mastra);
+    this.#mastra = mastra;
+    this.executionEngine.__registerMastra(mastra);
+    const updateNested = (step) => {
+      if ((step.type === "step" || step.type === "loop" || step.type === "foreach") && step.step instanceof _InngestWorkflow) {
+        step.step.__registerMastra(mastra);
+      } else if (step.type === "parallel" || step.type === "conditional") {
+        for (const subStep of step.steps) {
+          updateNested(subStep);
+        }
+      }
+    };
+    if (this.executionGraph.steps.length) {
+      for (const step of this.executionGraph.steps) {
+        updateNested(step);
+      }
+    }
+  }
+  async createRun(options) {
+    const runIdToUse = options?.runId || randomUUID();
+    const existingInMemoryRun = this.runs.get(runIdToUse);
+    const newRun = new InngestRun(
+      {
+        workflowId: this.id,
+        runId: runIdToUse,
+        resourceId: options?.resourceId,
+        executionEngine: this.executionEngine,
+        executionGraph: this.executionGraph,
+        serializedStepGraph: this.serializedStepGraph,
+        mastra: this.#mastra,
+        retryConfig: this.retryConfig,
+        cleanup: () => this.runs.delete(runIdToUse),
+        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 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,
+        snapshot: {
+          runId: runIdToUse,
+          status: "pending",
+          value: {},
+          context: {},
+          activePaths: [],
+          activeStepsPath: {},
+          waitingPaths: {},
+          serializedStepGraph: this.serializedStepGraph,
+          suspendedPaths: {},
+          resumeLabels: {},
+          result: void 0,
+          error: void 0,
+          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}` }],
+        triggers: { cron: this.cronConfig?.cron ?? "" },
+        ...this.flowControlConfig
+      },
+      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;
+    }
+    this.function = this.inngest.createFunction(
+      {
+        id: `workflow.${this.id}`,
+        retries: 0,
+        cancelOn: [{ event: `cancel.workflow.${this.id}` }],
+        triggers: { event: `workflow.${this.id}` },
+        // Spread flow control configuration
+        ...this.flowControlConfig
+      },
+      async ({ event, step, attempt }) => {
+        let {
+          inputData,
+          initialState,
+          runId,
+          resourceId,
+          resume,
+          outputOptions,
+          format,
+          timeTravel,
+          perStep,
+          tracingOptions,
+          actor,
+          nestedWorkflowOutputMode: requestedNestedWorkflowOutputMode
+        } = event.data;
+        const nestedWorkflowOutputMode = resolveNestedWorkflowOutputMode(requestedNestedWorkflowOutputMode);
+        const shouldCompactNestedWorkflowOutput = nestedWorkflowOutputMode === NESTED_WORKFLOW_OUTPUT_MODE.COMPACT;
+        if (!runId) {
+          runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
+            return randomUUID();
+          });
+        }
+        const defaultPubsub = new InngestPubSub(this.inngest, this.id);
+        const pubsub = this.#pubsubFactory?.(defaultPubsub) ?? defaultPubsub;
+        const requestContext = new 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 = mastra?.observability?.getSelectedInstance({ requestContext });
+          if (!observability) return void 0;
+          const span = observability.startSpan({
+            type: SpanType.WORKFLOW_RUN,
+            name: `workflow run: '${this.id}'`,
+            entityType: EntityType.WORKFLOW_RUN,
+            entityId: this.id,
+            entityName: 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,
+            actor,
+            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);
+              }
+            }
+          });
+        } catch (executionError) {
+          result = {
+            status: "failed",
+            steps: {},
+            state: initialState ?? {},
+            error: executionError instanceof Error ? executionError : new Error(String(executionError))
+          };
+        }
+        const returnedResult = shouldCompactNestedWorkflowOutput ? compactNestedWorkflowResult(result) : result;
+        let finalizeError;
+        let finalizeErrored = false;
+        try {
+          await step.run(`workflow.${this.id}.finalize`, async () => {
+            if (result.status === "failed" && inputData?.__workflowKind === "durable-agent" && inputData?.runId) {
+              const error = result.error instanceof Error ? result.error : new Error(String(result.error));
+              try {
+                await emitErrorEvent(pubsub, inputData.runId, error);
+              } catch (e) {
+                this.logger.debug?.("Failed to emit error event:", e);
+              }
+            }
+            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 }
+                  });
+                }
+              }
+            }
+            const shouldPersistFinalSnapshot = this.options.shouldPersistSnapshot({
+              workflowStatus: result.status,
+              stepResults: result.steps
+            });
+            if (shouldPersistFinalSnapshot) {
+              const workflowsStore = await mastra?.getStorage()?.getStore("workflows");
+              if (workflowsStore) {
+                let existingSnapshot;
+                if (result.status === "suspended") {
+                  existingSnapshot = await workflowsStore.loadWorkflowSnapshot({
+                    workflowName: this.id,
+                    runId
+                  }) ?? void 0;
+                }
+                await workflowsStore.persistWorkflowSnapshot({
+                  workflowName: this.id,
+                  runId,
+                  resourceId,
+                  snapshot: {
+                    runId,
+                    status: result.status,
+                    value: result.state ?? initialState ?? {},
+                    context: toSnapshotContext(result.steps),
+                    activePaths: [],
+                    activeStepsPath: {},
+                    serializedStepGraph: this.serializedStepGraph,
+                    suspendedPaths: existingSnapshot?.suspendedPaths ?? {},
+                    waitingPaths: {},
+                    resumeLabels: existingSnapshot?.resumeLabels ?? result.resumeLabels ?? {},
+                    result: result.status === "success" ? toSnapshotResult(result.result) : void 0,
+                    error: result.status === "failed" ? result.error : void 0,
+                    timestamp: Date.now()
+                  }
+                });
+              }
+            }
+            try {
+              await pubsub.publish(`workflow.events.v2.${runId}`, {
+                type: "watch",
+                runId,
+                data: {
+                  type: "workflow-finish",
+                  payload: {
+                    status: result.status,
+                    result: result.status === "success" ? result.result : void 0,
+                    error: result.status === "failed" ? result.error : void 0
+                  }
+                }
+              });
+            } catch (publishError) {
+              this.logger.debug?.("Failed to publish workflow-finish event:", publishError);
+            }
+            if (result.status === "failed") {
+              throw new NonRetriableError(`Workflow failed`, {
+                cause: shouldCompactNestedWorkflowOutput ? { ...returnedResult, runId } : result
+              });
+            }
+            return shouldCompactNestedWorkflowOutput ? { status: result.status } : result;
+          });
+        } catch (error) {
+          finalizeErrored = true;
+          finalizeError = error;
+        } finally {
+          const observability = mastra?.observability?.getSelectedInstance({ requestContext });
+          if (observability) {
+            try {
+              await observability.flush();
+            } catch (flushError) {
+              this.logger.debug?.("Failed to flush observability:", flushError);
+            }
+          }
+        }
+        if (finalizeErrored) {
+          throw finalizeError;
+        }
+        return { result: returnedResult, runId };
+      }
+    );
+    return this.function;
+  }
+  getNestedFunctions(steps) {
+    return steps.flatMap((step) => {
+      if (step.type === "step" || step.type === "loop" || step.type === "foreach") {
+        if (step.step instanceof _InngestWorkflow) {
+          return [step.step.getFunction(), ...step.step.getNestedFunctions(step.step.executionGraph.steps)];
+        }
+        return [];
+      } else if (step.type === "parallel" || step.type === "conditional") {
+        return this.getNestedFunctions(step.steps);
+      }
+      return [];
+    });
+  }
+  getFunctions() {
+    return [
+      this.getFunction(),
+      ...this.cronConfig?.cron ? [this.createCronFunction()] : [],
+      ...this.getNestedFunctions(this.executionGraph.steps)
+    ];
+  }
+};
+function toSnapshotContext(steps) {
+  return steps;
+}
+function toSnapshotResult(output) {
+  return output;
+}
+
+// src/functions.ts
+function collectInngestFunctions({
+  mastra,
+  functions: userFunctions = []
+}) {
+  const workflows = mastra.listWorkflows();
+  const workflowFunctions = Array.from(
+    new Set(
+      Object.values(workflows).flatMap((workflow) => {
+        if (workflow instanceof InngestWorkflow) {
+          workflow.__registerMastra(mastra);
+          return workflow.getFunctions();
+        }
+        return [];
+      })
+    )
+  );
+  return [...workflowFunctions, ...userFunctions];
+}
+
+// src/connect.ts
+async function connect(options) {
+  const { mastra, inngest, functions, registerOptions, ...connectOptions } = options;
+  const appFunctions = collectInngestFunctions({ mastra, functions });
+  if (appFunctions.length === 0) {
+    console.warn(
+      "[@mastra/inngest] connect() was called with no Inngest workflows and no additional functions. The worker will connect to Inngest but has nothing to execute. Register at least one InngestWorkflow on the Mastra instance or pass `functions: [...]`."
+    );
+  }
+  const { connect: connectWorker } = await import('inngest/connect');
+  return connectWorker({
+    // Top-level Connect options first, then registerOptions so they take precedence
+    // for any overlapping keys (e.g. `signingKey`). This matches serve()'s behavior.
+    ...connectOptions,
+    ...registerOptions,
+    apps: [{ client: inngest, functions: appFunctions }]
+  });
+}
+
+export { InngestExecutionEngine, InngestPubSub, InngestRun, InngestWorkflow, collectInngestFunctions, connect };
+//# sourceMappingURL=chunk-SE7QPBOX.js.map
+//# sourceMappingURL=chunk-SE7QPBOX.js.map