@mastra/inngest 0.0.0-feat-add-query-option-to-playground-20251209160219 → 0.0.0-feat-8782-cf-bindings-20260102164434

package/dist/index.cjs

@@ -1,14 +1,17 @@
 'use strict';
 
+var agent = require('@mastra/core/agent');
 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 = require('crypto');
+var crypto$1 = require('crypto');
 var di = require('@mastra/core/di');
 var inngest = require('inngest');
-var web = require('stream/web');
+var error = require('@mastra/core/error');
 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');
 
@@ -25,17 +28,18 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
   // Hook Overrides
   // =============================================================================
   /**
-   * Format errors with stack traces for better debugging in Inngest
+   * Format errors while preserving Error instances and their custom properties.
+   * Uses getErrorFromUnknown to ensure all error properties are preserved.
    */
-  formatResultError(error, lastOutput) {
-    if (error instanceof Error) {
-      return error.stack ?? error.message;
-    }
+  formatResultError(error$1, lastOutput) {
     const outputError = lastOutput?.error;
-    if (outputError instanceof Error) {
-      return outputError.message;
-    }
-    return outputError ?? error ?? "Unknown 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"
+    });
+    return errorInstance.toJSON();
   }
   /**
    * Detect InngestWorkflow instances for special nested workflow handling
@@ -57,32 +61,46 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
    * After retries exhausted, error propagates here and we return a failed result.
    */
   async executeStepWithRetry(stepId, runStep, params) {
-    try {
-      const result = await this.wrapDurableOperation(stepId, runStep, { delay: params.delay });
-      return { ok: true, result };
-    } catch (e) {
-      const cause = e?.cause;
-      if (cause?.status === "failed") {
-        params.stepSpan?.error({
-          error: e,
-          attributes: { status: "failed" }
-        });
-        return { ok: false, error: cause };
+    for (let i = 0; i < params.retries + 1; i++) {
+      if (i > 0 && params.delay) {
+        await new Promise((resolve) => setTimeout(resolve, params.delay));
       }
-      const errorMessage = e instanceof Error ? e.message : String(e);
-      params.stepSpan?.error({
-        error: e,
-        attributes: { status: "failed" }
-      });
-      return {
-        ok: false,
-        error: {
-          status: "failed",
-          error: `Error: ${errorMessage}`,
-          endedAt: Date.now()
+      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 { ok: false, error: { status: "failed", error: new Error("Unknown error"), endedAt: Date.now() } };
   }
   /**
    * Use Inngest's sleep primitive for durability
@@ -101,21 +119,11 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
    * If retryConfig is provided, throws RetryAfterError INSIDE step.run() to trigger
    * Inngest's step-level retry mechanism (not function-level retry).
    */
-  async wrapDurableOperation(operationId, operationFn, retryConfig) {
+  async wrapDurableOperation(operationId, operationFn) {
     return this.inngestStep.run(operationId, async () => {
       try {
         return await operationFn();
       } catch (e) {
-        if (retryConfig) {
-          const errorMessage = e instanceof Error ? e.message : String(e);
-          throw new inngest.RetryAfterError(errorMessage, retryConfig.delay, {
-            cause: {
-              status: "failed",
-              error: `Error: ${errorMessage}`,
-              endedAt: Date.now()
-            }
-          });
-        }
         throw e;
       }
     });
@@ -126,6 +134,18 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
   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);
+  }
   /**
    * Execute nested InngestWorkflow using inngestStep.invoke() for durability.
    * This MUST be called directly (not inside step.run()) due to Inngest constraints.
@@ -134,15 +154,27 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     if (!(params.step instanceof InngestWorkflow)) {
       return null;
     }
-    const { step, stepResults, executionContext, resume, timeTravel, prevOutput, inputData, emitter, startedAt } = params;
+    const {
+      step,
+      stepResults,
+      executionContext,
+      resume,
+      timeTravel,
+      prevOutput,
+      inputData,
+      pubsub,
+      startedAt,
+      perStep
+    } = params;
     const isResume = !!resume?.steps?.length;
     let result;
     let runId;
     const isTimeTravel = !!(timeTravel && timeTravel.steps?.length > 1 && timeTravel.steps[0] === step.id);
     try {
       if (isResume) {
-        runId = stepResults[resume?.steps?.[0] ?? ""]?.suspendPayload?.__workflow_meta?.runId ?? crypto.randomUUID();
-        const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
+        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
         });
@@ -159,14 +191,16 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               resumePayload: resume.resumePayload,
               resumePath: resume.steps?.[1] ? snapshot?.suspendedPaths?.[resume.steps?.[1]] : void 0
             },
-            outputOptions: { includeState: true }
+            outputOptions: { includeState: true },
+            perStep
           }
         });
         result = invokeResp.result;
         runId = invokeResp.runId;
         executionContext.state = invokeResp.result.state;
       } else if (isTimeTravel) {
-        const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
+        const workflowsStoreForTimeTravel = await this.mastra?.getStorage()?.getStore("workflows");
+        const snapshot = await workflowsStoreForTimeTravel?.loadWorkflowSnapshot({
           workflowName: step.id,
           runId: executionContext.runId
         }) ?? { context: {} };
@@ -185,7 +219,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             timeTravel: timeTravelParams,
             initialState: executionContext.state ?? {},
             runId: executionContext.runId,
-            outputOptions: { includeState: true }
+            outputOptions: { includeState: true },
+            perStep
           }
         });
         result = invokeResp.result;
@@ -197,7 +232,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           data: {
             inputData,
             initialState: executionContext.state ?? {},
-            outputOptions: { includeState: true }
+            outputOptions: { includeState: true },
+            perStep
           }
         });
         result = invokeResp.result;
@@ -208,9 +244,9 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       const errorCause = e?.cause;
       if (errorCause && typeof errorCause === "object") {
         result = errorCause;
-        runId = errorCause.runId || crypto.randomUUID();
+        runId = errorCause.runId || crypto$1.randomUUID();
       } else {
-        runId = crypto.randomUUID();
+        runId = crypto$1.randomUUID();
         result = {
           status: "failed",
           error: e instanceof Error ? e : new Error(String(e)),
@@ -223,16 +259,20 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       `workflow.${executionContext.workflowId}.step.${step.id}.nestedwf-results`,
       async () => {
         if (result.status === "failed") {
-          await emitter.emit("watch", {
-            type: "workflow-step-result",
-            payload: {
-              id: step.id,
-              status: "failed",
-              error: result?.error,
-              payload: prevOutput
+          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 } };
+          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;
@@ -241,17 +281,22 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           for (const [stepName, stepResult] of suspendedSteps) {
             const suspendPath = [stepName, ...stepResult?.suspendPayload?.__workflow_meta?.path ?? []];
             executionContext.suspendedPaths[step.id] = executionContext.executionPath;
-            await emitter.emit("watch", {
-              type: "workflow-step-suspended",
-              payload: {
-                id: step.id,
-                status: "suspended"
+            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,
@@ -264,39 +309,205 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             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 emitter.emit("watch", {
-          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-result",
+            payload: {
+              id: step.id,
+              status: "success",
+              output: result?.result
+            }
           }
         });
-        await emitter.emit("watch", {
-          type: "workflow-step-finish",
-          payload: {
-            id: step.id,
-            metadata: {}
+        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 } };
+        return { executionContext, result: { status: "success", output: result?.result, endedAt: Date.now() } };
       }
     );
     Object.assign(executionContext, res.executionContext);
     return {
       ...res.result,
       startedAt,
-      endedAt: Date.now(),
       payload: inputData,
       resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
       resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
     };
   }
 };
+var 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;
@@ -308,38 +519,90 @@ var InngestRun = class extends workflows.Run {
     this.#mastra = params.mastra;
   }
   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}`
+    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)));
+        }
       }
-    });
-    const json = await response.json();
-    return json.data;
+    }
+    throw new inngest.NonRetriableError(`Failed to get runs after ${maxRetries} attempts: ${lastError?.message}`);
   }
-  async getRunOutput(eventId) {
-    let runs = await this.getRuns(eventId);
+  async getRunOutput(eventId, maxWaitMs = 3e5) {
+    const startTime = Date.now();
     const storage = this.#mastra?.getStorage();
-    while (runs?.[0]?.status !== "Completed" || runs?.[0]?.event_id !== eventId) {
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      runs = await this.getRuns(eventId);
+    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 storage?.loadWorkflowSnapshot({
+        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", error: runs?.[0]?.output?.message } }
+          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 storage?.loadWorkflowSnapshot({
+        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));
     }
-    return runs?.[0];
+    throw new inngest.NonRetriableError(`Workflow did not complete within ${maxWaitMs}ms`);
   }
   async cancel() {
     const storage = this.#mastra?.getStorage();
@@ -349,12 +612,13 @@ var InngestRun = class extends workflows.Run {
         runId: this.runId
       }
     });
-    const snapshot = await storage?.loadWorkflowSnapshot({
+    const workflowsStore = await storage?.getStore("workflows");
+    const snapshot = await workflowsStore?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
     if (snapshot) {
-      await storage?.persistWorkflowSnapshot({
+      await workflowsStore?.persistWorkflowSnapshot({
         workflowName: this.workflowId,
         runId: this.runId,
         resourceId: this.resourceId,
@@ -369,15 +633,64 @@ var InngestRun = class extends workflows.Run {
   async start(params) {
     return this._start(params);
   }
+  /**
+   * 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(params) {
+    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(params.inputData);
+    const initialStateToUse = await this._validateInitialState(params.initialState ?? {});
+    const eventOutput = await this.inngest.send({
+      name: `workflow.${this.workflowId}`,
+      data: {
+        inputData: inputDataToUse,
+        initialState: initialStateToUse,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        outputOptions: params.outputOptions,
+        tracingOptions: params.tracingOptions,
+        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");
+    }
+    return { runId: this.runId };
+  }
   async _start({
     inputData,
     initialState,
     outputOptions,
     tracingOptions,
     format,
-    requestContext
+    requestContext,
+    perStep
   }) {
-    await this.#mastra.getStorage()?.persistWorkflowSnapshot({
+    const workflowsStore = await this.#mastra.getStorage()?.getStore("workflows");
+    await workflowsStore?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId,
       resourceId: this.resourceId,
@@ -407,7 +720,8 @@ var InngestRun = class extends workflows.Run {
         outputOptions,
         tracingOptions,
         format,
-        requestContext: requestContext ? Object.fromEntries(requestContext.entries()) : {}
+        requestContext: requestContext ? Object.fromEntries(requestContext.entries()) : {},
+        perStep
       }
     });
     const eventId = eventOutput.ids[0];
@@ -416,9 +730,7 @@ var InngestRun = class extends workflows.Run {
     }
     const runOutput = await this.getRunOutput(eventId);
     const result = runOutput?.output?.result;
-    if (result.status === "failed") {
-      result.error = new Error(result.error);
-    }
+    this.hydrateFailedResult(result);
     if (result.status !== "suspended") {
       this.cleanup?.();
     }
@@ -445,7 +757,8 @@ var InngestRun = class extends workflows.Run {
         (step) => typeof step === "string" ? step : step?.id
       );
     }
-    const snapshot = await storage?.loadWorkflowSnapshot({
+    const workflowsStore = await storage?.getStore("workflows");
+    const snapshot = await workflowsStore?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
@@ -468,7 +781,8 @@ var InngestRun = class extends workflows.Run {
           resumePayload: resumeDataToUse,
           resumePath: steps?.[0] ? snapshot?.suspendedPaths?.[steps?.[0]] : void 0
         },
-        requestContext: mergedRequestContext
+        requestContext: mergedRequestContext,
+        perStep: params.perStep
       }
     });
     const eventId = eventOutput.ids[0];
@@ -477,9 +791,7 @@ var InngestRun = class extends workflows.Run {
     }
     const runOutput = await this.getRunOutput(eventId);
     const result = runOutput?.output?.result;
-    if (result.status === "failed") {
-      result.error = new Error(result.error);
-    }
+    this.hydrateFailedResult(result);
     return result;
   }
   async timeTravel(params) {
@@ -509,12 +821,13 @@ var InngestRun = class extends workflows.Run {
       throw new Error("No steps provided to timeTravel");
     }
     const storage = this.#mastra?.getStorage();
-    const snapshot = await storage?.loadWorkflowSnapshot({
+    const workflowsStore = await storage?.getStore("workflows");
+    const snapshot = await workflowsStore?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
     if (!snapshot) {
-      await storage?.persistWorkflowSnapshot({
+      await workflowsStore?.persistWorkflowSnapshot({
         workflowName: this.workflowId,
         runId: this.runId,
         resourceId: this.resourceId,
@@ -548,7 +861,8 @@ var InngestRun = class extends workflows.Run {
       nestedStepsContext: params.nestedStepsContext,
       snapshot: snapshot ?? { context: {} },
       graph: this.executionGraph,
-      initialState: params.initialState
+      initialState: params.initialState,
+      perStep: params.perStep
     });
     const eventOutput = await this.inngest.send({
       name: `workflow.${this.workflowId}`,
@@ -560,7 +874,8 @@ var InngestRun = class extends workflows.Run {
         timeTravel: timeTravelData,
         tracingOptions: params.tracingOptions,
         outputOptions: params.outputOptions,
-        requestContext: params.requestContext ? Object.fromEntries(params.requestContext.entries()) : {}
+        requestContext: params.requestContext ? Object.fromEntries(params.requestContext.entries()) : {},
+        perStep: params.perStep
       }
     });
     const eventId = eventOutput.ids[0];
@@ -569,9 +884,7 @@ var InngestRun = class extends workflows.Run {
     }
     const runOutput = await this.getRunOutput(eventId);
     const result = runOutput?.output?.result;
-    if (result.status === "failed") {
-      result.error = new Error(result.error);
-    }
+    this.hydrateFailedResult(result);
     return result;
   }
   watch(cb) {
@@ -653,7 +966,8 @@ var InngestRun = class extends workflows.Run {
     tracingOptions,
     closeOnSuspend = true,
     initialState,
-    outputOptions
+    outputOptions,
+    perStep
   } = {}) {
     if (this.closeStreamAction && this.streamOutput) {
       return this.streamOutput;
@@ -689,7 +1003,8 @@ var InngestRun = class extends workflows.Run {
           initialState,
           tracingOptions,
           outputOptions,
-          format: "vnext"
+          format: "vnext",
+          perStep
         });
         let executionResults;
         try {
@@ -720,9 +1035,6 @@ var InngestRun = class extends workflows.Run {
     });
     return this.streamOutput;
   }
-  streamVNext(args = {}) {
-    return this.stream(args);
-  }
   timeTravelStream({
     inputData,
     resumeData,
@@ -732,7 +1044,8 @@ var InngestRun = class extends workflows.Run {
     nestedStepsContext,
     requestContext,
     tracingOptions,
-    outputOptions
+    outputOptions,
+    perStep
   }) {
     this.closeStreamAction = async () => {
     };
@@ -767,7 +1080,8 @@ var InngestRun = class extends workflows.Run {
           initialState,
           requestContext,
           tracingOptions,
-          outputOptions
+          outputOptions,
+          perStep
         });
         self.executionResults = executionResultsPromise;
         let executionResults;
@@ -792,6 +1106,18 @@ var InngestRun = class extends workflows.Run {
     });
     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
@@ -799,9 +1125,11 @@ 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(
@@ -810,6 +1138,9 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     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();
@@ -817,7 +1148,11 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
       return { runs: [], total: 0 };
     }
-    return storage.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
+    const workflowsStore = await storage.getStore("workflows");
+    if (!workflowsStore) {
+      return { runs: [], total: 0 };
+    }
+    return workflowsStore.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
   async getWorkflowRunById(runId) {
     const storage = this.#mastra?.getStorage();
@@ -825,10 +1160,15 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       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 run = await storage.getWorkflowRunById({ runId, workflowName: this.id });
+    const workflowsStore = await storage.getStore("workflows");
+    if (!workflowsStore) {
+      return this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null;
+    }
+    const run = await workflowsStore.getWorkflowRunById({ runId, workflowName: this.id });
     return run ?? (this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null);
   }
   __registerMastra(mastra) {
+    super.__registerMastra(mastra);
     this.#mastra = mastra;
     this.executionEngine.__registerMastra(mastra);
     const updateNested = (step) => {
@@ -847,7 +1187,7 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     }
   }
   async createRun(options) {
-    const runIdToUse = options?.runId || crypto.randomUUID();
+    const runIdToUse = options?.runId || crypto$1.randomUUID();
     const run = this.runs.get(runIdToUse) ?? new InngestRun(
       {
         workflowId: this.id,
@@ -870,9 +1210,12 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       workflowStatus: run.workflowRunStatus,
       stepResults: {}
     });
-    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, false);
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, {
+      withNestedWorkflows: false
+    });
     if (!workflowSnapshotInStorage && shouldPersistSnapshot) {
-      await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+      const workflowsStore = await this.mastra?.getStorage()?.getStore("workflows");
+      await workflowsStore?.persistWorkflowSnapshot({
         workflowName: this.id,
         runId: runIdToUse,
         resourceId: options?.resourceId,
@@ -895,6 +1238,30 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     }
     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;
@@ -902,41 +1269,20 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     this.function = this.inngest.createFunction(
       {
         id: `workflow.${this.id}`,
-        retries: Math.min(this.retryConfig?.attempts ?? 0, 20),
+        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, format, timeTravel } = event.data;
+        let { inputData, initialState, runId, resourceId, resume, outputOptions, format, timeTravel, perStep } = 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;
-            }
-            try {
-              await publish({
-                channel: `workflow:${this.id}:${runId}`,
-                topic: event2,
-                data
-              });
-            } catch (err) {
-              this.logger.error("Error emitting event: " + (err?.stack ?? err?.message ?? err));
-            }
-          },
-          on: (_event, _callback) => {
-          },
-          off: (_event, _callback) => {
-          },
-          once: (_event, _callback) => {
-          }
-        };
+        const pubsub = new InngestPubSub(this.inngest, this.id, publish);
         const engine = new InngestExecutionEngine(this.#mastra, step, attempt, this.options);
         const result = await engine.execute({
           workflowId: this.id,
@@ -946,21 +1292,32 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
           serializedStepGraph: this.serializedStepGraph,
           input: inputData,
           initialState,
-          emitter,
+          pubsub,
           retryConfig: this.retryConfig,
           requestContext: new di.RequestContext(Object.entries(event.data.requestContext ?? {})),
           resume,
           timeTravel,
+          perStep,
           format,
           abortController: new AbortController(),
           // currentSpan: undefined, // TODO: Pass actual parent Span from workflow execution context
           outputOptions,
           outputWriter: async (chunk) => {
-            void emitter.emit("watch", chunk).catch(() => {
-            });
+            try {
+              await pubsub.publish(`workflow.events.v2.${runId}`, {
+                type: "watch",
+                runId,
+                data: chunk
+              });
+            } catch (err) {
+              this.logger.debug?.("Failed to publish watch event:", err);
+            }
           }
         });
         await step.run(`workflow.${this.id}.finalize`, async () => {
+          if (result.status !== "paused") {
+            await engine.invokeLifecycleCallbacksInternal(result);
+          }
           if (result.status === "failed") {
             throw new inngest.NonRetriableError(`Workflow failed`, {
               cause: result
@@ -987,7 +1344,11 @@ 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 serve({
@@ -1019,20 +1380,14 @@ function serve({
 var _compatibilityCheck = true;
 
 // src/index.ts
-function isAgent(params) {
-  return params?.component === "AGENT";
-}
-function isTool(params) {
-  return params instanceof tools.Tool;
-}
-function isInngestWorkflow(params) {
-  return params instanceof InngestWorkflow;
-}
-function createStep(params, agentOptions) {
-  if (isInngestWorkflow(params)) {
+function createStep(params, agentOrToolOptions) {
+  if (params instanceof InngestWorkflow) {
     return params;
   }
-  if (isAgent(params)) {
+  if (params instanceof agent.Agent) {
+    const options = agentOrToolOptions;
+    const outputSchema = options?.structuredOutput?.schema ?? zod.z.object({ text: zod.z.string() });
+    const { retries, scorers, ...agentOptions } = options ?? {};
     return {
       id: params.name,
       description: params.getDescription(),
@@ -1041,12 +1396,13 @@ function createStep(params, agentOptions) {
         // resourceId: z.string().optional(),
         // threadId: z.string().optional(),
       }),
-      outputSchema: zod.z.object({
-        text: zod.z.string()
-      }),
+      outputSchema,
+      retries,
+      scorers,
       execute: async ({
         inputData,
-        [_constants.EMITTER_SYMBOL]: emitter,
+        runId,
+        [_constants.PUBSUB_SYMBOL]: pubsub,
         [_constants.STREAM_FORMAT_SYMBOL]: streamFormat,
         requestContext,
         tracingContext,
@@ -1059,6 +1415,7 @@ function createStep(params, agentOptions) {
           streamPromise.resolve = resolve;
           streamPromise.reject = reject;
         });
+        let structuredResult = null;
         const toolData = {
           name: params.name,
           args: inputData
@@ -1072,6 +1429,10 @@ function createStep(params, 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);
             },
@@ -1084,6 +1445,10 @@ function createStep(params, 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);
             },
@@ -1092,22 +1457,24 @@ function createStep(params, agentOptions) {
           stream = modelOutput.fullStream;
         }
         if (streamFormat === "legacy") {
-          await emitter.emit("watch", {
-            type: "tool-call-streaming-start",
-            ...toolData ?? {}
+          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 emitter.emit("watch", {
-                type: "tool-call-delta",
-                ...toolData ?? {},
-                argsTextDelta: chunk.textDelta
+              await pubsub.publish(`workflow.events.v2.${runId}`, {
+                type: "watch",
+                runId,
+                data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
               });
             }
           }
-          await emitter.emit("watch", {
-            type: "tool-call-streaming-finish",
-            ...toolData ?? {}
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
           });
         } else {
           for await (const chunk of stream) {
@@ -1117,6 +1484,9 @@ function createStep(params, agentOptions) {
         if (abortSignal.aborted) {
           return abort();
         }
+        if (structuredResult !== null) {
+          return structuredResult;
+        }
         return {
           text: await streamPromise.promise
         };
@@ -1124,7 +1494,8 @@ function createStep(params, agentOptions) {
       component: params.component
     };
   }
-  if (isTool(params)) {
+  if (params instanceof tools.Tool) {
+    const toolOpts = agentOrToolOptions;
     if (!params.inputSchema || !params.outputSchema) {
       throw new Error("Tool must have input and output schemas defined");
     }
@@ -1136,6 +1507,8 @@ function createStep(params, agentOptions) {
       outputSchema: params.outputSchema,
       suspendSchema: params.suspendSchema,
       resumeSchema: params.resumeSchema,
+      retries: toolOpts?.retries,
+      scorers: toolOpts?.scorers,
       execute: async ({
         inputData,
         mastra,
@@ -1173,6 +1546,8 @@ function createStep(params, agentOptions) {
     outputSchema: params.outputSchema,
     resumeSchema: params.resumeSchema,
     suspendSchema: params.suspendSchema,
+    retries: params.retries,
+    scorers: params.scorers,
     execute: params.execute
   };
 }
@@ -1217,6 +1592,7 @@ function init(inngest) {
 }
 
 exports.InngestExecutionEngine = InngestExecutionEngine;
+exports.InngestPubSub = InngestPubSub;
 exports.InngestRun = InngestRun;
 exports.InngestWorkflow = InngestWorkflow;
 exports._compatibilityCheck = _compatibilityCheck;