@mastra/inngest 0.18.5 → 0.18.6

package/dist/index.js

@@ -5,7 +5,7 @@ import { wrapMastra, AISpanType } from '@mastra/core/ai-tracing';
 import { RuntimeContext } from '@mastra/core/di';
 import { ChunkFrom, WorkflowRunOutput } from '@mastra/core/stream';
 import { ToolStream, Tool } from '@mastra/core/tools';
-import { Run, Workflow, DefaultExecutionEngine, getStepResult, validateStepInput } from '@mastra/core/workflows';
+import { Run, createTimeTravelExecutionParams, Workflow, DefaultExecutionEngine, getStepResult, validateStepInput, validateStepResumeData } from '@mastra/core/workflows';
 import { EMITTER_SYMBOL, STREAM_FORMAT_SYMBOL } from '@mastra/core/workflows/_constants';
 import { NonRetriableError, RetryAfterError } from 'inngest';
 import { serve as serve$1 } from 'inngest/hono';
@@ -103,7 +103,8 @@ var InngestRun = class extends Run {
         resourceId: this.resourceId,
         snapshot: {
           ...snapshot,
-          status: "canceled"
+          status: "canceled",
+          value: snapshot.value
         }
       });
     }
@@ -119,14 +120,15 @@ var InngestRun = class extends 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);
@@ -166,10 +168,16 @@ var InngestRun = class extends Run {
     return p;
   }
   async _resume(params) {
-    const steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
-      (step) => typeof step === "string" ? step : step?.id
-    );
-    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+    const storage = this.#mastra?.getStorage();
+    let steps = [];
+    if (typeof params.step === "string") {
+      steps = params.step.split(".");
+    } else {
+      steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
+        (step) => typeof step === "string" ? step : step?.id
+      );
+    }
+    const snapshot = await storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
@@ -226,6 +234,97 @@ var InngestRun = class extends Run {
       });
     };
   }
+  async timeTravel(params) {
+    const p = this._timeTravel(params).then((result) => {
+      if (result.status !== "suspended") {
+        this.closeStreamAction?.().catch(() => {
+        });
+      }
+      return result;
+    });
+    this.executionResults = p;
+    return p;
+  }
+  async _timeTravel(params) {
+    if (!params.step || Array.isArray(params.step) && params.step?.length === 0) {
+      throw new Error("Step is required and must be a valid step or array of steps");
+    }
+    let steps = [];
+    if (typeof params.step === "string") {
+      steps = params.step.split(".");
+    } else {
+      steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
+        (step) => typeof step === "string" ? step : step?.id
+      );
+    }
+    if (steps.length === 0) {
+      throw new Error("No steps provided to timeTravel");
+    }
+    const storage = this.#mastra?.getStorage();
+    const snapshot = await storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (!snapshot) {
+      await storage?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        snapshot: {
+          runId: this.runId,
+          serializedStepGraph: this.serializedStepGraph,
+          status: "pending",
+          value: {},
+          context: {},
+          activePaths: [],
+          suspendedPaths: {},
+          activeStepsPath: {},
+          resumeLabels: {},
+          waitingPaths: {},
+          timestamp: Date.now()
+        }
+      });
+    }
+    if (snapshot?.status === "running") {
+      throw new Error("This workflow run is still running, cannot time travel");
+    }
+    let inputDataToUse = params.inputData;
+    if (inputDataToUse && steps.length === 1) {
+      inputDataToUse = await this._validateTimetravelInputData(params.inputData, this.workflowSteps[steps[0]]);
+    }
+    const timeTravelData = createTimeTravelExecutionParams({
+      steps,
+      inputData: inputDataToUse,
+      resumeData: params.resumeData,
+      context: params.context,
+      nestedStepsContext: params.nestedStepsContext,
+      snapshot: snapshot ?? { context: {} },
+      graph: this.executionGraph,
+      initialState: params.initialState
+    });
+    const eventOutput = await this.inngest.send({
+      name: `workflow.${this.workflowId}`,
+      data: {
+        initialState: timeTravelData.state,
+        runId: this.runId,
+        workflowId: this.workflowId,
+        stepResults: timeTravelData.stepResults,
+        timeTravel: timeTravelData,
+        tracingOptions: params.tracingOptions,
+        outputOptions: params.outputOptions
+      }
+    });
+    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;
+  }
   streamLegacy({ inputData, runtimeContext } = {}) {
     const { readable, writable } = new TransformStream();
     const writer = writable.getWriter();
@@ -313,6 +412,74 @@ var InngestRun = class extends Run {
     });
     return streamOutput;
   }
+  timeTravelStream({
+    inputData,
+    resumeData,
+    initialState,
+    step,
+    context,
+    nestedStepsContext,
+    runtimeContext,
+    tracingOptions,
+    outputOptions
+  }) {
+    const self = this;
+    let streamOutput;
+    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
+            }
+          });
+        }, "watch-v2");
+        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,
+          runtimeContext,
+          tracingOptions,
+          outputOptions
+        });
+        self.executionResults = executionResultsPromise;
+        let executionResults;
+        try {
+          executionResults = await executionResultsPromise;
+          self.closeStreamAction?.().catch(() => {
+          });
+          if (streamOutput) {
+            streamOutput.updateResults(executionResults);
+          }
+        } catch (err) {
+          streamOutput?.rejectResults(err);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return streamOutput;
+  }
 };
 var InngestWorkflow = class _InngestWorkflow extends Workflow {
   #mastra;
@@ -322,6 +489,7 @@ var InngestWorkflow = class _InngestWorkflow extends 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
     );
@@ -386,7 +554,9 @@ var InngestWorkflow = class _InngestWorkflow extends 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
     );
@@ -407,6 +577,7 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
           value: {},
           context: {},
           activePaths: [],
+          activeStepsPath: {},
           waitingPaths: {},
           serializedStepGraph: this.serializedStepGraph,
           suspendedPaths: {},
@@ -435,7 +606,7 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, initialState, runId, resourceId, resume, outputOptions } = event.data;
+        let { inputData, initialState, runId, resourceId, resume, outputOptions, timeTravel } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
             return randomUUID();
@@ -477,6 +648,7 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
           runtimeContext: new RuntimeContext(),
           // TODO
           resume,
+          timeTravel,
           abortController: new AbortController(),
           currentSpan: void 0,
           // TODO: Pass actual parent AI span from workflow execution context
@@ -937,6 +1109,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     stepResults,
     executionContext,
     resume,
+    timeTravel,
     prevOutput,
     emitter,
     abortController,
@@ -1000,6 +1173,7 @@ var InngestExecutionEngine = class extends 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 ?? randomUUID();
@@ -1027,6 +1201,32 @@ var InngestExecutionEngine = class extends 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 = 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(),
@@ -1087,12 +1287,12 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             });
             return { executionContext, result: { status: "failed", error: result?.error } };
           } else if (result.status === "suspended") {
-            const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult]) => {
-              const stepRes2 = stepResult;
+            const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult2]) => {
+              const stepRes2 = stepResult2;
               return stepRes2?.status === "suspended";
             });
-            for (const [stepName, stepResult] of suspendedSteps) {
-              const suspendPath = [stepName, ...stepResult?.suspendPayload?.__workflow_meta?.path ?? []];
+            for (const [stepName, stepResult2] of suspendedSteps) {
+              const suspendPath = [stepName, ...stepResult2?.suspendPayload?.__workflow_meta?.path ?? []];
               executionContext.suspendedPaths[step.id] = executionContext.executionPath;
               await emitter.emit("watch", {
                 type: "watch",
@@ -1100,9 +1300,9 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
                   currentStep: {
                     id: step.id,
                     status: "suspended",
-                    payload: stepResult.payload,
+                    payload: stepResult2.payload,
                     suspendPayload: {
-                      ...stepResult?.suspendPayload,
+                      ...stepResult2?.suspendPayload,
                       __workflow_meta: { runId, path: suspendPath }
                     }
                   },
@@ -1126,9 +1326,9 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
                 executionContext,
                 result: {
                   status: "suspended",
-                  payload: stepResult.payload,
+                  payload: stepResult2.payload,
                   suspendPayload: {
-                    ...stepResult?.suspendPayload,
+                    ...stepResult2?.suspendPayload,
                     __workflow_meta: { runId, path: suspendPath }
                   }
                 }
@@ -1195,7 +1395,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         }
       );
       Object.assign(executionContext, res.executionContext);
-      return {
+      const stepResult = {
         ...res.result,
         startedAt,
         endedAt: Date.now(),
@@ -1203,6 +1403,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
         resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
       };
+      return { result: stepResult, executionContextState: executionContext.state };
     }
     let stepRes;
     try {
@@ -1210,6 +1411,21 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         let execResults;
         let suspended;
         let bailed;
+        const { resumeData: timeTravelResumeData, validationError: timeTravelResumeValidationError } = await 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;
@@ -1224,7 +1440,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               executionContext.state = state;
             },
             inputData,
-            resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
+            resumeData: resumeDataToUse,
             tracingContext: {
               currentSpan: stepAISpan
             },
@@ -1265,8 +1481,8 @@ var InngestExecutionEngine = class extends 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 = {
@@ -1275,8 +1491,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             error: e instanceof Error ? e.stack ?? 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`;
@@ -1292,8 +1508,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             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 = {
@@ -1396,9 +1612,11 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       });
     }
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
-    Object.assign(stepResults, stepRes.stepResults);
     executionContext.state = stepRes.executionContext.state;
-    return stepRes.result;
+    return {
+      result: stepRes.result,
+      executionContextState: stepRes.executionContext.state
+    };
   }
   async persistStepUpdate({
     workflowId,
@@ -1424,14 +1642,15 @@ var InngestExecutionEngine = class extends 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
@@ -1447,6 +1666,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     entry,
     prevOutput,
     stepResults,
+    timeTravel,
     resume,
     executionContext,
     emitter,
@@ -1557,10 +1777,12 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           prevOutput,
           stepResults,
           resume,
+          timeTravel,
           executionContext: {
             workflowId,
             runId,
             executionPath: [...executionContext.executionPath, index],
+            activeStepsPath: executionContext.activeStepsPath,
             suspendedPaths: executionContext.suspendedPaths,
             resumeLabels: executionContext.resumeLabels,
             retryConfig: executionContext.retryConfig,
@@ -1576,8 +1798,9 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             currentSpan: conditionalSpan
           }
         });
-        stepResults[step.step.id] = result;
-        return result;
+        stepResults[step.step.id] = result.result;
+        executionContext.state = result.executionContextState;
+        return result.result;
       })
     );
     const hasFailed = results.find((result) => result.status === "failed");