@mastra/inngest 0.0.0-bundle-recursion-20251030002519 → 0.0.0-client-js-listmessages-agentid-fix-20251119175531

package/dist/index.cjs

@@ -3,8 +3,8 @@
 var crypto = require('crypto');
 var web = require('stream/web');
 var realtime = require('@inngest/realtime');
-var aiTracing = require('@mastra/core/ai-tracing');
 var di = require('@mastra/core/di');
+var observability = require('@mastra/core/observability');
 var stream = require('@mastra/core/stream');
 var tools = require('@mastra/core/tools');
 var workflows = require('@mastra/core/workflows');
@@ -20,7 +20,7 @@ function serve({
   functions: userFunctions = [],
   registerOptions
 }) {
-  const wfs = mastra.getWorkflows();
+  const wfs = mastra.listWorkflows();
   const workflowFunctions = Array.from(
     new Set(
       Object.values(wfs).flatMap((wf) => {
@@ -59,11 +59,12 @@ var InngestRun = class extends workflows.Run {
   }
   async getRunOutput(eventId) {
     let runs = await this.getRuns(eventId);
+    const storage = this.#mastra?.getStorage();
     while (runs?.[0]?.status !== "Completed" || runs?.[0]?.event_id !== eventId) {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
       runs = await this.getRuns(eventId);
       if (runs?.[0]?.status === "Failed") {
-        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+        const snapshot = await storage?.loadWorkflowSnapshot({
           workflowName: this.workflowId,
           runId: this.runId
         });
@@ -72,7 +73,7 @@ var InngestRun = class extends workflows.Run {
         };
       }
       if (runs?.[0]?.status === "Cancelled") {
-        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+        const snapshot = await storage?.loadWorkflowSnapshot({
           workflowName: this.workflowId,
           runId: this.runId
         });
@@ -81,31 +82,27 @@ var InngestRun = class extends workflows.Run {
     }
     return runs?.[0];
   }
-  async sendEvent(event, data) {
-    await this.inngest.send({
-      name: `user-event-${event}`,
-      data
-    });
-  }
   async cancel() {
+    const storage = this.#mastra?.getStorage();
     await this.inngest.send({
       name: `cancel.workflow.${this.workflowId}`,
       data: {
         runId: this.runId
       }
     });
-    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+    const snapshot = await storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
     if (snapshot) {
-      await this.#mastra?.storage?.persistWorkflowSnapshot({
+      await storage?.persistWorkflowSnapshot({
         workflowName: this.workflowId,
         runId: this.runId,
         resourceId: this.resourceId,
         snapshot: {
           ...snapshot,
-          status: "canceled"
+          status: "canceled",
+          value: snapshot.value
         }
       });
     }
@@ -127,14 +124,15 @@ var InngestRun = class extends workflows.Run {
       snapshot: {
         runId: this.runId,
         serializedStepGraph: this.serializedStepGraph,
+        status: "running",
         value: {},
         context: {},
         activePaths: [],
         suspendedPaths: {},
+        activeStepsPath: {},
         resumeLabels: {},
         waitingPaths: {},
-        timestamp: Date.now(),
-        status: "running"
+        timestamp: Date.now()
       }
     });
     const inputDataToUse = await this._validateInput(inputData);
@@ -177,10 +175,16 @@ var InngestRun = class extends workflows.Run {
     return p;
   }
   async _resume(params) {
-    const steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
-      (step) => typeof step === "string" ? step : step?.id
-    );
-    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+    const storage = this.#mastra?.getStorage();
+    let steps = [];
+    if (typeof params.step === "string") {
+      steps = params.step.split(".");
+    } else {
+      steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
+        (step) => typeof step === "string" ? step : step?.id
+      );
+    }
+    const snapshot = await storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
@@ -198,9 +202,99 @@ var InngestRun = class extends workflows.Run {
           steps,
           stepResults: snapshot?.context,
           resumePayload: resumeDataToUse,
-          // @ts-ignore
-          resumePath: snapshot?.suspendedPaths?.[steps?.[0]]
+          resumePath: steps?.[0] ? snapshot?.suspendedPaths?.[steps?.[0]] : void 0
+        }
+      }
+    });
+    const eventId = eventOutput.ids[0];
+    if (!eventId) {
+      throw new Error("Event ID is not set");
+    }
+    const runOutput = await this.getRunOutput(eventId);
+    const result = runOutput?.output?.result;
+    if (result.status === "failed") {
+      result.error = new Error(result.error);
+    }
+    return result;
+  }
+  async timeTravel(params) {
+    const p = this._timeTravel(params).then((result) => {
+      if (result.status !== "suspended") {
+        this.closeStreamAction?.().catch(() => {
+        });
+      }
+      return result;
+    });
+    this.executionResults = p;
+    return p;
+  }
+  async _timeTravel(params) {
+    if (!params.step || Array.isArray(params.step) && params.step?.length === 0) {
+      throw new Error("Step is required and must be a valid step or array of steps");
+    }
+    let steps = [];
+    if (typeof params.step === "string") {
+      steps = params.step.split(".");
+    } else {
+      steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
+        (step) => typeof step === "string" ? step : step?.id
+      );
+    }
+    if (steps.length === 0) {
+      throw new Error("No steps provided to timeTravel");
+    }
+    const storage = this.#mastra?.getStorage();
+    const snapshot = await storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (!snapshot) {
+      await storage?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        snapshot: {
+          runId: this.runId,
+          serializedStepGraph: this.serializedStepGraph,
+          status: "pending",
+          value: {},
+          context: {},
+          activePaths: [],
+          suspendedPaths: {},
+          activeStepsPath: {},
+          resumeLabels: {},
+          waitingPaths: {},
+          timestamp: Date.now()
         }
+      });
+    }
+    if (snapshot?.status === "running") {
+      throw new Error("This workflow run is still running, cannot time travel");
+    }
+    let inputDataToUse = params.inputData;
+    if (inputDataToUse && steps.length === 1) {
+      inputDataToUse = await this._validateTimetravelInputData(params.inputData, this.workflowSteps[steps[0]]);
+    }
+    const timeTravelData = workflows.createTimeTravelExecutionParams({
+      steps,
+      inputData: inputDataToUse,
+      resumeData: params.resumeData,
+      context: params.context,
+      nestedStepsContext: params.nestedStepsContext,
+      snapshot: snapshot ?? { context: {} },
+      graph: this.executionGraph,
+      initialState: params.initialState
+    });
+    const eventOutput = await this.inngest.send({
+      name: `workflow.${this.workflowId}`,
+      data: {
+        initialState: timeTravelData.state,
+        runId: this.runId,
+        workflowId: this.workflowId,
+        stepResults: timeTravelData.stepResults,
+        timeTravel: timeTravelData,
+        tracingOptions: params.tracingOptions,
+        outputOptions: params.outputOptions
       }
     });
     const eventId = eventOutput.ids[0];
@@ -214,12 +308,12 @@ var InngestRun = class extends workflows.Run {
     }
     return result;
   }
-  watch(cb, type = "watch") {
+  watch(cb) {
     let active = true;
     const streamPromise = realtime.subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: [type],
+        topics: ["watch"],
         app: this.inngest
       },
       (message) => {
@@ -237,7 +331,7 @@ var InngestRun = class extends workflows.Run {
       });
     };
   }
-  streamLegacy({ inputData, runtimeContext } = {}) {
+  streamLegacy({ inputData, requestContext } = {}) {
     const { readable, writable } = new TransformStream();
     const writer = writable.getWriter();
     const unwatch = this.watch(async (event) => {
@@ -259,7 +353,7 @@ var InngestRun = class extends workflows.Run {
         await writer.write(e);
       } catch {
       }
-    }, "watch-v2");
+    });
     this.closeStreamAction = async () => {
       await writer.write({
         type: "finish",
@@ -275,7 +369,7 @@ var InngestRun = class extends workflows.Run {
         writer.releaseLock();
       }
     };
-    this.executionResults = this._start({ inputData, runtimeContext, format: "legacy" }).then((result) => {
+    this.executionResults = this._start({ inputData, requestContext, format: "legacy" }).then((result) => {
       if (result.status !== "suspended") {
         this.closeStreamAction?.().catch(() => {
         });
@@ -289,7 +383,7 @@ var InngestRun = class extends workflows.Run {
   }
   stream({
     inputData,
-    runtimeContext,
+    requestContext,
     tracingOptions,
     closeOnSuspend = true,
     initialState,
@@ -313,7 +407,7 @@ var InngestRun = class extends workflows.Run {
               ...payload
             }
           });
-        }, "watch-v2");
+        });
         self.closeStreamAction = async () => {
           unwatch();
           try {
@@ -324,7 +418,7 @@ var InngestRun = class extends workflows.Run {
         };
         const executionResultsPromise = self._start({
           inputData,
-          runtimeContext,
+          requestContext,
           // tracingContext, // We are not able to pass a reference to a span here, what to do?
           initialState,
           tracingOptions,
@@ -363,6 +457,75 @@ var InngestRun = class extends workflows.Run {
   streamVNext(args = {}) {
     return this.stream(args);
   }
+  timeTravelStream({
+    inputData,
+    resumeData,
+    initialState,
+    step,
+    context,
+    nestedStepsContext,
+    requestContext,
+    tracingOptions,
+    outputOptions
+  }) {
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream$1 = new web.ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = stream.ChunkFrom.WORKFLOW, payload }) => {
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            await controller.close();
+          } catch (err) {
+            console.error("Error closing stream:", err);
+          }
+        };
+        const executionResultsPromise = self._timeTravel({
+          inputData,
+          step,
+          context,
+          nestedStepsContext,
+          resumeData,
+          initialState,
+          requestContext,
+          tracingOptions,
+          outputOptions
+        });
+        self.executionResults = executionResultsPromise;
+        let executionResults;
+        try {
+          executionResults = await executionResultsPromise;
+          self.closeStreamAction?.().catch(() => {
+          });
+          if (self.streamOutput) {
+            self.streamOutput.updateResults(executionResults);
+          }
+        } catch (err) {
+          self.streamOutput?.rejectResults(err);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new stream.WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream: stream$1
+    });
+    return this.streamOutput;
+  }
 };
 var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
   #mastra;
@@ -372,6 +535,7 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
   constructor(params, inngest) {
     const { concurrency, rateLimit, throttle, debounce, priority, ...workflowParams } = params;
     super(workflowParams);
+    this.engineType = "inngest";
     const flowControlEntries = Object.entries({ concurrency, rateLimit, throttle, debounce, priority }).filter(
       ([_, value]) => value !== void 0
     );
@@ -379,13 +543,13 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     this.#mastra = params.mastra;
     this.inngest = inngest;
   }
-  async getWorkflowRuns(args) {
+  async listWorkflowRuns(args) {
     const storage = this.#mastra?.getStorage();
     if (!storage) {
       this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
       return { runs: [], total: 0 };
     }
-    return storage.getWorkflowRuns({ workflowName: this.id, ...args ?? {} });
+    return storage.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
   async getWorkflowRunById(runId) {
     const storage = this.#mastra?.getStorage();
@@ -414,16 +578,7 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
       }
     }
   }
-  /**
-   * @deprecated Use createRunAsync() instead.
-   * @throws {Error} Always throws an error directing users to use createRunAsync()
-   */
-  createRun(_options) {
-    throw new Error(
-      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = workflow.createRun();\n  After:  const run = await workflow.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
-    );
-  }
-  async createRunAsync(options) {
+  async createRun(options) {
     const runIdToUse = options?.runId || crypto.randomUUID();
     const run = this.runs.get(runIdToUse) ?? new InngestRun(
       {
@@ -436,7 +591,9 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
         mastra: this.#mastra,
         retryConfig: this.retryConfig,
         cleanup: () => this.runs.delete(runIdToUse),
-        workflowSteps: this.steps
+        workflowSteps: this.steps,
+        workflowEngineType: this.engineType,
+        validateInputs: this.options.validateInputs
       },
       this.inngest
     );
@@ -457,13 +614,13 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
           value: {},
           context: {},
           activePaths: [],
+          activeStepsPath: {},
           waitingPaths: {},
           serializedStepGraph: this.serializedStepGraph,
           suspendedPaths: {},
           resumeLabels: {},
           result: void 0,
           error: void 0,
-          // @ts-ignore
           timestamp: Date.now()
         }
       });
@@ -477,15 +634,14 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     this.function = this.inngest.createFunction(
       {
         id: `workflow.${this.id}`,
-        // @ts-ignore
-        retries: this.retryConfig?.attempts ?? 0,
+        retries: Math.min(this.retryConfig?.attempts ?? 0, 20),
         cancelOn: [{ event: `cancel.workflow.${this.id}` }],
         // Spread flow control configuration
         ...this.flowControlConfig
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, initialState, runId, resourceId, resume, outputOptions, format } = event.data;
+        let { inputData, initialState, runId, resourceId, resume, outputOptions, format, timeTravel } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
             return crypto.randomUUID();
@@ -524,16 +680,17 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
           initialState,
           emitter,
           retryConfig: this.retryConfig,
-          runtimeContext: new di.RuntimeContext(),
+          requestContext: new di.RequestContext(),
           // TODO
           resume,
+          timeTravel,
           format,
           abortController: new AbortController(),
-          // currentSpan: undefined, // TODO: Pass actual parent AI span from workflow execution context
+          // currentSpan: undefined, // TODO: Pass actual parent Span from workflow execution context
           outputOptions,
-          writableStream: new WritableStream({
+          writableStream: new web.WritableStream({
             write(chunk) {
-              void emitter.emit("watch-v2", chunk).catch(() => {
+              void emitter.emit("watch", chunk).catch(() => {
               });
             }
           })
@@ -579,13 +736,11 @@ function createStep(params, agentOptions) {
     return {
       id: params.name,
       description: params.getDescription(),
-      // @ts-ignore
       inputSchema: zod.z.object({
         prompt: zod.z.string()
         // resourceId: z.string().optional(),
         // threadId: z.string().optional(),
       }),
-      // @ts-ignore
       outputSchema: zod.z.object({
         text: zod.z.string()
       }),
@@ -593,7 +748,7 @@ function createStep(params, agentOptions) {
         inputData,
         [_constants.EMITTER_SYMBOL]: emitter,
         [_constants.STREAM_FORMAT_SYMBOL]: streamFormat,
-        runtimeContext,
+        requestContext,
         tracingContext,
         abortSignal,
         abort,
@@ -614,7 +769,7 @@ function createStep(params, agentOptions) {
             ...agentOptions ?? {},
             // resourceId: inputData.resourceId,
             // threadId: inputData.threadId,
-            runtimeContext,
+            requestContext,
             tracingContext,
             onFinish: (result) => {
               streamPromise.resolve(result.text);
@@ -626,7 +781,7 @@ function createStep(params, agentOptions) {
         } else {
           const modelOutput = await params.stream(inputData.prompt, {
             ...agentOptions ?? {},
-            runtimeContext,
+            requestContext,
             tracingContext,
             onFinish: (result) => {
               streamPromise.resolve(result.text);
@@ -637,20 +792,20 @@ function createStep(params, agentOptions) {
           stream = modelOutput.fullStream;
         }
         if (streamFormat === "legacy") {
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "tool-call-streaming-start",
             ...toolData ?? {}
           });
           for await (const chunk of stream) {
             if (chunk.type === "text-delta") {
-              await emitter.emit("watch-v2", {
+              await emitter.emit("watch", {
                 type: "tool-call-delta",
                 ...toolData ?? {},
                 argsTextDelta: chunk.textDelta
               });
             }
           }
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "tool-call-streaming-finish",
             ...toolData ?? {}
           });
@@ -675,20 +830,36 @@ function createStep(params, agentOptions) {
     }
     return {
       // TODO: tool probably should have strong id type
-      // @ts-ignore
       id: params.id,
       description: params.description,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
-      execute: async ({ inputData, mastra, runtimeContext, tracingContext, suspend, resumeData }) => {
-        return params.execute({
-          context: inputData,
-          mastra: aiTracing.wrapMastra(mastra, tracingContext),
-          runtimeContext,
+      execute: async ({
+        inputData,
+        mastra,
+        requestContext,
+        tracingContext,
+        suspend,
+        resumeData,
+        runId,
+        workflowId,
+        state,
+        setState
+      }) => {
+        const toolContext = {
+          mastra,
+          requestContext,
           tracingContext,
-          suspend,
-          resumeData
-        });
+          resumeData,
+          workflow: {
+            runId,
+            suspend,
+            workflowId,
+            state,
+            setState
+          }
+        };
+        return params.execute(inputData, toolContext);
       },
       component: "TOOL"
     };
@@ -722,6 +893,8 @@ function init(inngest) {
         suspendSchema: step.suspendSchema,
         stateSchema: step.stateSchema,
         execute: step.execute,
+        retries: step.retries,
+        scorers: step.scorers,
         component: step.component
       };
     },
@@ -753,45 +926,10 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       steps: stepResults
     };
     if (lastOutput.status === "success") {
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: lastOutput.output
-          }
-        },
-        eventTimestamp: Date.now()
-      });
       base.result = lastOutput.output;
     } else if (lastOutput.status === "failed") {
       base.error = error instanceof Error ? error?.stack ?? error.message : lastOutput?.error instanceof Error ? lastOutput.error.message : lastOutput.error ?? error ?? "Unknown error";
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: null,
-            error: base.error
-          }
-        },
-        eventTimestamp: Date.now()
-      });
     } else if (lastOutput.status === "suspended") {
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: null,
-            error: null
-          }
-        },
-        eventTimestamp: Date.now()
-      });
       const suspendedStepIds = Object.entries(stepResults).flatMap(([stepId, stepResult]) => {
         if (stepResult?.status === "suspended") {
           const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
@@ -814,14 +952,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     stepResults,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     executionContext,
     writableStream,
     tracingContext
   }) {
     let { duration, fn } = entry;
     const sleepSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: aiTracing.AISpanType.WORKFLOW_SLEEP,
+      type: observability.SpanType.WORKFLOW_SLEEP,
       name: `sleep: ${duration ? `${duration}ms` : "dynamic"}`,
       attributes: {
         durationMs: duration,
@@ -838,13 +976,12 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               runId,
               workflowId,
               mastra: this.mastra,
-              runtimeContext,
+              requestContext,
               inputData: prevOutput,
               state: executionContext.state,
               setState: (state) => {
                 executionContext.state = state;
               },
-              runCount: -1,
               retryCount: -1,
               tracingContext: {
                 currentSpan: sleepSpan
@@ -903,14 +1040,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     stepResults,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     executionContext,
     writableStream,
     tracingContext
   }) {
     let { date, fn } = entry;
     const sleepUntilSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: aiTracing.AISpanType.WORKFLOW_SLEEP,
+      type: observability.SpanType.WORKFLOW_SLEEP,
       name: `sleepUntil: ${date ? date.toISOString() : "dynamic"}`,
       attributes: {
         untilDate: date,
@@ -928,13 +1065,12 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               runId,
               workflowId,
               mastra: this.mastra,
-              runtimeContext,
+              requestContext,
               inputData: prevOutput,
               state: executionContext.state,
               setState: (state) => {
                 executionContext.state = state;
               },
-              runCount: -1,
               retryCount: -1,
               tracingContext: {
                 currentSpan: sleepUntilSpan
@@ -993,32 +1129,23 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       throw e;
     }
   }
-  async executeWaitForEvent({ event, timeout }) {
-    const eventData = await this.inngestStep.waitForEvent(`user-event-${event}`, {
-      event: `user-event-${event}`,
-      timeout: timeout ?? 5e3
-    });
-    if (eventData === null) {
-      throw "Timeout waiting for event";
-    }
-    return eventData?.data;
-  }
   async executeStep({
     step,
     stepResults,
     executionContext,
     resume,
+    timeTravel,
     prevOutput,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     tracingContext,
     writableStream,
     disableScorers
   }) {
-    const stepAISpan = tracingContext?.currentSpan?.createChildSpan({
+    const stepSpan = tracingContext?.currentSpan?.createChildSpan({
       name: `workflow step: '${step.id}'`,
-      type: aiTracing.AISpanType.WORKFLOW_STEP,
+      type: observability.SpanType.WORKFLOW_STEP,
       input: prevOutput,
       attributes: {
         stepId: step.id
@@ -1028,34 +1155,13 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     const { inputData, validationError } = await workflows.validateStepInput({
       prevOutput,
       step,
-      validateInputs: this.options?.validateInputs ?? false
+      validateInputs: this.options?.validateInputs ?? true
     });
     const startedAt = await this.inngestStep.run(
       `workflow.${executionContext.workflowId}.run.${executionContext.runId}.step.${step.id}.running_ev`,
       async () => {
         const startedAt2 = Date.now();
         await emitter.emit("watch", {
-          type: "watch",
-          payload: {
-            currentStep: {
-              id: step.id,
-              status: "running"
-            },
-            workflowState: {
-              status: "running",
-              steps: {
-                ...stepResults,
-                [step.id]: {
-                  status: "running"
-                }
-              },
-              result: null,
-              error: null
-            }
-          },
-          eventTimestamp: Date.now()
-        });
-        await emitter.emit("watch-v2", {
           type: "workflow-step-start",
           payload: {
             id: step.id,
@@ -1071,9 +1177,10 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       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();
+          runId = stepResults[resume?.steps?.[0] ?? ""]?.suspendPayload?.__workflow_meta?.runId ?? crypto.randomUUID();
           const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
             workflowName: step.id,
             runId
@@ -1089,8 +1196,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                 steps: resume.steps.slice(1),
                 stepResults: snapshot?.context,
                 resumePayload: resume.resumePayload,
-                // @ts-ignore
-                resumePath: snapshot?.suspendedPaths?.[resume.steps?.[1]]
+                resumePath: resume.steps?.[1] ? snapshot?.suspendedPaths?.[resume.steps?.[1]] : void 0
               },
               outputOptions: { includeState: true }
             }
@@ -1098,6 +1204,32 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           result = invokeResp.result;
           runId = invokeResp.runId;
           executionContext.state = invokeResp.result.state;
+        } else if (isTimeTravel) {
+          const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
+            workflowName: step.id,
+            runId: executionContext.runId
+          }) ?? { context: {} };
+          const timeTravelParams = workflows.createTimeTravelExecutionParams({
+            steps: timeTravel.steps.slice(1),
+            inputData: timeTravel.inputData,
+            resumeData: timeTravel.resumeData,
+            context: timeTravel.nestedStepResults?.[step.id] ?? {},
+            nestedStepsContext: timeTravel.nestedStepResults ?? {},
+            snapshot,
+            graph: step.buildExecutionGraph()
+          });
+          const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
+            function: step.getFunction(),
+            data: {
+              timeTravel: timeTravelParams,
+              initialState: executionContext.state ?? {},
+              runId: executionContext.runId,
+              outputOptions: { includeState: true }
+            }
+          });
+          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(),
@@ -1131,23 +1263,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
         async () => {
           if (result.status === "failed") {
             await emitter.emit("watch", {
-              type: "watch",
-              payload: {
-                currentStep: {
-                  id: step.id,
-                  status: "failed",
-                  error: result?.error
-                },
-                workflowState: {
-                  status: "running",
-                  steps: stepResults,
-                  result: null,
-                  error: null
-                }
-              },
-              eventTimestamp: Date.now()
-            });
-            await emitter.emit("watch-v2", {
               type: "workflow-step-result",
               payload: {
                 id: step.id,
@@ -1166,27 +1281,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               const suspendPath = [stepName, ...stepResult?.suspendPayload?.__workflow_meta?.path ?? []];
               executionContext.suspendedPaths[step.id] = executionContext.executionPath;
               await emitter.emit("watch", {
-                type: "watch",
-                payload: {
-                  currentStep: {
-                    id: step.id,
-                    status: "suspended",
-                    payload: stepResult.payload,
-                    suspendPayload: {
-                      ...stepResult?.suspendPayload,
-                      __workflow_meta: { runId, path: suspendPath }
-                    }
-                  },
-                  workflowState: {
-                    status: "running",
-                    steps: stepResults,
-                    result: null,
-                    error: null
-                  }
-                },
-                eventTimestamp: Date.now()
-              });
-              await emitter.emit("watch-v2", {
                 type: "workflow-step-suspended",
                 payload: {
                   id: step.id,
@@ -1205,23 +1299,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                 }
               };
             }
-            await emitter.emit("watch", {
-              type: "watch",
-              payload: {
-                currentStep: {
-                  id: step.id,
-                  status: "suspended",
-                  payload: {}
-                },
-                workflowState: {
-                  status: "running",
-                  steps: stepResults,
-                  result: null,
-                  error: null
-                }
-              },
-              eventTimestamp: Date.now()
-            });
             return {
               executionContext,
               result: {
@@ -1231,23 +1308,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             };
           }
           await emitter.emit("watch", {
-            type: "watch",
-            payload: {
-              currentStep: {
-                id: step.id,
-                status: "success",
-                output: result?.result
-              },
-              workflowState: {
-                status: "running",
-                steps: stepResults,
-                result: null,
-                error: null
-              }
-            },
-            eventTimestamp: Date.now()
-          });
-          await emitter.emit("watch-v2", {
             type: "workflow-step-result",
             payload: {
               id: step.id,
@@ -1255,7 +1315,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               output: result?.result
             }
           });
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-finish",
             payload: {
               id: step.id,
@@ -1282,14 +1342,32 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
         let execResults;
         let suspended;
         let bailed;
+        const { resumeData: timeTravelResumeData, validationError: timeTravelResumeValidationError } = await workflows.validateStepResumeData({
+          resumeData: timeTravel?.stepResults[step.id]?.status === "suspended" ? timeTravel?.resumeData : void 0,
+          step
+        });
+        let resumeDataToUse;
+        if (timeTravelResumeData && !timeTravelResumeValidationError) {
+          resumeDataToUse = timeTravelResumeData;
+        } else if (timeTravelResumeData && timeTravelResumeValidationError) {
+          this.logger.warn("Time travel resume data validation failed", {
+            stepId: step.id,
+            error: timeTravelResumeValidationError.message
+          });
+        } else if (resume?.steps[0] === step.id) {
+          resumeDataToUse = resume?.resumePayload;
+        }
         try {
           if (validationError) {
             throw validationError;
           }
+          const retryCount = this.getOrGenerateRetryCount(step.id);
           const result = await step.execute({
             runId: executionContext.runId,
+            workflowId: executionContext.workflowId,
             mastra: this.mastra,
-            runtimeContext,
+            requestContext,
+            retryCount,
             writer: new tools.ToolStream(
               {
                 prefix: "workflow-step",
@@ -1304,9 +1382,9 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               executionContext.state = state;
             },
             inputData,
-            resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
+            resumeData: resumeDataToUse,
             tracingContext: {
-              currentSpan: stepAISpan
+              currentSpan: stepSpan
             },
             getInitData: () => stepResults?.input,
             getStepResult: workflows.getStepResult.bind(this, stepResults),
@@ -1326,11 +1404,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             bail: (result2) => {
               bailed = { payload: result2 };
             },
-            resume: {
-              steps: resume?.steps?.slice(1) || [],
-              resumePayload: resume?.resumePayload,
-              // @ts-ignore
-              runId: stepResults[step.id]?.suspendPayload?.__workflow_meta?.runId
+            abort: () => {
+              abortController?.abort();
             },
             [_constants.EMITTER_SYMBOL]: emitter,
             [_constants.STREAM_FORMAT_SYMBOL]: executionContext.format,
@@ -1346,8 +1421,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             startedAt,
             endedAt,
             payload: inputData,
-            resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
-            resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+            resumedAt: resumeDataToUse ? startedAt : void 0,
+            resumePayload: resumeDataToUse
           };
         } catch (e) {
           const stepFailure = {
@@ -1356,12 +1431,12 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             error: e instanceof Error ? e.message : String(e),
             endedAt: Date.now(),
             startedAt,
-            resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
-            resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+            resumedAt: resumeDataToUse ? startedAt : void 0,
+            resumePayload: resumeDataToUse
           };
           execResults = stepFailure;
           const fallbackErrorMessage = `Step ${step.id} failed`;
-          stepAISpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
+          stepSpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
           throw new inngest.RetryAfterError(execResults.error ?? fallbackErrorMessage, executionContext.retryConfig.delay, {
             cause: execResults
           });
@@ -1370,11 +1445,12 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           execResults = {
             status: "suspended",
             suspendPayload: suspended.payload,
+            ...execResults.output ? { suspendOutput: execResults.output } : {},
             payload: inputData,
             suspendedAt: Date.now(),
             startedAt,
-            resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
-            resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+            resumedAt: resumeDataToUse ? startedAt : void 0,
+            resumePayload: resumeDataToUse
           };
         } else if (bailed) {
           execResults = {
@@ -1385,24 +1461,8 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             startedAt
           };
         }
-        await emitter.emit("watch", {
-          type: "watch",
-          payload: {
-            currentStep: {
-              id: step.id,
-              ...execResults
-            },
-            workflowState: {
-              status: "running",
-              steps: { ...stepResults, [step.id]: execResults },
-              result: null,
-              error: null
-            }
-          },
-          eventTimestamp: Date.now()
-        });
         if (execResults.status === "suspended") {
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-suspended",
             payload: {
               id: step.id,
@@ -1410,14 +1470,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             }
           });
         } else {
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-result",
             payload: {
               id: step.id,
               ...execResults
             }
           });
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-finish",
             payload: {
               id: step.id,
@@ -1425,7 +1485,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             }
           });
         }
-        stepAISpan?.end({ output: execResults });
+        stepSpan?.end({ output: execResults });
         return { result: execResults, executionContext, stepResults };
       });
     } catch (e) {
@@ -1455,15 +1515,14 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             output: stepRes.result,
             workflowId: executionContext.workflowId,
             stepId: step.id,
-            runtimeContext,
+            requestContext,
             disableScorers,
-            tracingContext: { currentSpan: stepAISpan }
+            tracingContext: { currentSpan: stepSpan }
           });
         }
       });
     }
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
-    Object.assign(stepResults, stepRes.stepResults);
     executionContext.state = stepRes.executionContext.state;
     return stepRes.result;
   }
@@ -1491,17 +1550,17 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           resourceId,
           snapshot: {
             runId,
+            status: workflowStatus,
             value: executionContext.state,
             context: stepResults,
-            activePaths: [],
+            activePaths: executionContext.executionPath,
+            activeStepsPath: executionContext.activeStepsPath,
             suspendedPaths: executionContext.suspendedPaths,
             resumeLabels: executionContext.resumeLabels,
             waitingPaths: {},
             serializedStepGraph,
-            status: workflowStatus,
             result,
             error,
-            // @ts-ignore
             timestamp: Date.now()
           }
         });
@@ -1514,17 +1573,18 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     entry,
     prevOutput,
     stepResults,
+    timeTravel,
     resume,
     executionContext,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     writableStream,
     disableScorers,
     tracingContext
   }) {
     const conditionalSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: aiTracing.AISpanType.WORKFLOW_CONDITIONAL,
+      type: observability.SpanType.WORKFLOW_CONDITIONAL,
       name: `conditional: '${entry.conditions.length} conditions'`,
       input: prevOutput,
       attributes: {
@@ -1537,7 +1597,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
       entry.conditions.map(
         (cond, index) => this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
           const evalSpan = conditionalSpan?.createChildSpan({
-            type: aiTracing.AISpanType.WORKFLOW_CONDITIONAL_EVAL,
+            type: observability.SpanType.WORKFLOW_CONDITIONAL_EVAL,
             name: `condition: '${index}'`,
             input: prevOutput,
             attributes: {
@@ -1552,8 +1612,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                   runId,
                   workflowId,
                   mastra: this.mastra,
-                  runtimeContext,
-                  runCount: -1,
+                  requestContext,
                   retryCount: -1,
                   inputData: prevOutput,
                   state: executionContext.state,
@@ -1633,10 +1692,12 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           prevOutput,
           stepResults,
           resume,
+          timeTravel,
           executionContext: {
             workflowId,
             runId,
             executionPath: [...executionContext.executionPath, index],
+            activeStepsPath: executionContext.activeStepsPath,
             suspendedPaths: executionContext.suspendedPaths,
             resumeLabels: executionContext.resumeLabels,
             retryConfig: executionContext.retryConfig,
@@ -1644,7 +1705,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           },
           emitter,
           abortController,
-          runtimeContext,
+          requestContext,
           writableStream,
           disableScorers,
           tracingContext: {
@@ -1660,13 +1721,19 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     if (hasFailed) {
       execResults = { status: "failed", error: hasFailed.error };
     } else if (hasSuspended) {
-      execResults = { status: "suspended", suspendPayload: hasSuspended.suspendPayload };
+      execResults = {
+        status: "suspended",
+        suspendPayload: hasSuspended.suspendPayload,
+        ...hasSuspended.suspendOutput ? { suspendOutput: hasSuspended.suspendOutput } : {}
+      };
     } else {
       execResults = {
         status: "success",
         output: results.reduce((acc, result, index) => {
           if (result.status === "success") {
-            acc[stepsToRun[index].step.id] = result.output;
+            if ("step" in stepsToRun[index]) {
+              acc[stepsToRun[index].step.id] = result.output;
+            }
           }
           return acc;
         }, {})