@mastra/temporal 0.5.0 → 0.6.0-alpha.1

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");
@@ -427,24 +427,55 @@ function hasLocalMastraBinding(ast) {
 }
 function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBinding, requestContextClassName) {
 	const helperSource = `
-    function withRequestContext(params) {
+    function withRequestContext(params, args) {
       const { requestContext, initData, ...rest } = params;
+      let suspended;
       return {
         ...rest,
         requestContext: new ${requestContextClassName}(requestContext),
         getInitData: () => initData,
+        suspend: async (suspendPayload, options) => {
+          const parsedSuspendPayload = await parseWithSchema(args.suspendSchema, suspendPayload, 'Suspend payload');
+          suspended = {
+            __temporalSuspension: true,
+            suspendPayload: parsedSuspendPayload,
+            ...(options?.resumeLabel !== undefined && { resumeLabel: options.resumeLabel }),
+          };
+        },
+        __getTemporalSuspension: () => suspended,
       };
     }
 
+    async function parseWithSchema(schema, value, label) {
+      if (!schema) return value;
+      if (schema['~standard']?.validate) {
+        const result = await schema['~standard'].validate(value);
+        if ('issues' in result && result.issues?.length) {
+          throw new Error(label + ' validation failed: ' + result.issues.map(issue => issue.message).join(', '));
+        }
+        return result.value;
+      }
+      if (typeof schema.parseAsync === 'function') return schema.parseAsync(value);
+      if (typeof schema.parse === 'function') return schema.parse(value);
+      return value;
+    }
+
+    async function executeTemporalStep(args, context) {
+      const result = await args.execute(context);
+      return context.__getTemporalSuspension() ?? result;
+    }
+
     function createStep(args) {
       return {
         inputSchema: args.inputSchema,
         requestContextSchema: args.requestContextSchema,
+        suspendSchema: args.suspendSchema,
+        resumeSchema: args.resumeSchema,
         execute: async (params) => {
           ${mastraImportPath ? `
       const { mastra } = await import(${JSON.stringify(mastraImportPath)});
-      return args.execute({ ...withRequestContext(params), mastra });
-    ` : hasMastraBinding ? "return args.execute({ ...withRequestContext(params), mastra });" : "return args.execute(withRequestContext(params));"}
+      return executeTemporalStep(args, { ...withRequestContext(params, args), mastra });
+    ` : hasMastraBinding ? "return executeTemporalStep(args, { ...withRequestContext(params, args), mastra });" : "return executeTemporalStep(args, withRequestContext(params, args));"}
         },
       };
     }
@@ -1181,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.
 */
@@ -1203,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,
@@ -1267,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;