@mastra/temporal 0.6.0-alpha.0 → 0.6.0-alpha.1

package/dist/temporal-workflow-runtime.mjs

@@ -1,8 +1,11 @@
 import {
+  ApplicationFailure,
+  TemporalFailure,
   condition,
   defineQuery,
   defineSignal,
   executeChild,
+  isCancellation,
   proxyActivities,
   log,
   setHandler,
@@ -12,6 +15,39 @@ import {
 const resumeSignal = defineSignal('mastra.resume');
 const statusQuery = defineQuery('mastra.status');
 
+// The step error an Activity or child Workflow put in its failure details. Failures without them
+// (timeouts, Activities from an older Worker) give the innermost cause's type and message.
+function readStepFailure(error) {
+  let current = error;
+  while (current) {
+    const details = current.details?.[0];
+
+    if (details?.error) {
+      return { error: details.error, ...(details.tripwire && { tripwire: details.tripwire }) };
+    }
+
+    if (!current.cause) {
+      break;
+    }
+
+    current = current.cause;
+  }
+
+  return { error: { name: current?.type ?? current?.name ?? 'Error', message: current?.message ?? String(error) } };
+}
+
+// Records a step as failed, in the core StepResult shape, before its failure ends the run.
+function recordFailure(stepResults, id, payload, startedAt, error) {
+  stepResults[id] = {
+    __temporalStepResult: true,
+    status: 'failed',
+    payload,
+    ...readStepFailure(error),
+    startedAt,
+    endedAt: Date.now(),
+  };
+}
+
 export class TemporalExecutionEngine {
   startToCloseTimeout;
   activityHandle;
@@ -56,8 +92,26 @@ export class TemporalExecutionEngine {
       steps: stepResults,
     };
 
-    for (const entry of params.graph.steps) {
-      result = await this.executeEntry(entry, result, stepResults);
+    try {
+      for (const entry of params.graph.steps) {
+        result = await this.executeEntry(entry, result, stepResults);
+      }
+    } catch (error) {
+      // An error that isn't a Temporal failure comes from Workflow code. It fails only the Workflow
+      // Task, which Temporal retries, so a fixed Worker can still finish the run.
+      if (isCancellation(error) || !(error instanceof TemporalFailure)) {
+        throw error;
+      }
+
+      // The run still fails in Temporal. The details let start() return step records and the
+      // step's own error, which a thrown ActivityFailure would lose.
+      const failure = readStepFailure(error);
+      throw ApplicationFailure.create({
+        message: failure.error.message,
+        type: failure.error.name,
+        cause: error,
+        details: [{ ...failure, steps: stepResults }],
+      });
     }
 
     this.currentResult = {
@@ -82,9 +136,17 @@ export class TemporalExecutionEngine {
   }
 
   // Record steps in the core StepResult shape ({ status, payload, output, startedAt, endedAt }).
-  async recordStep(stepResults, id, payload, run) {
+  async recordStep(stepResults, id, payload, run, group) {
     const startedAt = Date.now();
-    let output = await run();
+    const attempt = async resumeData => {
+      try {
+        return await run(resumeData);
+      } catch (error) {
+        recordFailure(stepResults, id, payload, startedAt, error);
+        throw error;
+      }
+    };
+    let output = await attempt();
     let suspendPayload;
     let resumeData;
 
@@ -114,7 +176,11 @@ export class TemporalExecutionEngine {
 
       this.suspendedSteps.add(id);
       try {
-        await condition(() => this.resumePayloads.has(id));
+        await condition(() => this.resumePayloads.has(id) || group?.failed === true);
+        // A failed sibling branch ends the run, so the step stays suspended in the records.
+        if (!this.resumePayloads.has(id)) {
+          return output;
+        }
         resumeData = this.resumePayloads.get(id)?.resumeData;
         this.resumePayloads.delete(id);
       } finally {
@@ -131,7 +197,7 @@ export class TemporalExecutionEngine {
         state: this.initialState,
         steps: stepResults,
       };
-      output = await run(resumeData);
+      output = await attempt(resumeData);
     }
 
     stepResults[id] = {
@@ -157,17 +223,22 @@ export class TemporalExecutionEngine {
     return { inputData, ...extra, ...this.executionContext };
   }
 
-  async executeEntry(entry, inputData, stepResults) {
+  async executeEntry(entry, inputData, stepResults, group) {
     switch (entry.type) {
       case 'step': {
         log.info('step', { stepId: entry.step.id });
-        return this.recordStep(stepResults, entry.step.id, inputData, resumeData =>
-          this.activityHandle[entry.step.id](
-            this.activityParams(inputData, {
-              initData: this.initData,
-              ...(resumeData !== undefined && { resumeData }),
-            }),
-          ),
+        return this.recordStep(
+          stepResults,
+          entry.step.id,
+          inputData,
+          resumeData =>
+            this.activityHandle[entry.step.id](
+              this.activityParams(inputData, {
+                initData: this.initData,
+                ...(resumeData !== undefined && { resumeData }),
+              }),
+            ),
+          group,
         );
       }
 
@@ -213,11 +284,34 @@ export class TemporalExecutionEngine {
         const entryId = parallelEntry =>
           parallelEntry.type === 'childWorkflow' ? parallelEntry.workflowType : parallelEntry.step.id;
         log.info('parallel', { steps: entry.steps.map(entryId) });
-        const results = await Promise.all(entry.steps.map(step => this.executeEntry(step, inputData, stepResults)));
+        // Waits for every branch, as a local run does, so a failed run keeps the others' records.
+        // A failed branch also ends the wait of a suspended one, which would otherwise keep the run
+        // open until a resume. The flag is per group so a later parallel starts clean.
+        const group = { failed: false };
+        const settled = await Promise.allSettled(
+          entry.steps.map(step =>
+            this.executeEntry(step, inputData, stepResults, group).catch(error => {
+              group.failed = true;
+              throw error;
+            }),
+          ),
+        );
+        const failures = settled.filter(outcome => outcome.status === 'rejected');
+        // Same order as in execute(), whatever the branch order: a cancelled run ends Canceled, and
+        // an error from Workflow code wins so Temporal retries the Workflow Task.
+        const rejected =
+          failures.find(outcome => isCancellation(outcome.reason)) ??
+          failures.find(outcome => !(outcome.reason instanceof TemporalFailure)) ??
+          failures[0];
+
+        if (rejected) {
+          throw rejected.reason;
+        }
+
         const out = {};
 
         entry.steps.forEach((step, i) => {
-          out[entryId(step)] = results[i];
+          out[entryId(step)] = settled[i].value;
         });
 
         return out;
@@ -301,7 +395,12 @@ export class TemporalExecutionEngine {
           }
         });
 
-        await Promise.all(workers);
+        try {
+          await Promise.all(workers);
+        } catch (error) {
+          recordFailure(stepResults, entry.step.id, inputData, startedAt, error);
+          throw error;
+        }
         stepResults[entry.step.id] = {
           __temporalStepResult: true,
           status: 'success',

package/dist/transforms/temporal-workflow-runtime.d.mts

@@ -17,7 +17,7 @@ export declare class TemporalExecutionEngine {
     constructor(params: any);
     execute(params: any): Promise<any>;
     resumeTarget(payload: any): any;
-    recordStep(stepResults: any, id: any, payload: any, run: any): Promise<any>;
+    recordStep(stepResults: any, id: any, payload: any, run: any, group: any): Promise<any>;
     activityParams(inputData: any, extra?: {}): {
         requestContext?: any;
         runId?: any;
@@ -26,7 +26,7 @@ export declare class TemporalExecutionEngine {
         workflowId?: any;
         inputData: any;
     };
-    executeEntry(entry: any, inputData: any, stepResults: any): Promise<any>;
+    executeEntry(entry: any, inputData: any, stepResults: any, group: any): Promise<any>;
 }
 export declare function createWorkflow(workflowId: any, options: any): ((startArgs: any) => Promise<any>) & {
     then(stepId: any): (startArgs: any) => Promise<any>;

package/dist/transforms/temporal-workflow-runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"temporal-workflow-runtime.d.mts","sourceRoot":"","sources":["../../src/transforms/temporal-workflow-runtime.mjs"],"names":[],"mappings":"AAcA,qBAAa,uBAAuB;IA4B3B,gBAAgB;;;;;;;IA3BvB,mBAAmB,MAAC;IACpB,cAAc,wGAAC;IACf,cAAc,gBAAa;IAC3B,cAAc,WAAa;IAC3B,YAAY,gBAAa;IACzB,aAAa,MAAC;IACd,QAAQ,MAAC;IACT,YAAY,MAAC;IAEb,YAAY,MAAM,KAAA,EAajB;IAEK,OAAO,CAAC,MAAM,KAAA,gBA+BnB;IAED,YAAY,CAAC,OAAO,KAAA,OASnB;IAGK,UAAU,CAAC,WAAW,KAAA,EAAE,EAAE,KAAA,EAAE,OAAO,KAAA,EAAE,GAAG,KAAA,gBAqE7C;IAED,cAAc,CAAC,SAAS,KAAA,EAAE,KAAK,KAAK;;;;;;;MAEnC;IAEK,YAAY,CAAC,KAAK,KAAA,EAAE,SAAS,KAAA,EAAE,WAAW,KAAA,gBA+J/C;CACF;AAED,wBAAgB,cAAc,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;EAuJjD"}
+{"version":3,"file":"temporal-workflow-runtime.d.mts","sourceRoot":"","sources":["../../src/transforms/temporal-workflow-runtime.mjs"],"names":[],"mappings":"AAkDA,qBAAa,uBAAuB;IA4B3B,gBAAgB;;;;;;;IA3BvB,mBAAmB,MAAC;IACpB,cAAc,wGAAC;IACf,cAAc,gBAAa;IAC3B,cAAc,WAAa;IAC3B,YAAY,gBAAa;IACzB,aAAa,MAAC;IACd,QAAQ,MAAC;IACT,YAAY,MAAC;IAEb,YAAY,MAAM,KAAA,EAajB;IAEK,OAAO,CAAC,MAAM,KAAA,gBAiDnB;IAED,YAAY,CAAC,OAAO,KAAA,OASnB;IAGK,UAAU,CAAC,WAAW,KAAA,EAAE,EAAE,KAAA,EAAE,OAAO,KAAA,EAAE,GAAG,KAAA,EAAE,KAAK,KAAA,gBAiFpD;IAED,cAAc,CAAC,SAAS,KAAA,EAAE,KAAK,KAAK;;;;;;;MAEnC;IAEK,YAAY,CAAC,KAAK,KAAA,EAAE,SAAS,KAAA,EAAE,WAAW,KAAA,EAAE,KAAK,KAAA,gBAgMtD;CACF;AAED,wBAAgB,cAAc,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;EAuJjD"}

package/dist/worker.cjs

@@ -23,12 +23,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 const require_utils = require("./utils-BVE1AkTt.cjs");
 let _mastra_core_workflows = require("@mastra/core/workflows");
 let _mastra_core_di = require("@mastra/core/di");
+let _mastra_core_error = require("@mastra/core/error");
 let fs = require("fs");
 let fs_promises = require("fs/promises");
 let path = require("path");
 path = __toESM(path, 1);
 let url = require("url");
-let _mastra_core_error = require("@mastra/core/error");
 let _mastra_core_schema = require("@mastra/core/schema");
 let _temporalio_activity = require("@temporalio/activity");
 let _babel_generator = require("@babel/generator");
@@ -1212,6 +1212,44 @@ function getActivityBindingsPath(outputDir) {
 	return path.default.join(outputDir, ACTIVITY_BINDINGS_FILE_NAME);
 }
 /**
+* Temporal reduces a thrown error to its class name and message, so the step's own fields go in
+* the failure's `details` for start() to rebuild the result a local run returns.
+*/
+function toStepFailureDetails(error) {
+	const serialized = (0, _mastra_core_error.getErrorFromUnknown)(error, { serializeStack: false }).toJSON();
+	let details;
+	try {
+		details = JSON.parse(JSON.stringify(serialized));
+	} catch {
+		details = {
+			name: serialized.name,
+			message: serialized.message
+		};
+	}
+	if (error instanceof Error && error.name === "TripWire") {
+		const { options, processorId } = error;
+		return {
+			error: details,
+			tripwire: {
+				reason: error.message,
+				retry: options?.retry,
+				metadata: options?.metadata,
+				processorId
+			}
+		};
+	}
+	return { error: details };
+}
+/** Fails as Temporal's own conversion would (same type, message and retries), plus the details. */
+async function runStep(execute) {
+	try {
+		return await execute();
+	} catch (error) {
+		if (error instanceof _temporalio_activity.ApplicationFailure || error instanceof _temporalio_activity.CancelledFailure) throw error;
+		throw _temporalio_activity.ApplicationFailure.fromError(error, { details: [toStepFailureDetails(error)] });
+	}
+}
+/**
 * Activities queued by a Workflow built before `validateInputs` existed carry no flag and run
 * unchecked. A mismatch is non-retryable because a retry gets the same input.
 */
@@ -1234,7 +1272,8 @@ async function checkStepParams(stepId, { inputSchema, requestContextSchema }, {
 		type: error instanceof _mastra_core_error.MastraError ? error.id : error.name,
 		message: error.message,
 		nonRetryable: true,
-		cause: error
+		cause: error,
+		details: [toStepFailureDetails(error)]
 	});
 	return {
 		...params,
@@ -1298,9 +1337,10 @@ var MastraPlugin = class {
 			if (generatedActivities[binding.stepId]) continue;
 			generatedActivities[binding.stepId] = async (params) => {
 				const activity = (await this.#loadCompiledActivitiesModule(compiledActivitiesPath))[binding.exportName];
-				if (typeof activity === "function") return activity(params);
+				if (typeof activity === "function") return runStep(() => activity(params));
 				if (typeof activity?.execute !== "function") throw new Error(`Unable to load activity '${binding.exportName}' from ${compiledActivitiesPath}`);
-				return activity.execute(await checkStepParams(binding.stepId, activity, params));
+				const checkedParams = await checkStepParams(binding.stepId, activity, params);
+				return runStep(() => activity.execute(checkedParams));
 			};
 		}
 		return generatedActivities;