@mastra/temporal 0.5.0-alpha.3 → 0.6.0-alpha.0

package/dist/temporal-workflow-runtime.mjs

@@ -1,8 +1,26 @@
-import { executeChild, proxyActivities, log, sleep } from '@temporalio/workflow';
+import {
+  condition,
+  defineQuery,
+  defineSignal,
+  executeChild,
+  proxyActivities,
+  log,
+  setHandler,
+  sleep,
+} from '@temporalio/workflow';
+
+const resumeSignal = defineSignal('mastra.resume');
+const statusQuery = defineQuery('mastra.status');
 
 export class TemporalExecutionEngine {
   startToCloseTimeout;
   activityHandle;
+  resumePayloads = new Map();
+  suspendedSteps = new Set();
+  resumeLabels = new Map();
+  currentResult;
+  initData;
+  initialState;
 
   constructor(params) {
     this.startToCloseTimeout = params?.options?.startToCloseTimeout ?? '1 minute';
@@ -10,47 +28,129 @@ export class TemporalExecutionEngine {
       startToCloseTimeout: this.startToCloseTimeout,
       ...(params?.options?.retry !== undefined && { retry: params.options.retry }),
     });
+    setHandler(resumeSignal, payload => {
+      const id = this.resumeTarget(payload);
+      if (id !== undefined && !this.resumePayloads.has(id)) {
+        this.resumePayloads.set(id, payload);
+      }
+    });
+    setHandler(statusQuery, () => this.currentResult);
   }
 
   async execute(params) {
     this.initData = params.input;
+    this.initialState = params.initialState;
     this.executionContext = {
       ...(params.requestContext !== undefined && { requestContext: params.requestContext }),
       ...(params.runId !== undefined && { runId: params.runId }),
       ...(params.resourceId !== undefined && { resourceId: params.resourceId }),
-      validateInputs: params.validateInputs,
+      ...(params.validateInputs !== undefined && { validateInputs: params.validateInputs }),
       workflowId: params.workflowId,
     };
-    // Step times let start() build Mastra step records. Only recorded on request so runs that
-    // never read them (startAsync, runs started before the field existed) keep their result size.
-    this.stepMeta = params.recordStepMeta ? {} : undefined;
     let result = params.input;
     const stepResults = {};
+    this.currentResult = {
+      status: 'running',
+      input: params.input,
+      state: params.initialState,
+      steps: stepResults,
+    };
 
     for (const entry of params.graph.steps) {
       result = await this.executeEntry(entry, result, stepResults);
     }
 
-    return {
+    this.currentResult = {
       status: 'success',
       input: params.input,
       result,
       state: params.initialState,
       steps: stepResults,
-      ...(this.stepMeta && { stepMeta: this.stepMeta }),
     };
+    return this.currentResult;
   }
 
-  // Runs one timed entry and stores its output under `id`. Date.now() in Workflow code is the
-  // Workflow Task time, which replay reads from history.
-  async timed(stepResults, id, run) {
+  resumeTarget(payload) {
+    if (payload?.step !== undefined) {
+      return this.suspendedSteps.has(payload.step) ? payload.step : undefined;
+    }
+    if (payload?.label !== undefined) {
+      const labeledStep = this.resumeLabels.get(payload.label);
+      return labeledStep !== undefined && this.suspendedSteps.has(labeledStep) ? labeledStep : undefined;
+    }
+    return this.suspendedSteps.size === 1 ? [...this.suspendedSteps][0] : undefined;
+  }
+
+  // Record steps in the core StepResult shape ({ status, payload, output, startedAt, endedAt }).
+  async recordStep(stepResults, id, payload, run) {
     const startedAt = Date.now();
-    const out = await run();
-    stepResults[id] = out;
-    if (this.stepMeta) {
-      this.stepMeta[id] = { startedAt, endedAt: Date.now() };
+    let output = await run();
+    let suspendPayload;
+    let resumeData;
+
+    while (output?.__temporalSuspension === true) {
+      suspendPayload = output.suspendPayload;
+      stepResults[id] = {
+        __temporalStepResult: true,
+        status: 'suspended',
+        payload,
+        suspendPayload,
+        suspendedAt: Date.now(),
+      };
+      for (const [label, target] of Object.entries(output.resumeLabels ?? {})) {
+        if (target?.stepId === id) {
+          this.resumeLabels.set(label, id);
+        }
+      }
+      this.currentResult = {
+        status: 'suspended',
+        input: this.initData,
+        state: this.initialState,
+        steps: stepResults,
+        suspended: [[id]],
+        suspendPayload: { [id]: suspendPayload },
+        resumeLabels: Object.fromEntries([...this.resumeLabels].map(([label, stepId]) => [label, { stepId }])),
+      };
+
+      this.suspendedSteps.add(id);
+      try {
+        await condition(() => this.resumePayloads.has(id));
+        resumeData = this.resumePayloads.get(id)?.resumeData;
+        this.resumePayloads.delete(id);
+      } finally {
+        this.suspendedSteps.delete(id);
+        for (const [label, stepId] of this.resumeLabels.entries()) {
+          if (stepId === id) {
+            this.resumeLabels.delete(label);
+          }
+        }
+      }
+      this.currentResult = {
+        status: 'running',
+        input: this.initData,
+        state: this.initialState,
+        steps: stepResults,
+      };
+      output = await run(resumeData);
     }
-    return out;
+
+    stepResults[id] = {
+      __temporalStepResult: true,
+      status: 'success',
+      payload,
+      output,
+      ...(suspendPayload !== undefined && { suspendPayload }),
+      ...(resumeData !== undefined && { resumeData }),
+      startedAt,
+      endedAt: Date.now(),
+    };
+    this.currentResult = {
+      status: 'running',
+      input: this.initData,
+      state: this.initialState,
+      steps: stepResults,
+    };
+    return output;
   }
 
   activityParams(inputData, extra = {}) {
@@ -61,14 +161,19 @@ export class TemporalExecutionEngine {
     switch (entry.type) {
       case 'step': {
         log.info('step', { stepId: entry.step.id });
-        return this.timed(stepResults, entry.step.id, () =>
-          this.activityHandle[entry.step.id](this.activityParams(inputData, { initData: this.initData })),
+        return this.recordStep(stepResults, entry.step.id, inputData, resumeData =>
+          this.activityHandle[entry.step.id](
+            this.activityParams(inputData, {
+              initData: this.initData,
+              ...(resumeData !== undefined && { resumeData }),
+            }),
+          ),
         );
       }
 
       case 'childWorkflow': {
         log.info('childWorkflow', { workflowType: entry.workflowType });
-        return this.timed(stepResults, entry.id, async () => {
+        return this.recordStep(stepResults, entry.id ?? entry.workflowType, inputData, async () => {
           const childResult = await executeChild(entry.workflowType, {
             args: [{ inputData, ...this.executionContext }],
           });
@@ -78,7 +183,7 @@ export class TemporalExecutionEngine {
 
       case 'mapping': {
         log.info('mapping', { mappingId: entry.id });
-        return this.timed(stepResults, entry.id, () =>
+        return this.recordStep(stepResults, entry.id, inputData, () =>
           this.activityHandle[entry.id](this.activityParams(inputData, { initData: this.initData })),
         );
       }
@@ -105,8 +210,6 @@ export class TemporalExecutionEngine {
       }
 
       case 'parallel': {
-        // The next step keeps reading a nested workflow under its Temporal type name, as before.
-        // Only the step records use the Mastra id.
         const entryId = parallelEntry =>
           parallelEntry.type === 'childWorkflow' ? parallelEntry.workflowType : parallelEntry.step.id;
         log.info('parallel', { steps: entry.steps.map(entryId) });
@@ -134,8 +237,13 @@ export class TemporalExecutionEngine {
         for (let i = 0; i < entry.steps.length; i++) {
           if (condResults[i]) {
             const stepId = entry.steps[i].step.id;
-            out[stepId] = await this.timed(stepResults, stepId, () =>
-              this.activityHandle[stepId](this.activityParams(inputData, { initData: this.initData })),
+            out[stepId] = await this.recordStep(stepResults, stepId, inputData, resumeData =>
+              this.activityHandle[stepId](
+                this.activityParams(inputData, {
+                  initData: this.initData,
+                  ...(resumeData !== undefined && { resumeData }),
+                }),
+              ),
             );
           }
         }
@@ -148,9 +256,14 @@ export class TemporalExecutionEngine {
         let current = inputData;
 
         while (true) {
-          const stepInput = current;
-          current = await this.timed(stepResults, entry.step.id, () =>
-            this.activityHandle[entry.step.id](this.activityParams(stepInput, { initData: this.initData })),
+          const payload = current;
+          current = await this.recordStep(stepResults, entry.step.id, payload, resumeData =>
+            this.activityHandle[entry.step.id](
+              this.activityParams(payload, {
+                initData: this.initData,
+                ...(resumeData !== undefined && { resumeData }),
+              }),
+            ),
           );
           const shouldContinue = Boolean(
             await this.activityHandle[entry.serializedCondition.id](this.activityParams(current)),
@@ -173,24 +286,31 @@ export class TemporalExecutionEngine {
             : (entry.opts.concurrency ?? 1);
         const concurrency = Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 1;
         log.info('foreach', { step: entry.step.id, concurrency });
-        return this.timed(stepResults, entry.step.id, async () => {
-          const results = new Array(items.length);
-          let index = 0;
-          const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-            while (true) {
-              const i = index++;
-              if (i >= items.length) {
-                break;
-              }
-              results[i] = await this.activityHandle[entry.step.id](
-                this.activityParams(items[i], { initData: this.initData }),
-              );
+        const startedAt = Date.now();
+        const results = new Array(items.length);
+        let index = 0;
+        const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+          while (true) {
+            const i = index++;
+            if (i >= items.length) {
+              break;
             }
-          });
-
-          await Promise.all(workers);
-          return results;
+            results[i] = await this.activityHandle[entry.step.id](
+              this.activityParams(items[i], { initData: this.initData }),
+            );
+          }
         });
+
+        await Promise.all(workers);
+        stepResults[entry.step.id] = {
+          __temporalStepResult: true,
+          status: 'success',
+          payload: inputData,
+          output: results,
+          startedAt,
+          endedAt: Date.now(),
+        };
+        return results;
       }
 
       default:
@@ -220,7 +340,6 @@ export function createWorkflow(workflowId, options) {
       },
       input: startArgs?.inputData,
       initialState: startArgs?.initialState,
-      recordStepMeta: startArgs?.recordStepMeta,
     });
   };
 

package/dist/transforms/activities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../src/transforms/activities.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mCAAmC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,uBAAuB,EAAE,CAAC;CAC7C;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAmE/G;AAoSD,wBAAsB,6BAA6B,CACjD,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,mCAAmC,CAAC,CAoZ9C"}
+{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../src/transforms/activities.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mCAAmC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,uBAAuB,EAAE,CAAC;CAC7C;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAmE/G;AAkUD,wBAAsB,6BAA6B,CACjD,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,mCAAmC,CAAC,CAoZ9C"}

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

@@ -1,25 +1,23 @@
 export declare class TemporalExecutionEngine {
-    initData: any;
     executionContext: {
         requestContext?: any;
         runId?: any;
         resourceId?: any;
-        validateInputs: any;
+        validateInputs?: any;
         workflowId: any;
     } | undefined;
-    stepMeta: {} | undefined;
     startToCloseTimeout: any;
     activityHandle: import("@temporalio/workflow").ActivityInterfaceFor<import("@temporalio/workflow").UntypedActivities>;
+    resumePayloads: Map<any, any>;
+    suspendedSteps: Set<any>;
+    resumeLabels: Map<any, any>;
+    currentResult: any;
+    initData: any;
+    initialState: any;
     constructor(params: any);
-    execute(params: any): Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    timed(stepResults: any, id: any, run: any): Promise<any>;
+    execute(params: any): Promise<any>;
+    resumeTarget(payload: any): any;
+    recordStep(stepResults: any, id: any, payload: any, run: any): Promise<any>;
     activityParams(inputData: any, extra?: {}): {
         requestContext?: any;
         runId?: any;
@@ -30,101 +28,17 @@ export declare class TemporalExecutionEngine {
     };
     executeEntry(entry: any, inputData: any, stepResults: any): Promise<any>;
 }
-export declare function createWorkflow(workflowId: any, options: any): ((startArgs: any) => Promise<{
-    status: string;
-    input: any;
-    result: any;
-    state: any;
-    steps: {};
-    stepMeta?: {} | undefined;
-}>) & {
-    then(stepId: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    thenWorkflow(workflowType: any, id: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    map(mappingId: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    sleep(durationOrFnId: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    sleepUntil(dateOrFnId: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    parallel(entries: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    branch(pairs: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    dowhile(stepId: any, condId: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    dountil(stepId: any, condId: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    foreach(stepId: any, opts: any): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
-    commit(): (startArgs: any) => Promise<{
-        status: string;
-        input: any;
-        result: any;
-        state: any;
-        steps: {};
-        stepMeta?: {} | undefined;
-    }>;
+export declare function createWorkflow(workflowId: any, options: any): ((startArgs: any) => Promise<any>) & {
+    then(stepId: any): (startArgs: any) => Promise<any>;
+    thenWorkflow(workflowType: any, id: any): (startArgs: any) => Promise<any>;
+    map(mappingId: any): (startArgs: any) => Promise<any>;
+    sleep(durationOrFnId: any): (startArgs: any) => Promise<any>;
+    sleepUntil(dateOrFnId: any): (startArgs: any) => Promise<any>;
+    parallel(entries: any): (startArgs: any) => Promise<any>;
+    branch(pairs: any): (startArgs: any) => Promise<any>;
+    dowhile(stepId: any, condId: any): (startArgs: any) => Promise<any>;
+    dountil(stepId: any, condId: any): (startArgs: any) => Promise<any>;
+    foreach(stepId: any, opts: any): (startArgs: any) => Promise<any>;
+    commit(): (startArgs: any) => Promise<any>;
 };
 //# sourceMappingURL=temporal-workflow-runtime.d.mts.map

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":"AAEA,qBAAa,uBAAuB;IAa3B,QAAQ;IACR,gBAAgB;;;;;;;IAShB,QAAQ;IAtBf,mBAAmB,MAAC;IACpB,cAAc,wGAAC;IAEf,YAAY,MAAM,KAAA,EAMjB;IAEK,OAAO,CAAC,MAAM,KAAA;;;;;;;OA2BnB;IAIK,KAAK,CAAC,WAAW,KAAA,EAAE,EAAE,KAAA,EAAE,GAAG,KAAA,gBAQ/B;IAED,cAAc,CAAC,SAAS,KAAA,EAAE,KAAK,KAAK;;;;;;;MAEnC;IAEK,YAAY,CAAC,KAAK,KAAA,EAAE,SAAS,KAAA,EAAE,WAAW,KAAA,gBA2I/C;CACF;AAED,wBAAgB,cAAc,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJjD"}
+{"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"}

package/dist/worker.cjs

@@ -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));"}
         },
       };
     }