@mastra/temporal 0.5.0 → 0.6.0-alpha.1

package/dist/worker.js

@@ -2,13 +2,13 @@ import { t as toWorkflowType } from "./utils-R6cB86BM.js";
 import { builtinModules } from "module";
 import { validateStepInput, validateStepRequestContext } from "@mastra/core/workflows";
 import { RequestContext } from "@mastra/core/di";
+import { MastraError, getErrorFromUnknown } from "@mastra/core/error";
 import { readFileSync } from "fs";
 import { writeFile } from "fs/promises";
 import path, { basename, join } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
-import { MastraError } from "@mastra/core/error";
 import { toStandardSchema } from "@mastra/core/schema";
-import { ApplicationFailure } from "@temporalio/activity";
+import { ApplicationFailure, CancelledFailure } from "@temporalio/activity";
 import { generate } from "@babel/generator";
 import { parse } from "@babel/parser";
 import * as t from "@babel/types";
@@ -403,24 +403,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));"}
         },
       };
     }
@@ -1157,6 +1188,44 @@ function getActivityBindingsPath(outputDir) {
 	return path.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 = 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 ApplicationFailure || error instanceof CancelledFailure) throw error;
+		throw 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.
 */
@@ -1179,7 +1248,8 @@ async function checkStepParams(stepId, { inputSchema, requestContextSchema }, {
 		type: error instanceof MastraError ? error.id : error.name,
 		message: error.message,
 		nonRetryable: true,
-		cause: error
+		cause: error,
+		details: [toStepFailureDetails(error)]
 	});
 	return {
 		...params,
@@ -1243,9 +1313,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;