@mastra/temporal 0.5.0 → 0.6.0-alpha.1

package/dist/temporal-workflow-runtime.mjs

@@ -1,8 +1,62 @@
-import { executeChild, proxyActivities, log, sleep } from '@temporalio/workflow';
+import {
+  ApplicationFailure,
+  TemporalFailure,
+  condition,
+  defineQuery,
+  defineSignal,
+  executeChild,
+  isCancellation,
+  proxyActivities,
+  log,
+  setHandler,
+  sleep,
+} from '@temporalio/workflow';
+
+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;
+  resumePayloads = new Map();
+  suspendedSteps = new Set();
+  resumeLabels = new Map();
+  currentResult;
+  initData;
+  initialState;
 
   constructor(params) {
     this.startToCloseTimeout = params?.options?.startToCloseTimeout ?? '1 minute';
@@ -10,65 +64,187 @@ 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);
+    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 }],
+      });
     }
 
-    return {
+    this.currentResult = {
       status: 'success',
       input: params.input,
       result,
       state: params.initialState,
       steps: stepResults,
-      ...(this.stepMeta && { stepMeta: this.stepMeta }),
     };
+    return this.currentResult;
+  }
+
+  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;
   }
 
-  // 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) {
+  // Record steps in the core StepResult shape ({ status, payload, output, startedAt, endedAt }).
+  async recordStep(stepResults, id, payload, run, group) {
     const startedAt = Date.now();
-    const out = await run();
-    stepResults[id] = out;
-    if (this.stepMeta) {
-      this.stepMeta[id] = { startedAt, endedAt: Date.now() };
+    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;
+
+    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) || 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 {
+        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 attempt(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 = {}) {
     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.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 }),
+              }),
+            ),
+          group,
         );
       }
 
       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 +254,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,16 +281,37 @@ 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) });
-        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;
@@ -134,8 +331,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 +350,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 +380,36 @@ 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;
             }
-          });
+            results[i] = await this.activityHandle[entry.step.id](
+              this.activityParams(items[i], { initData: this.initData }),
+            );
+          }
+        });
 
+        try {
           await Promise.all(workers);
-          return results;
-        });
+        } catch (error) {
+          recordFailure(stepResults, entry.step.id, inputData, startedAt, error);
+          throw error;
+        }
+        stepResults[entry.step.id] = {
+          __temporalStepResult: true,
+          status: 'success',
+          payload: inputData,
+          output: results,
+          startedAt,
+          endedAt: Date.now(),
+        };
+        return results;
       }
 
       default:
@@ -220,7 +439,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, group: any): Promise<any>;
     activityParams(inputData: any, extra?: {}): {
         requestContext?: any;
         runId?: any;
@@ -28,103 +26,19 @@ 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<{
-    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":"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"}