@mastra/core 1.0.0-beta.11 → 1.0.0-beta.14

package/dist/{chunk-US2U7ECW.js → chunk-3IP3DZ7G.js}

@@ -1,7 +1,7 @@
-import { validateStepInput, createDeprecationProxy, getStepResult, validateStepSuspendData, runCountDeprecationMessage, createTimeTravelExecutionParams, validateStepResumeData, Workflow, Run, ExecutionEngine } from './chunk-2ULLRN4Y.js';
-import { STREAM_FORMAT_SYMBOL, EMITTER_SYMBOL } from './chunk-NLNKQD2T.js';
-import { getErrorFromUnknown, MastraError } from './chunk-JJ5O45LH.js';
-import { Tool } from './chunk-THZTRBFS.js';
+import { validateStepInput, createDeprecationProxy, EventEmitterPubSub, getStepResult, validateStepSuspendData, runCountDeprecationMessage, createTimeTravelExecutionParams, validateStepResumeData, Workflow, Run, ExecutionEngine, hydrateSerializedStepErrors } from './chunk-QF4MHFSU.js';
+import { STREAM_FORMAT_SYMBOL, PUBSUB_SYMBOL } from './chunk-6PMMP3FR.js';
+import { getErrorFromUnknown, MastraError } from './chunk-YPLZDWG7.js';
+import { Tool } from './chunk-373OC54J.js';
 import { RequestContext } from './chunk-6TBWJV35.js';
 import { MastraBase } from './chunk-LSHPJWM5.js';
 import { RegisteredLogger } from './chunk-NRUZYMHE.js';
@@ -20,7 +20,7 @@ var StepExecutor = class extends MastraBase {
   }
   async execute(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0 } = params;
-    const abortController = new AbortController();
+    const abortController = params.abortController ?? new AbortController();
     let suspended;
     let bailed;
     const startedAt = Date.now();
@@ -84,8 +84,7 @@ var StepExecutor = class extends MastraBase {
             abort: () => {
               abortController?.abort();
             },
-            [EMITTER_SYMBOL]: params.emitter,
-            // TODO: refactor this to use our PubSub actually
+            [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(params.emitter),
             [STREAM_FORMAT_SYMBOL]: void 0,
             // TODO
             engine: {},
@@ -132,20 +131,20 @@ var StepExecutor = class extends MastraBase {
     } catch (error) {
       const endedAt = Date.now();
       const errorInstance = getErrorFromUnknown(error, {
-        includeStack: false,
+        serializeStack: false,
         fallbackMessage: "Unknown step execution error"
       });
       return {
         ...stepInfo,
         status: "failed",
         endedAt,
-        error: `Error: ${errorInstance.message}`
+        error: errorInstance
       };
     }
   }
   async evaluateConditions(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0 } = params;
-    const abortController = new AbortController();
+    const abortController = params.abortController ?? new AbortController();
     const ee = new EventEmitter();
     const results = await Promise.all(
       step.conditions.map((condition) => {
@@ -213,8 +212,7 @@ var StepExecutor = class extends MastraBase {
           abort: () => {
             abortController?.abort();
           },
-          [EMITTER_SYMBOL]: emitter,
-          // TODO: refactor this to use our PubSub actually
+          [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(emitter),
           [STREAM_FORMAT_SYMBOL]: void 0,
           // TODO
           engine: {},
@@ -233,7 +231,7 @@ var StepExecutor = class extends MastraBase {
   }
   async resolveSleep(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0 } = params;
-    const abortController = new AbortController();
+    const abortController = params.abortController ?? new AbortController();
     const ee = new EventEmitter();
     if (step.duration) {
       return step.duration;
@@ -269,8 +267,7 @@ var StepExecutor = class extends MastraBase {
             },
             // TODO
             writer: void 0,
-            [EMITTER_SYMBOL]: ee,
-            // TODO: refactor this to use our PubSub actually
+            [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(ee),
             [STREAM_FORMAT_SYMBOL]: void 0,
             // TODO
             engine: {},
@@ -292,7 +289,7 @@ var StepExecutor = class extends MastraBase {
   }
   async resolveSleepUntil(params) {
     const { step, stepResults, runId, requestContext, retryCount = 0 } = params;
-    const abortController = new AbortController();
+    const abortController = params.abortController ?? new AbortController();
     const ee = new EventEmitter();
     if (step.date) {
       return step.date.getTime() - Date.now();
@@ -328,8 +325,7 @@ var StepExecutor = class extends MastraBase {
             },
             // TODO
             writer: void 0,
-            [EMITTER_SYMBOL]: ee,
-            // TODO: refactor this to use our PubSub actually
+            [PUBSUB_SYMBOL]: this.mastra?.pubsub ?? new EventEmitterPubSub(ee),
             [STREAM_FORMAT_SYMBOL]: void 0,
             // TODO
             engine: {},
@@ -925,10 +921,52 @@ async function processWorkflowSleepUntil({
 // src/workflows/evented/workflow-event-processor/index.ts
 var WorkflowEventProcessor = class extends EventProcessor {
   stepExecutor;
+  // Map of runId -> AbortController for active workflow runs
+  abortControllers = /* @__PURE__ */ new Map();
+  // Map of child runId -> parent runId for tracking nested workflows
+  parentChildRelationships = /* @__PURE__ */ new Map();
   constructor({ mastra }) {
     super({ mastra });
     this.stepExecutor = new StepExecutor({ mastra });
   }
+  /**
+   * Get or create an AbortController for a workflow run
+   */
+  getOrCreateAbortController(runId) {
+    let controller = this.abortControllers.get(runId);
+    if (!controller) {
+      controller = new AbortController();
+      this.abortControllers.set(runId, controller);
+    }
+    return controller;
+  }
+  /**
+   * Cancel a workflow run and all its nested child workflows
+   */
+  cancelRunAndChildren(runId) {
+    const controller = this.abortControllers.get(runId);
+    if (controller) {
+      controller.abort();
+    }
+    for (const [childRunId, parentRunId] of this.parentChildRelationships.entries()) {
+      if (parentRunId === runId) {
+        this.cancelRunAndChildren(childRunId);
+      }
+    }
+  }
+  /**
+   * Clean up abort controller and relationships when a workflow completes.
+   * Also cleans up any orphaned child entries that reference this run as parent.
+   */
+  cleanupRun(runId) {
+    this.abortControllers.delete(runId);
+    this.parentChildRelationships.delete(runId);
+    for (const [childRunId, parentRunId] of this.parentChildRelationships.entries()) {
+      if (parentRunId === runId) {
+        this.parentChildRelationships.delete(childRunId);
+      }
+    }
+  }
   __registerMastra(mastra) {
     super.__registerMastra(mastra);
     this.stepExecutor.__registerMastra(mastra);
@@ -951,7 +989,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
         executionPath: [],
         resumeSteps,
         stepResults,
-        prevResult: { status: "failed", error: e.stack ?? e.message },
+        prevResult: { status: "failed", error: getErrorFromUnknown(e).toJSON() },
         requestContext,
         resumeData,
         activeSteps: {},
@@ -960,26 +998,28 @@ var WorkflowEventProcessor = class extends EventProcessor {
     });
   }
   async processWorkflowCancel({ workflowId, runId }) {
-    const currentState = await this.mastra.getStorage()?.updateWorkflowState({
+    this.cancelRunAndChildren(runId);
+    const storage = this.mastra.getStorage();
+    const currentState = await storage?.loadWorkflowSnapshot({
       workflowName: workflowId,
-      runId,
-      opts: {
-        status: "canceled"
-      }
-    });
-    await this.endWorkflow({
-      workflow: void 0,
-      workflowId,
-      runId,
-      stepResults: currentState?.context,
-      prevResult: { status: "canceled" },
-      requestContext: currentState?.requestContext,
-      executionPath: [],
-      activeSteps: {},
-      resumeSteps: [],
-      resumeData: void 0,
-      parentWorkflow: void 0
+      runId
     });
+    await this.endWorkflow(
+      {
+        workflow: void 0,
+        workflowId,
+        runId,
+        stepResults: currentState?.context ?? {},
+        prevResult: { status: "canceled" },
+        requestContext: currentState?.requestContext ?? {},
+        executionPath: [],
+        activeSteps: {},
+        resumeSteps: [],
+        resumeData: void 0,
+        parentWorkflow: void 0
+      },
+      "canceled"
+    );
   }
   async processWorkflowStart({
     workflow,
@@ -994,9 +1034,16 @@ var WorkflowEventProcessor = class extends EventProcessor {
     stepResults,
     requestContext
   }) {
+    this.getOrCreateAbortController(runId);
+    if (parentWorkflow?.runId) {
+      this.parentChildRelationships.set(runId, parentWorkflow.runId);
+    }
+    const existingRun = await this.mastra.getStorage()?.getWorkflowRunById({ runId, workflowName: workflow.id });
+    const resourceId = existingRun?.resourceId;
     await this.mastra.getStorage()?.persistWorkflowSnapshot({
       workflowName: workflow.id,
       runId,
+      resourceId,
       snapshot: {
         activePaths: [],
         suspendedPaths: {},
@@ -1033,13 +1080,13 @@ var WorkflowEventProcessor = class extends EventProcessor {
       }
     });
   }
-  async endWorkflow(args) {
+  async endWorkflow(args, status = "success") {
     const { workflowId, runId, prevResult } = args;
     await this.mastra.getStorage()?.updateWorkflowState({
       workflowName: workflowId,
       runId,
       opts: {
-        status: "success",
+        status,
         result: prevResult
       }
     });
@@ -1061,6 +1108,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
   }
   async processWorkflowEnd(args) {
     const { resumeSteps, prevResult, resumeData, parentWorkflow, activeSteps, requestContext, runId, timeTravel } = args;
+    this.cleanupRun(runId);
     if (parentWorkflow) {
       await this.mastra.pubsub.publish("workflows", {
         type: "workflow.step.end",
@@ -1136,6 +1184,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
       requestContext,
       timeTravel
     } = args;
+    this.cleanupRun(runId);
     await this.mastra.getStorage()?.updateWorkflowState({
       workflowName: workflowId,
       runId,
@@ -1529,6 +1578,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
     } else if (resumeSteps?.length > 0 && resumeSteps?.[0] === step.step.id) {
       resumeDataToUse = resumeData;
     }
+    const abortController = this.getOrCreateAbortController(runId);
     const stepResult = await this.stepExecutor.execute({
       workflowId,
       step: step.step,
@@ -1542,7 +1592,8 @@ var WorkflowEventProcessor = class extends EventProcessor {
       resumeData: resumeDataToUse,
       retryCount,
       foreachIdx: step.type === "foreach" ? executionPath[1] : void 0,
-      validateInputs: workflow.options.validateInputs
+      validateInputs: workflow.options.validateInputs,
+      abortController
     });
     requestContext = Object.fromEntries(rc.entries());
     if (stepResult.status === "bailed") {
@@ -1922,7 +1973,7 @@ var WorkflowEventProcessor = class extends EventProcessor {
       workflowId: workflowData.workflowId,
       runId: workflowData.runId
     });
-    if (currentState?.status === "canceled" && type !== "workflow.end") {
+    if (currentState?.status === "canceled" && type !== "workflow.end" && type !== "workflow.cancel") {
       return;
     }
     if (type.startsWith("workflow.user-event.")) {
@@ -2079,7 +2130,7 @@ function createStep(params) {
       outputSchema: z.object({
         text: z.string()
       }),
-      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, requestContext, abortSignal, abort }) => {
+      execute: async ({ inputData, runId, [PUBSUB_SYMBOL]: pubsub, requestContext, abortSignal, abort }) => {
         let streamPromise = {};
         streamPromise.promise = new Promise((resolve, reject) => {
           streamPromise.resolve = resolve;
@@ -2101,22 +2152,24 @@ function createStep(params) {
           name: params.name,
           args: inputData
         };
-        await emitter.emit("watch", {
-          type: "tool-call-streaming-start",
-          ...toolData ?? {}
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
+          runId,
+          data: { type: "tool-call-streaming-start", ...toolData ?? {} }
         });
         for await (const chunk of fullStream) {
           if (chunk.type === "text-delta") {
-            await emitter.emit("watch", {
-              type: "tool-call-delta",
-              ...toolData ?? {},
-              argsTextDelta: chunk.textDelta
+            await pubsub.publish(`workflow.events.v2.${runId}`, {
+              type: "watch",
+              runId,
+              data: { type: "tool-call-delta", ...toolData ?? {}, argsTextDelta: chunk.textDelta }
             });
           }
         }
-        await emitter.emit("watch", {
-          type: "tool-call-streaming-finish",
-          ...toolData ?? {}
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
+          runId,
+          data: { type: "tool-call-streaming-finish", ...toolData ?? {} }
         });
         return {
           text: await streamPromise.promise
@@ -2187,7 +2240,9 @@ function createWorkflow(params) {
     options: {
       validateInputs: params.options?.validateInputs ?? true,
       shouldPersistSnapshot: params.options?.shouldPersistSnapshot ?? (() => true),
-      tracingPolicy: params.options?.tracingPolicy
+      tracingPolicy: params.options?.tracingPolicy,
+      onFinish: params.options?.onFinish,
+      onError: params.options?.onError
     }
   });
   return new EventedWorkflow({
@@ -2209,6 +2264,7 @@ var EventedWorkflow = class extends Workflow {
     const run = this.runs.get(runIdToUse) ?? new EventedRun({
       workflowId: this.id,
       runId: runIdToUse,
+      resourceId: options?.resourceId,
       executionEngine: this.executionEngine,
       executionGraph: this.executionGraph,
       serializedStepGraph: this.serializedStepGraph,
@@ -2224,11 +2280,14 @@ var EventedWorkflow = class extends Workflow {
       workflowStatus: run.workflowRunStatus,
       stepResults: {}
     });
-    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, false);
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, {
+      withNestedWorkflows: false
+    });
     if (!workflowSnapshotInStorage && shouldPersistSnapshot) {
       await this.mastra?.getStorage()?.persistWorkflowSnapshot({
         workflowName: this.id,
         runId: runIdToUse,
+        resourceId: options?.resourceId,
         snapshot: {
           runId: runIdToUse,
           status: "pending",
@@ -2255,6 +2314,25 @@ var EventedRun = class extends Run {
     super(params);
     this.serializedStepGraph = params.serializedStepGraph;
   }
+  /**
+   * Set up abort signal handler to publish workflow.cancel event when abortController.abort() is called.
+   * This ensures consistent cancellation behavior whether abort() is called directly or via cancel().
+   */
+  setupAbortHandler() {
+    const abortHandler = () => {
+      this.mastra?.pubsub.publish("workflows", {
+        type: "workflow.cancel",
+        runId: this.runId,
+        data: {
+          workflowId: this.workflowId,
+          runId: this.runId
+        }
+      }).catch((err) => {
+        console.error(`Failed to publish workflow.cancel for runId ${this.runId}:`, err);
+      });
+    };
+    this.abortController.signal.addEventListener("abort", abortHandler, { once: true });
+  }
   async start({
     inputData,
     initialState,
@@ -2272,6 +2350,7 @@ var EventedRun = class extends Run {
     await this.mastra?.getStorage()?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId,
+      resourceId: this.resourceId,
       snapshot: {
         runId: this.runId,
         serializedStepGraph: this.serializedStepGraph,
@@ -2289,6 +2368,10 @@ var EventedRun = class extends Run {
     });
     const inputDataToUse = await this._validateInput(inputData);
     const initialStateToUse = await this._validateInitialState(initialState ?? {});
+    if (!this.mastra?.pubsub) {
+      throw new Error("Mastra instance with pubsub is required for workflow execution");
+    }
+    this.setupAbortHandler();
     const result = await this.executionEngine.execute({
       workflowId: this.workflowId,
       runId: this.runId,
@@ -2296,20 +2379,7 @@ var EventedRun = class extends Run {
       serializedStepGraph: this.serializedStepGraph,
       input: inputDataToUse,
       initialState: initialStateToUse,
-      emitter: {
-        emit: async (event, data) => {
-          this.emitter.emit(event, data);
-        },
-        on: (event, callback) => {
-          this.emitter.on(event, callback);
-        },
-        off: (event, callback) => {
-          this.emitter.off(event, callback);
-        },
-        once: (event, callback) => {
-          this.emitter.once(event, callback);
-        }
-      },
+      pubsub: this.mastra.pubsub,
       retryConfig: this.retryConfig,
       requestContext,
       abortController: this.abortController
@@ -2319,6 +2389,62 @@ var EventedRun = class extends Run {
     }
     return result;
   }
+  /**
+   * Starts the workflow execution without waiting for completion (fire-and-forget).
+   * Returns immediately with the runId. The workflow executes in the background via pubsub.
+   * Use this when you don't need to wait for the result or want to avoid polling failures.
+   */
+  async startAsync({
+    inputData,
+    initialState,
+    requestContext
+  }) {
+    if (this.serializedStepGraph.length === 0) {
+      throw new Error(
+        "Execution flow of workflow is not defined. Add steps to the workflow via .then(), .branch(), etc."
+      );
+    }
+    if (!this.executionGraph.steps) {
+      throw new Error("Uncommitted step flow changes detected. Call .commit() to register the steps.");
+    }
+    requestContext = requestContext ?? new RequestContext();
+    await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId,
+      resourceId: this.resourceId,
+      snapshot: {
+        runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
+        status: "running",
+        value: {},
+        context: {},
+        requestContext: Object.fromEntries(requestContext.entries()),
+        activePaths: [],
+        activeStepsPath: {},
+        suspendedPaths: {},
+        resumeLabels: {},
+        waitingPaths: {},
+        timestamp: Date.now()
+      }
+    });
+    const inputDataToUse = await this._validateInput(inputData);
+    const initialStateToUse = await this._validateInitialState(initialState ?? {});
+    if (!this.mastra?.pubsub) {
+      throw new Error("Mastra instance with pubsub is required for workflow execution");
+    }
+    await this.mastra.pubsub.publish("workflows", {
+      type: "workflow.start",
+      runId: this.runId,
+      data: {
+        workflowId: this.workflowId,
+        runId: this.runId,
+        prevResult: { status: "success", output: inputDataToUse },
+        requestContext: Object.fromEntries(requestContext.entries()),
+        initialState: initialStateToUse
+      }
+    });
+    return { runId: this.runId };
+  }
   // TODO: stream
   async resume(params) {
     let steps = [];
@@ -2358,6 +2484,10 @@ var EventedRun = class extends Run {
     }
     const suspendedStep = this.workflowSteps[steps?.[0] ?? ""];
     const resumeDataToUse = await this._validateResumeData(params.resumeData, suspendedStep);
+    if (!this.mastra?.pubsub) {
+      throw new Error("Mastra instance with pubsub is required for workflow execution");
+    }
+    this.setupAbortHandler();
     const executionResultPromise = this.executionEngine.execute({
       workflowId: this.workflowId,
       runId: this.runId,
@@ -2370,21 +2500,7 @@ var EventedRun = class extends Run {
         resumePayload: resumeDataToUse,
         resumePath
       },
-      emitter: {
-        emit: (event, data) => {
-          this.emitter.emit(event, data);
-          return Promise.resolve();
-        },
-        on: (event, callback) => {
-          this.emitter.on(event, callback);
-        },
-        off: (event, callback) => {
-          this.emitter.off(event, callback);
-        },
-        once: (event, callback) => {
-          this.emitter.once(event, callback);
-        }
-      },
+      pubsub: this.mastra.pubsub,
       requestContext,
       abortController: this.abortController
     }).then((result) => {
@@ -2428,14 +2544,14 @@ var EventedRun = class extends Run {
     };
   }
   async cancel() {
-    await this.mastra?.pubsub.publish("workflows", {
-      type: "workflow.cancel",
+    await this.mastra?.getStorage()?.updateWorkflowState({
+      workflowName: this.workflowId,
       runId: this.runId,
-      data: {
-        workflowId: this.workflowId,
-        runId: this.runId
+      opts: {
+        status: "canceled"
       }
     });
+    this.abortController.abort();
   }
 };
 
@@ -2556,7 +2672,7 @@ var EventedExecutionEngine = class extends ExecutionEngine {
         }
       });
     }
-    const resultData = await new Promise((resolve) => {
+    const resultData = await new Promise((resolve, reject) => {
       const finishCb = async (event, ack) => {
         if (event.runId !== params.runId) {
           await ack?.();
@@ -2565,41 +2681,58 @@ var EventedExecutionEngine = class extends ExecutionEngine {
         if (["workflow.end", "workflow.fail", "workflow.suspend"].includes(event.type)) {
           await ack?.();
           await pubsub.unsubscribe("workflows-finish", finishCb);
+          if (event.type === "workflow.fail" && event.data.stepResults) {
+            event.data.stepResults = hydrateSerializedStepErrors(event.data.stepResults);
+          }
           resolve(event.data);
           return;
         }
         await ack?.();
       };
-      pubsub.subscribe("workflows-finish", finishCb).catch(() => {
+      pubsub.subscribe("workflows-finish", finishCb).catch((err) => {
+        console.error("Failed to subscribe to workflows-finish:", err);
+        reject(err);
       });
     });
+    let callbackArg;
     if (resultData.prevResult.status === "failed") {
-      return {
+      callbackArg = {
         status: "failed",
         error: resultData.prevResult.error,
         steps: resultData.stepResults
       };
     } else if (resultData.prevResult.status === "suspended") {
+      callbackArg = {
+        status: "suspended",
+        steps: resultData.stepResults
+      };
+    } else {
+      callbackArg = {
+        status: resultData.prevResult.status,
+        result: resultData.prevResult?.output,
+        steps: resultData.stepResults
+      };
+    }
+    await this.invokeLifecycleCallbacks(callbackArg);
+    let result;
+    if (resultData.prevResult.status === "suspended") {
       const suspendedSteps = Object.entries(resultData.stepResults).map(([_stepId, stepResult]) => {
         if (stepResult.status === "suspended") {
           return stepResult.suspendPayload?.__workflow_meta?.path ?? [];
         }
         return null;
       }).filter(Boolean);
-      return {
-        status: "suspended",
-        steps: resultData.stepResults,
+      result = {
+        ...callbackArg,
         suspended: suspendedSteps
       };
+    } else {
+      result = callbackArg;
     }
-    return {
-      status: resultData.prevResult.status,
-      result: resultData.prevResult?.output,
-      steps: resultData.stepResults
-    };
+    return result;
   }
 };
 
 export { EventedExecutionEngine, EventedRun, EventedWorkflow, StepExecutor, WorkflowEventProcessor, cloneStep, cloneWorkflow, createStep, createWorkflow };
-//# sourceMappingURL=chunk-US2U7ECW.js.map
-//# sourceMappingURL=chunk-US2U7ECW.js.map
+//# sourceMappingURL=chunk-3IP3DZ7G.js.map
+//# sourceMappingURL=chunk-3IP3DZ7G.js.map