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

package/dist/{chunk-US2U7ECW.js → chunk-BQDZIQ3G.js}

@@ -1,8 +1,8 @@
-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-E5BQRAJK.js';
+import { STREAM_FORMAT_SYMBOL, PUBSUB_SYMBOL } from './chunk-6PMMP3FR.js';
+import { Tool } from './chunk-373OC54J.js';
 import { RequestContext } from './chunk-6TBWJV35.js';
+import { getErrorFromUnknown, MastraError } from './chunk-YPLZDWG7.js';
 import { MastraBase } from './chunk-LSHPJWM5.js';
 import { RegisteredLogger } from './chunk-NRUZYMHE.js';
 import EventEmitter from 'events';
@@ -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,14 +131,14 @@ 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
       };
     }
   }
@@ -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: {},
@@ -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: {},
@@ -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: {},
@@ -951,7 +947,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 +956,27 @@ var WorkflowEventProcessor = class extends EventProcessor {
     });
   }
   async processWorkflowCancel({ workflowId, runId }) {
-    const currentState = await this.mastra.getStorage()?.updateWorkflowState({
+    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 +991,12 @@ var WorkflowEventProcessor = class extends EventProcessor {
     stepResults,
     requestContext
   }) {
+    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 +1033,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
       }
     });
@@ -1922,7 +1922,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 +2079,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 +2101,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 +2189,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 +2213,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,
@@ -2229,6 +2234,7 @@ var EventedWorkflow = class extends Workflow {
       await this.mastra?.getStorage()?.persistWorkflowSnapshot({
         workflowName: this.id,
         runId: runIdToUse,
+        resourceId: options?.resourceId,
         snapshot: {
           runId: runIdToUse,
           status: "pending",
@@ -2272,6 +2278,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 +2296,9 @@ 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");
+    }
     const result = await this.executionEngine.execute({
       workflowId: this.workflowId,
       runId: this.runId,
@@ -2296,20 +2306,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 +2316,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 +2411,9 @@ 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");
+    }
     const executionResultPromise = this.executionEngine.execute({
       workflowId: this.workflowId,
       runId: this.runId,
@@ -2370,21 +2426,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,6 +2470,13 @@ var EventedRun = class extends Run {
     };
   }
   async cancel() {
+    await this.mastra?.getStorage()?.updateWorkflowState({
+      workflowName: this.workflowId,
+      runId: this.runId,
+      opts: {
+        status: "canceled"
+      }
+    });
     await this.mastra?.pubsub.publish("workflows", {
       type: "workflow.cancel",
       runId: this.runId,
@@ -2556,7 +2605,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 +2614,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-BQDZIQ3G.js.map
+//# sourceMappingURL=chunk-BQDZIQ3G.js.map