@mastra/inngest 0.0.0-custom-instrumentation-20250626084921 → 0.0.0-fix-generate-title-20250616171351

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 var crypto = require('crypto');
 var realtime = require('@inngest/realtime');
+var core = require('@mastra/core');
 var di = require('@mastra/core/di');
-var tools = require('@mastra/core/tools');
 var workflows = require('@mastra/core/workflows');
 var _constants = require('@mastra/core/workflows/_constants');
 var hono = require('inngest/hono');
@@ -45,7 +45,7 @@ var InngestRun = class extends workflows.Run {
   }
   async getRunOutput(eventId) {
     let runs = await this.getRuns(eventId);
-    while (runs?.[0]?.status !== "Completed" || runs?.[0]?.event_id !== eventId) {
+    while (runs?.[0]?.status !== "Completed") {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
       runs = await this.getRuns(eventId);
       if (runs?.[0]?.status === "Failed" || runs?.[0]?.status === "Cancelled") {
@@ -54,12 +54,6 @@ var InngestRun = class extends workflows.Run {
     }
     return runs?.[0];
   }
-  async sendEvent(event, data) {
-    await this.inngest.send({
-      name: `user-event-${event}`,
-      data
-    });
-  }
   async start({
     inputData
   }) {
@@ -97,17 +91,6 @@ var InngestRun = class extends workflows.Run {
     return result;
   }
   async resume(params) {
-    const p = this._resume(params).then((result) => {
-      if (result.status !== "suspended") {
-        this.closeStreamAction?.().catch(() => {
-        });
-      }
-      return result;
-    });
-    this.executionResults = p;
-    return p;
-  }
-  async _resume(params) {
     const steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
       (step) => typeof step === "string" ? step : step?.id
     );
@@ -141,60 +124,25 @@ var InngestRun = class extends workflows.Run {
     }
     return result;
   }
-  watch(cb, type = "watch") {
-    let active = true;
+  watch(cb) {
     const streamPromise = realtime.subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: [type],
+        topics: ["watch"],
         app: this.inngest
       },
       (message) => {
-        if (active) {
-          cb(message.data);
-        }
+        cb(message.data);
       }
     );
     return () => {
-      active = false;
-      streamPromise.then(async (stream) => {
-        return stream.cancel();
+      streamPromise.then((stream) => {
+        stream.cancel();
       }).catch((err) => {
         console.error(err);
       });
     };
   }
-  stream({ inputData, runtimeContext } = {}) {
-    const { readable, writable } = new TransformStream();
-    const writer = writable.getWriter();
-    const unwatch = this.watch(async (event) => {
-      try {
-        await writer.write(event);
-      } catch {
-      }
-    }, "watch-v2");
-    this.closeStreamAction = async () => {
-      unwatch();
-      try {
-        await writer.close();
-      } catch (err) {
-        console.error("Error closing stream:", err);
-      } finally {
-        writer.releaseLock();
-      }
-    };
-    this.executionResults = this.start({ inputData, runtimeContext }).then((result) => {
-      if (result.status !== "suspended") {
-        this.closeStreamAction?.().catch(() => {
-        });
-      }
-      return result;
-    });
-    return {
-      stream: readable,
-      getWorkflowState: () => this.executionResults
-    };
-  }
 };
 var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
   #mastra;
@@ -279,41 +227,6 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     this.runs.set(runIdToUse, run);
     return run;
   }
-  async createRunAsync(options) {
-    const runIdToUse = options?.runId || crypto.randomUUID();
-    const run = this.runs.get(runIdToUse) ?? new InngestRun(
-      {
-        workflowId: this.id,
-        runId: runIdToUse,
-        executionEngine: this.executionEngine,
-        executionGraph: this.executionGraph,
-        serializedStepGraph: this.serializedStepGraph,
-        mastra: this.#mastra,
-        retryConfig: this.retryConfig,
-        cleanup: () => this.runs.delete(runIdToUse)
-      },
-      this.inngest
-    );
-    this.runs.set(runIdToUse, run);
-    await this.mastra?.getStorage()?.persistWorkflowSnapshot({
-      workflowName: this.id,
-      runId: runIdToUse,
-      snapshot: {
-        runId: runIdToUse,
-        status: "pending",
-        value: {},
-        context: {},
-        activePaths: [],
-        serializedStepGraph: this.serializedStepGraph,
-        suspendedPaths: {},
-        result: void 0,
-        error: void 0,
-        // @ts-ignore
-        timestamp: Date.now()
-      }
-    });
-    return run;
-  }
   getFunction() {
     if (this.function) {
       return this.function;
@@ -337,18 +250,12 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
             try {
               await publish({
                 channel: `workflow:${this.id}:${runId}`,
-                topic: event2,
+                topic: "watch",
                 data
               });
             } catch (err) {
               this.logger.error("Error emitting event: " + (err?.stack ?? err?.message ?? err));
             }
-          },
-          on: (_event, _callback) => {
-          },
-          off: (_event, _callback) => {
-          },
-          once: (_event, _callback) => {
           }
         };
         const engine = new InngestExecutionEngine(this.#mastra, step, attempt);
@@ -386,14 +293,8 @@ var InngestWorkflow = class _InngestWorkflow extends workflows.Workflow {
     return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
   }
 };
-function isAgent(params) {
-  return params?.component === "AGENT";
-}
-function isTool(params) {
-  return params instanceof tools.Tool;
-}
 function createStep(params) {
-  if (isAgent(params)) {
+  if (params instanceof core.Agent) {
     return {
       id: params.name,
       // @ts-ignore
@@ -458,7 +359,7 @@ function createStep(params) {
       }
     };
   }
-  if (isTool(params)) {
+  if (params instanceof core.Tool) {
     if (!params.inputSchema || !params.outputSchema) {
       throw new Error("Tool must have input and output schemas defined");
     }
@@ -524,18 +425,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     this.inngestStep = inngestStep;
     this.inngestAttempts = inngestAttempts;
   }
-  async execute(params) {
-    await params.emitter.emit("watch-v2", {
-      type: "start",
-      payload: { runId: params.runId }
-    });
-    const result = await super.execute(params);
-    await params.emitter.emit("watch-v2", {
-      type: "finish",
-      payload: { runId: params.runId }
-    });
-    return result;
-  }
   async fmtReturnValue(executionSpan, emitter, stepResults, lastOutput, error) {
     const base = {
       status: lastOutput.status,
@@ -619,16 +508,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
   async executeSleep({ id, duration }) {
     await this.inngestStep.sleep(id, duration);
   }
-  async executeWaitForEvent({ event, timeout }) {
-    const eventData = await this.inngestStep.waitForEvent(`user-event-${event}`, {
-      event: `user-event-${event}`,
-      timeout: timeout ?? 5e3
-    });
-    if (eventData === null) {
-      throw "Timeout waiting for event";
-    }
-    return eventData?.data;
-  }
   async executeStep({
     step,
     stepResults,
@@ -638,10 +517,9 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     emitter,
     runtimeContext
   }) {
-    const startedAt = await this.inngestStep.run(
+    await this.inngestStep.run(
       `workflow.${executionContext.workflowId}.run.${executionContext.runId}.step.${step.id}.running_ev`,
       async () => {
-        const startedAt2 = Date.now();
         await emitter.emit("watch", {
           type: "watch",
           payload: {
@@ -663,13 +541,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
           },
           eventTimestamp: Date.now()
         });
-        await emitter.emit("watch-v2", {
-          type: "step-start",
-          payload: {
-            id: step.id
-          }
-        });
-        return startedAt2;
       }
     );
     if (step instanceof InngestWorkflow) {
@@ -730,13 +601,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               },
               eventTimestamp: Date.now()
             });
-            await emitter.emit("watch-v2", {
-              type: "step-result",
-              payload: {
-                id: step.id,
-                status: "failed"
-              }
-            });
             return { executionContext, result: { status: "failed", error: result?.error } };
           } else if (result.status === "suspended") {
             const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult]) => {
@@ -763,12 +627,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
                 },
                 eventTimestamp: Date.now()
               });
-              await emitter.emit("watch-v2", {
-                type: "step-suspended",
-                payload: {
-                  id: step.id
-                }
-              });
               return {
                 executionContext,
                 result: {
@@ -819,13 +677,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             },
             eventTimestamp: Date.now()
           });
-          await emitter.emit("watch-v2", {
-            type: "step-finish",
-            payload: {
-              id: step.id,
-              metadata: {}
-            }
-          });
           return { executionContext, result: { status: "success", output: result?.result } };
         }
       );
@@ -835,7 +686,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     const stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
       let execResults;
       let suspended;
-      let bailed;
       try {
         const result = await step.execute({
           runId: executionContext.runId,
@@ -855,9 +705,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             executionContext.suspendedPaths[step.id] = executionContext.executionPath;
             suspended = { payload: suspendPayload };
           },
-          bail: (result2) => {
-            bailed = { payload: result2 };
-          },
           resume: {
             steps: resume?.steps?.slice(1) || [],
             resumePayload: resume?.resumePayload,
@@ -869,39 +716,12 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
             step: this.inngestStep
           }
         });
-        const endedAt = Date.now();
-        execResults = {
-          status: "success",
-          output: result,
-          startedAt,
-          endedAt,
-          payload: prevOutput,
-          resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
-          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
-        };
+        execResults = { status: "success", output: result };
       } catch (e) {
-        execResults = {
-          status: "failed",
-          payload: prevOutput,
-          error: e instanceof Error ? e.message : String(e),
-          endedAt: Date.now(),
-          startedAt,
-          resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
-          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
-        };
+        execResults = { status: "failed", error: e instanceof Error ? e.message : String(e) };
       }
       if (suspended) {
-        execResults = {
-          status: "suspended",
-          suspendedPayload: suspended.payload,
-          payload: prevOutput,
-          suspendedAt: Date.now(),
-          startedAt,
-          resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
-          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
-        };
-      } else if (bailed) {
-        execResults = { status: "bailed", output: bailed.payload, payload: prevOutput, endedAt: Date.now(), startedAt };
+        execResults = { status: "suspended", payload: suspended.payload };
       }
       if (execResults.status === "failed") {
         if (executionContext.retryConfig.attempts > 0 && this.inngestAttempts < executionContext.retryConfig.attempts) {
@@ -913,43 +733,18 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
         payload: {
           currentStep: {
             id: step.id,
-            ...execResults
+            status: execResults.status,
+            output: execResults.output
           },
           workflowState: {
             status: "running",
-            steps: { ...stepResults, [step.id]: execResults },
+            steps: stepResults,
             result: null,
             error: null
           }
         },
         eventTimestamp: Date.now()
       });
-      if (execResults.status === "suspended") {
-        await emitter.emit("watch-v2", {
-          type: "step-suspended",
-          payload: {
-            id: step.id,
-            status: execResults.status,
-            output: execResults.status === "success" ? execResults?.output : void 0
-          }
-        });
-      } else {
-        await emitter.emit("watch-v2", {
-          type: "step-result",
-          payload: {
-            id: step.id,
-            status: execResults.status,
-            output: execResults.status === "success" ? execResults?.output : void 0
-          }
-        });
-        await emitter.emit("watch-v2", {
-          type: "step-finish",
-          payload: {
-            id: step.id,
-            metadata: {}
-          }
-        });
-      }
       return { result: execResults, executionContext, stepResults };
     });
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
@@ -1026,8 +821,6 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
               // TODO: this function shouldn't have suspend probably?
               suspend: async (_suspendPayload) => {
               },
-              bail: () => {
-              },
               [_constants.EMITTER_SYMBOL]: emitter,
               engine: {
                 step: this.inngestStep
@@ -1069,7 +862,7 @@ var InngestExecutionEngine = class extends workflows.DefaultExecutionEngine {
     if (hasFailed) {
       execResults = { status: "failed", error: hasFailed.result.error };
     } else if (hasSuspended) {
-      execResults = { status: "suspended", payload: hasSuspended.result.suspendPayload };
+      execResults = { status: "suspended", payload: hasSuspended.result.payload };
     } else {
       execResults = {
         status: "success",