@mastra/inngest 0.0.0-ai-sdk-network-text-delta-20251017172601 → 0.0.0-allow-to-pass-a-mastra-url-instance-20251105224938

package/dist/index.js

@@ -1,9 +1,11 @@
 import { randomUUID } from 'crypto';
+import { ReadableStream } from 'stream/web';
 import { subscribe } from '@inngest/realtime';
-import { wrapMastra, AISpanType } from '@mastra/core/ai-tracing';
-import { RuntimeContext } from '@mastra/core/di';
+import { RequestContext } from '@mastra/core/di';
+import { wrapMastra, SpanType } from '@mastra/core/observability';
+import { ChunkFrom, WorkflowRunOutput } from '@mastra/core/stream';
 import { ToolStream, Tool } from '@mastra/core/tools';
-import { Run, Workflow, DefaultExecutionEngine, getStepResult, validateStepInput } from '@mastra/core/workflows';
+import { Run, Workflow, DefaultExecutionEngine, createDeprecationProxy, getStepResult, runCountDeprecationMessage, validateStepInput } from '@mastra/core/workflows';
 import { EMITTER_SYMBOL, STREAM_FORMAT_SYMBOL } from '@mastra/core/workflows/_constants';
 import { NonRetriableError, RetryAfterError } from 'inngest';
 import { serve as serve$1 } from 'inngest/hono';
@@ -16,7 +18,7 @@ function serve({
   functions: userFunctions = [],
   registerOptions
 }) {
-  const wfs = mastra.getWorkflows();
+  const wfs = mastra.listWorkflows();
   const workflowFunctions = Array.from(
     new Set(
       Object.values(wfs).flatMap((wf) => {
@@ -55,11 +57,12 @@ var InngestRun = class extends Run {
   }
   async getRunOutput(eventId) {
     let runs = await this.getRuns(eventId);
+    const storage = this.#mastra?.getStorage();
     while (runs?.[0]?.status !== "Completed" || runs?.[0]?.event_id !== eventId) {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
       runs = await this.getRuns(eventId);
       if (runs?.[0]?.status === "Failed") {
-        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+        const snapshot = await storage?.loadWorkflowSnapshot({
           workflowName: this.workflowId,
           runId: this.runId
         });
@@ -68,7 +71,7 @@ var InngestRun = class extends Run {
         };
       }
       if (runs?.[0]?.status === "Cancelled") {
-        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+        const snapshot = await storage?.loadWorkflowSnapshot({
           workflowName: this.workflowId,
           runId: this.runId
         });
@@ -77,25 +80,20 @@ var InngestRun = class extends Run {
     }
     return runs?.[0];
   }
-  async sendEvent(event, data) {
-    await this.inngest.send({
-      name: `user-event-${event}`,
-      data
-    });
-  }
   async cancel() {
+    const storage = this.#mastra?.getStorage();
     await this.inngest.send({
       name: `cancel.workflow.${this.workflowId}`,
       data: {
         runId: this.runId
       }
     });
-    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+    const snapshot = await storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
     if (snapshot) {
-      await this.#mastra?.storage?.persistWorkflowSnapshot({
+      await storage?.persistWorkflowSnapshot({
         workflowName: this.workflowId,
         runId: this.runId,
         resourceId: this.resourceId,
@@ -106,9 +104,15 @@ var InngestRun = class extends Run {
       });
     }
   }
-  async start({
+  async start(params) {
+    return this._start(params);
+  }
+  async _start({
     inputData,
-    initialState
+    initialState,
+    outputOptions,
+    tracingOptions,
+    format
   }) {
     await this.#mastra.getStorage()?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
@@ -135,7 +139,10 @@ var InngestRun = class extends Run {
         inputData: inputDataToUse,
         initialState: initialStateToUse,
         runId: this.runId,
-        resourceId: this.resourceId
+        resourceId: this.resourceId,
+        outputOptions,
+        tracingOptions,
+        format
       }
     });
     const eventId = eventOutput.ids[0];
@@ -164,10 +171,11 @@ var InngestRun = class extends Run {
     return p;
   }
   async _resume(params) {
+    const storage = this.#mastra?.getStorage();
     const steps = (Array.isArray(params.step) ? params.step : [params.step]).map(
       (step) => typeof step === "string" ? step : step?.id
     );
-    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+    const snapshot = await storage?.loadWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId
     });
@@ -201,12 +209,12 @@ var InngestRun = class extends Run {
     }
     return result;
   }
-  watch(cb, type = "watch") {
+  watch(cb) {
     let active = true;
     const streamPromise = subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: [type],
+        topics: ["watch"],
         app: this.inngest
       },
       (message) => {
@@ -224,20 +232,35 @@ var InngestRun = class extends Run {
       });
     };
   }
-  stream({ inputData, runtimeContext } = {}) {
+  streamLegacy({ inputData, requestContext } = {}) {
     const { readable, writable } = new TransformStream();
     const writer = writable.getWriter();
     const unwatch = this.watch(async (event) => {
       try {
+        await writer.write({
+          // @ts-ignore
+          type: "start",
+          // @ts-ignore
+          payload: { runId: this.runId }
+        });
         const e = {
           ...event,
           type: event.type.replace("workflow-", "")
         };
+        if (e.type === "step-output") {
+          e.type = e.payload.output.type;
+          e.payload = e.payload.output.payload;
+        }
         await writer.write(e);
       } catch {
       }
-    }, "watch-v2");
+    });
     this.closeStreamAction = async () => {
+      await writer.write({
+        type: "finish",
+        // @ts-ignore
+        payload: { runId: this.runId }
+      });
       unwatch();
       try {
         await writer.close();
@@ -247,7 +270,7 @@ var InngestRun = class extends Run {
         writer.releaseLock();
       }
     };
-    this.executionResults = this.start({ inputData, runtimeContext }).then((result) => {
+    this.executionResults = this._start({ inputData, requestContext, format: "legacy" }).then((result) => {
       if (result.status !== "suspended") {
         this.closeStreamAction?.().catch(() => {
         });
@@ -259,6 +282,82 @@ var InngestRun = class extends Run {
       getWorkflowState: () => this.executionResults
     };
   }
+  stream({
+    inputData,
+    requestContext,
+    tracingOptions,
+    closeOnSuspend = true,
+    initialState,
+    outputOptions
+  } = {}) {
+    if (this.closeStreamAction && this.streamOutput) {
+      return this.streamOutput;
+    }
+    this.closeStreamAction = async () => {
+    };
+    const self = this;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const unwatch = self.watch(async ({ type, from = ChunkFrom.WORKFLOW, payload }) => {
+          controller.enqueue({
+            type,
+            runId: self.runId,
+            from,
+            payload: {
+              stepName: payload?.id,
+              ...payload
+            }
+          });
+        });
+        self.closeStreamAction = async () => {
+          unwatch();
+          try {
+            await controller.close();
+          } catch (err) {
+            console.error("Error closing stream:", err);
+          }
+        };
+        const executionResultsPromise = self._start({
+          inputData,
+          requestContext,
+          // tracingContext, // We are not able to pass a reference to a span here, what to do?
+          initialState,
+          tracingOptions,
+          outputOptions,
+          format: "vnext"
+        });
+        let executionResults;
+        try {
+          executionResults = await executionResultsPromise;
+          if (closeOnSuspend) {
+            self.closeStreamAction?.().catch(() => {
+            });
+          } else if (executionResults.status !== "suspended") {
+            self.closeStreamAction?.().catch(() => {
+            });
+          }
+          if (self.streamOutput) {
+            self.streamOutput.updateResults(
+              executionResults
+            );
+          }
+        } catch (err) {
+          self.streamOutput?.rejectResults(err);
+          self.closeStreamAction?.().catch(() => {
+          });
+        }
+      }
+    });
+    this.streamOutput = new WorkflowRunOutput({
+      runId: this.runId,
+      workflowId: this.workflowId,
+      stream
+    });
+    return this.streamOutput;
+  }
+  streamVNext(args = {}) {
+    return this.stream(args);
+  }
 };
 var InngestWorkflow = class _InngestWorkflow extends Workflow {
   #mastra;
@@ -275,13 +374,13 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     this.#mastra = params.mastra;
     this.inngest = inngest;
   }
-  async getWorkflowRuns(args) {
+  async listWorkflowRuns(args) {
     const storage = this.#mastra?.getStorage();
     if (!storage) {
       this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
       return { runs: [], total: 0 };
     }
-    return storage.getWorkflowRuns({ workflowName: this.id, ...args ?? {} });
+    return storage.listWorkflowRuns({ workflowName: this.id, ...args ?? {} });
   }
   async getWorkflowRunById(runId) {
     const storage = this.#mastra?.getStorage();
@@ -310,16 +409,7 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       }
     }
   }
-  /**
-   * @deprecated Use createRunAsync() instead.
-   * @throws {Error} Always throws an error directing users to use createRunAsync()
-   */
-  createRun(_options) {
-    throw new Error(
-      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = workflow.createRun();\n  After:  const run = await workflow.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
-    );
-  }
-  async createRunAsync(options) {
+  async createRun(options) {
     const runIdToUse = options?.runId || randomUUID();
     const run = this.runs.get(runIdToUse) ?? new InngestRun(
       {
@@ -381,7 +471,7 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, initialState, runId, resourceId, resume, outputOptions } = event.data;
+        let { inputData, initialState, runId, resourceId, resume, outputOptions, format } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
             return randomUUID();
@@ -420,13 +510,19 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
           initialState,
           emitter,
           retryConfig: this.retryConfig,
-          runtimeContext: new RuntimeContext(),
+          requestContext: new RequestContext(),
           // TODO
           resume,
+          format,
           abortController: new AbortController(),
-          currentSpan: void 0,
-          // TODO: Pass actual parent AI span from workflow execution context
-          outputOptions
+          // currentSpan: undefined, // TODO: Pass actual parent Span from workflow execution context
+          outputOptions,
+          writableStream: new WritableStream({
+            write(chunk) {
+              void emitter.emit("watch", chunk).catch(() => {
+              });
+            }
+          })
         });
         await step.run(`workflow.${this.id}.finalize`, async () => {
           if (result.status === "failed") {
@@ -464,7 +560,7 @@ function isAgent(params) {
 function isTool(params) {
   return params instanceof Tool;
 }
-function createStep(params) {
+function createStep(params, agentOptions) {
   if (isAgent(params)) {
     return {
       id: params.name,
@@ -472,12 +568,23 @@ function createStep(params) {
       // @ts-ignore
       inputSchema: z.object({
         prompt: z.string()
+        // resourceId: z.string().optional(),
+        // threadId: z.string().optional(),
       }),
       // @ts-ignore
       outputSchema: z.object({
         text: z.string()
       }),
-      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort, tracingContext }) => {
+      execute: async ({
+        inputData,
+        [EMITTER_SYMBOL]: emitter,
+        [STREAM_FORMAT_SYMBOL]: streamFormat,
+        requestContext,
+        tracingContext,
+        abortSignal,
+        abort,
+        writer
+      }) => {
         let streamPromise = {};
         streamPromise.promise = new Promise((resolve, reject) => {
           streamPromise.resolve = resolve;
@@ -487,61 +594,60 @@ function createStep(params) {
           name: params.name,
           args: inputData
         };
-        if ((await params.getLLM()).getModel().specificationVersion === `v2`) {
-          const { fullStream } = await params.stream(inputData.prompt, {
-            runtimeContext,
+        let stream;
+        if ((await params.getModel()).specificationVersion === "v1") {
+          const { fullStream } = await params.streamLegacy(inputData.prompt, {
+            ...agentOptions ?? {},
+            // resourceId: inputData.resourceId,
+            // threadId: inputData.threadId,
+            requestContext,
             tracingContext,
             onFinish: (result) => {
               streamPromise.resolve(result.text);
+              void agentOptions?.onFinish?.(result);
             },
             abortSignal
           });
-          if (abortSignal.aborted) {
-            return abort();
-          }
-          await emitter.emit("watch-v2", {
-            type: "tool-call-streaming-start",
-            ...toolData ?? {}
-          });
-          for await (const chunk of fullStream) {
-            if (chunk.type === "text-delta") {
-              await emitter.emit("watch-v2", {
-                type: "tool-call-delta",
-                ...toolData ?? {},
-                argsTextDelta: chunk.payload.text
-              });
-            }
-          }
+          stream = fullStream;
         } else {
-          const { fullStream } = await params.streamLegacy(inputData.prompt, {
-            runtimeContext,
+          const modelOutput = await params.stream(inputData.prompt, {
+            ...agentOptions ?? {},
+            requestContext,
             tracingContext,
             onFinish: (result) => {
               streamPromise.resolve(result.text);
+              void agentOptions?.onFinish?.(result);
             },
             abortSignal
           });
-          if (abortSignal.aborted) {
-            return abort();
-          }
-          await emitter.emit("watch-v2", {
+          stream = modelOutput.fullStream;
+        }
+        if (streamFormat === "legacy") {
+          await emitter.emit("watch", {
             type: "tool-call-streaming-start",
             ...toolData ?? {}
           });
-          for await (const chunk of fullStream) {
+          for await (const chunk of stream) {
             if (chunk.type === "text-delta") {
-              await emitter.emit("watch-v2", {
+              await emitter.emit("watch", {
                 type: "tool-call-delta",
                 ...toolData ?? {},
                 argsTextDelta: chunk.textDelta
               });
             }
           }
+          await emitter.emit("watch", {
+            type: "tool-call-streaming-finish",
+            ...toolData ?? {}
+          });
+        } else {
+          for await (const chunk of stream) {
+            await writer.write(chunk);
+          }
+        }
+        if (abortSignal.aborted) {
+          return abort();
         }
-        await emitter.emit("watch-v2", {
-          type: "tool-call-streaming-finish",
-          ...toolData ?? {}
-        });
         return {
           text: await streamPromise.promise
         };
@@ -560,11 +666,11 @@ function createStep(params) {
       description: params.description,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
-      execute: async ({ inputData, mastra, runtimeContext, tracingContext, suspend, resumeData }) => {
+      execute: async ({ inputData, mastra, requestContext, tracingContext, suspend, resumeData }) => {
         return params.execute({
           context: inputData,
           mastra: wrapMastra(mastra, tracingContext),
-          runtimeContext,
+          requestContext,
           tracingContext,
           suspend,
           resumeData
@@ -627,63 +733,16 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     this.inngestStep = inngestStep;
     this.inngestAttempts = inngestAttempts;
   }
-  async execute(params) {
-    await params.emitter.emit("watch-v2", {
-      type: "workflow-start",
-      payload: { runId: params.runId }
-    });
-    const result = await super.execute(params);
-    await params.emitter.emit("watch-v2", {
-      type: "workflow-finish",
-      payload: { runId: params.runId }
-    });
-    return result;
-  }
-  async fmtReturnValue(executionSpan, emitter, stepResults, lastOutput, error) {
+  async fmtReturnValue(emitter, stepResults, lastOutput, error) {
     const base = {
       status: lastOutput.status,
       steps: stepResults
     };
     if (lastOutput.status === "success") {
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: lastOutput.output
-          }
-        },
-        eventTimestamp: Date.now()
-      });
       base.result = lastOutput.output;
     } else if (lastOutput.status === "failed") {
       base.error = error instanceof Error ? error?.stack ?? error.message : lastOutput?.error instanceof Error ? lastOutput.error.message : lastOutput.error ?? error ?? "Unknown error";
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: null,
-            error: base.error
-          }
-        },
-        eventTimestamp: Date.now()
-      });
     } else if (lastOutput.status === "suspended") {
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          workflowState: {
-            status: lastOutput.status,
-            steps: stepResults,
-            result: null,
-            error: null
-          }
-        },
-        eventTimestamp: Date.now()
-      });
       const suspendedStepIds = Object.entries(stepResults).flatMap(([stepId, stepResult]) => {
         if (stepResult?.status === "suspended") {
           const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
@@ -693,7 +752,6 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       });
       base.suspended = suspendedStepIds;
     }
-    executionSpan?.end();
     return base;
   }
   // async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
@@ -707,14 +765,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     stepResults,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     executionContext,
     writableStream,
     tracingContext
   }) {
     let { duration, fn } = entry;
     const sleepSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: AISpanType.WORKFLOW_SLEEP,
+      type: SpanType.WORKFLOW_SLEEP,
       name: `sleep: ${duration ? `${duration}ms` : "dynamic"}`,
       attributes: {
         durationMs: duration,
@@ -725,45 +783,53 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     if (fn) {
       const stepCallId = randomUUID();
       duration = await this.inngestStep.run(`workflow.${workflowId}.sleep.${entry.id}`, async () => {
-        return await fn({
-          runId,
-          workflowId,
-          mastra: this.mastra,
-          runtimeContext,
-          inputData: prevOutput,
-          state: executionContext.state,
-          setState: (state) => {
-            executionContext.state = state;
-          },
-          runCount: -1,
-          tracingContext: {
-            currentSpan: sleepSpan
-          },
-          getInitData: () => stepResults?.input,
-          getStepResult: getStepResult.bind(this, stepResults),
-          // TODO: this function shouldn't have suspend probably?
-          suspend: async (_suspendPayload) => {
-          },
-          bail: () => {
-          },
-          abort: () => {
-            abortController?.abort();
-          },
-          [EMITTER_SYMBOL]: emitter,
-          // TODO: add streamVNext support
-          [STREAM_FORMAT_SYMBOL]: executionContext.format,
-          engine: { step: this.inngestStep },
-          abortSignal: abortController?.signal,
-          writer: new ToolStream(
+        return await fn(
+          createDeprecationProxy(
             {
-              prefix: "workflow-step",
-              callId: stepCallId,
-              name: "sleep",
-              runId
+              runId,
+              workflowId,
+              mastra: this.mastra,
+              requestContext,
+              inputData: prevOutput,
+              state: executionContext.state,
+              setState: (state) => {
+                executionContext.state = state;
+              },
+              retryCount: -1,
+              tracingContext: {
+                currentSpan: sleepSpan
+              },
+              getInitData: () => stepResults?.input,
+              getStepResult: getStepResult.bind(this, stepResults),
+              // TODO: this function shouldn't have suspend probably?
+              suspend: async (_suspendPayload) => {
+              },
+              bail: () => {
+              },
+              abort: () => {
+                abortController?.abort();
+              },
+              [EMITTER_SYMBOL]: emitter,
+              [STREAM_FORMAT_SYMBOL]: executionContext.format,
+              engine: { step: this.inngestStep },
+              abortSignal: abortController?.signal,
+              writer: new ToolStream(
+                {
+                  prefix: "workflow-step",
+                  callId: stepCallId,
+                  name: "sleep",
+                  runId
+                },
+                writableStream
+              )
             },
-            writableStream
+            {
+              paramName: "runCount",
+              deprecationMessage: runCountDeprecationMessage,
+              logger: this.logger
+            }
           )
-        });
+        );
       });
       sleepSpan?.update({
         attributes: {
@@ -787,14 +853,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     stepResults,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     executionContext,
     writableStream,
     tracingContext
   }) {
     let { date, fn } = entry;
     const sleepUntilSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: AISpanType.WORKFLOW_SLEEP,
+      type: SpanType.WORKFLOW_SLEEP,
       name: `sleepUntil: ${date ? date.toISOString() : "dynamic"}`,
       attributes: {
         untilDate: date,
@@ -806,45 +872,53 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     if (fn) {
       date = await this.inngestStep.run(`workflow.${workflowId}.sleepUntil.${entry.id}`, async () => {
         const stepCallId = randomUUID();
-        return await fn({
-          runId,
-          workflowId,
-          mastra: this.mastra,
-          runtimeContext,
-          inputData: prevOutput,
-          state: executionContext.state,
-          setState: (state) => {
-            executionContext.state = state;
-          },
-          runCount: -1,
-          tracingContext: {
-            currentSpan: sleepUntilSpan
-          },
-          getInitData: () => stepResults?.input,
-          getStepResult: getStepResult.bind(this, stepResults),
-          // TODO: this function shouldn't have suspend probably?
-          suspend: async (_suspendPayload) => {
-          },
-          bail: () => {
-          },
-          abort: () => {
-            abortController?.abort();
-          },
-          [EMITTER_SYMBOL]: emitter,
-          [STREAM_FORMAT_SYMBOL]: executionContext.format,
-          // TODO: add streamVNext support
-          engine: { step: this.inngestStep },
-          abortSignal: abortController?.signal,
-          writer: new ToolStream(
+        return await fn(
+          createDeprecationProxy(
             {
-              prefix: "workflow-step",
-              callId: stepCallId,
-              name: "sleep",
-              runId
+              runId,
+              workflowId,
+              mastra: this.mastra,
+              requestContext,
+              inputData: prevOutput,
+              state: executionContext.state,
+              setState: (state) => {
+                executionContext.state = state;
+              },
+              retryCount: -1,
+              tracingContext: {
+                currentSpan: sleepUntilSpan
+              },
+              getInitData: () => stepResults?.input,
+              getStepResult: getStepResult.bind(this, stepResults),
+              // TODO: this function shouldn't have suspend probably?
+              suspend: async (_suspendPayload) => {
+              },
+              bail: () => {
+              },
+              abort: () => {
+                abortController?.abort();
+              },
+              [EMITTER_SYMBOL]: emitter,
+              [STREAM_FORMAT_SYMBOL]: executionContext.format,
+              engine: { step: this.inngestStep },
+              abortSignal: abortController?.signal,
+              writer: new ToolStream(
+                {
+                  prefix: "workflow-step",
+                  callId: stepCallId,
+                  name: "sleep",
+                  runId
+                },
+                writableStream
+              )
             },
-            writableStream
+            {
+              paramName: "runCount",
+              deprecationMessage: runCountDeprecationMessage,
+              logger: this.logger
+            }
           )
-        });
+        );
       });
       if (date && !(date instanceof Date)) {
         date = new Date(date);
@@ -868,16 +942,6 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       throw e;
     }
   }
-  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,
@@ -886,14 +950,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     prevOutput,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     tracingContext,
     writableStream,
     disableScorers
   }) {
-    const stepAISpan = tracingContext?.currentSpan?.createChildSpan({
+    const stepSpan = tracingContext?.currentSpan?.createChildSpan({
       name: `workflow step: '${step.id}'`,
-      type: AISpanType.WORKFLOW_STEP,
+      type: SpanType.WORKFLOW_STEP,
       input: prevOutput,
       attributes: {
         stepId: step.id
@@ -910,27 +974,6 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       async () => {
         const startedAt2 = Date.now();
         await emitter.emit("watch", {
-          type: "watch",
-          payload: {
-            currentStep: {
-              id: step.id,
-              status: "running"
-            },
-            workflowState: {
-              status: "running",
-              steps: {
-                ...stepResults,
-                [step.id]: {
-                  status: "running"
-                }
-              },
-              result: null,
-              error: null
-            }
-          },
-          eventTimestamp: Date.now()
-        });
-        await emitter.emit("watch-v2", {
           type: "workflow-step-start",
           payload: {
             id: step.id,
@@ -1006,23 +1049,6 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         async () => {
           if (result.status === "failed") {
             await emitter.emit("watch", {
-              type: "watch",
-              payload: {
-                currentStep: {
-                  id: step.id,
-                  status: "failed",
-                  error: result?.error
-                },
-                workflowState: {
-                  status: "running",
-                  steps: stepResults,
-                  result: null,
-                  error: null
-                }
-              },
-              eventTimestamp: Date.now()
-            });
-            await emitter.emit("watch-v2", {
               type: "workflow-step-result",
               payload: {
                 id: step.id,
@@ -1041,27 +1067,6 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               const suspendPath = [stepName, ...stepResult?.suspendPayload?.__workflow_meta?.path ?? []];
               executionContext.suspendedPaths[step.id] = executionContext.executionPath;
               await emitter.emit("watch", {
-                type: "watch",
-                payload: {
-                  currentStep: {
-                    id: step.id,
-                    status: "suspended",
-                    payload: stepResult.payload,
-                    suspendPayload: {
-                      ...stepResult?.suspendPayload,
-                      __workflow_meta: { runId, path: suspendPath }
-                    }
-                  },
-                  workflowState: {
-                    status: "running",
-                    steps: stepResults,
-                    result: null,
-                    error: null
-                  }
-                },
-                eventTimestamp: Date.now()
-              });
-              await emitter.emit("watch-v2", {
                 type: "workflow-step-suspended",
                 payload: {
                   id: step.id,
@@ -1080,23 +1085,6 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
                 }
               };
             }
-            await emitter.emit("watch", {
-              type: "watch",
-              payload: {
-                currentStep: {
-                  id: step.id,
-                  status: "suspended",
-                  payload: {}
-                },
-                workflowState: {
-                  status: "running",
-                  steps: stepResults,
-                  result: null,
-                  error: null
-                }
-              },
-              eventTimestamp: Date.now()
-            });
             return {
               executionContext,
               result: {
@@ -1106,23 +1094,6 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             };
           }
           await emitter.emit("watch", {
-            type: "watch",
-            payload: {
-              currentStep: {
-                id: step.id,
-                status: "success",
-                output: result?.result
-              },
-              workflowState: {
-                status: "running",
-                steps: stepResults,
-                result: null,
-                error: null
-              }
-            },
-            eventTimestamp: Date.now()
-          });
-          await emitter.emit("watch-v2", {
             type: "workflow-step-result",
             payload: {
               id: step.id,
@@ -1130,7 +1101,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               output: result?.result
             }
           });
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-finish",
             payload: {
               id: step.id,
@@ -1150,6 +1121,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
       };
     }
+    const stepCallId = randomUUID();
     let stepRes;
     try {
       stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
@@ -1163,8 +1135,16 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           const result = await step.execute({
             runId: executionContext.runId,
             mastra: this.mastra,
-            runtimeContext,
-            writableStream,
+            requestContext,
+            writer: new ToolStream(
+              {
+                prefix: "workflow-step",
+                callId: stepCallId,
+                name: step.id,
+                runId: executionContext.runId
+              },
+              writableStream
+            ),
             state: executionContext?.state ?? {},
             setState: (state) => {
               executionContext.state = state;
@@ -1172,14 +1152,20 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             inputData,
             resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
             tracingContext: {
-              currentSpan: stepAISpan
+              currentSpan: stepSpan
             },
             getInitData: () => stepResults?.input,
             getStepResult: getStepResult.bind(this, stepResults),
             suspend: async (suspendPayload, suspendOptions) => {
               executionContext.suspendedPaths[step.id] = executionContext.executionPath;
               if (suspendOptions?.resumeLabel) {
-                executionContext.resumeLabels[suspendOptions.resumeLabel] = step.id;
+                const resumeLabel = Array.isArray(suspendOptions.resumeLabel) ? suspendOptions.resumeLabel : [suspendOptions.resumeLabel];
+                for (const label of resumeLabel) {
+                  executionContext.resumeLabels[label] = {
+                    stepId: step.id,
+                    foreachIndex: executionContext.foreachIndex
+                  };
+                }
               }
               suspended = { payload: suspendPayload };
             },
@@ -1193,6 +1179,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               runId: stepResults[step.id]?.suspendPayload?.__workflow_meta?.runId
             },
             [EMITTER_SYMBOL]: emitter,
+            [STREAM_FORMAT_SYMBOL]: executionContext.format,
             engine: {
               step: this.inngestStep
             },
@@ -1220,7 +1207,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           };
           execResults = stepFailure;
           const fallbackErrorMessage = `Step ${step.id} failed`;
-          stepAISpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
+          stepSpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
           throw new RetryAfterError(execResults.error ?? fallbackErrorMessage, executionContext.retryConfig.delay, {
             cause: execResults
           });
@@ -1244,24 +1231,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             startedAt
           };
         }
-        await emitter.emit("watch", {
-          type: "watch",
-          payload: {
-            currentStep: {
-              id: step.id,
-              ...execResults
-            },
-            workflowState: {
-              status: "running",
-              steps: { ...stepResults, [step.id]: execResults },
-              result: null,
-              error: null
-            }
-          },
-          eventTimestamp: Date.now()
-        });
         if (execResults.status === "suspended") {
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-suspended",
             payload: {
               id: step.id,
@@ -1269,14 +1240,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             }
           });
         } else {
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-result",
             payload: {
               id: step.id,
               ...execResults
             }
           });
-          await emitter.emit("watch-v2", {
+          await emitter.emit("watch", {
             type: "workflow-step-finish",
             payload: {
               id: step.id,
@@ -1284,7 +1255,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             }
           });
         }
-        stepAISpan?.end({ output: execResults });
+        stepSpan?.end({ output: execResults });
         return { result: execResults, executionContext, stepResults };
       });
     } catch (e) {
@@ -1314,9 +1285,9 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             output: stepRes.result,
             workflowId: executionContext.workflowId,
             stepId: step.id,
-            runtimeContext,
+            requestContext,
             disableScorers,
-            tracingContext: { currentSpan: stepAISpan }
+            tracingContext: { currentSpan: stepSpan }
           });
         }
       });
@@ -1372,20 +1343,18 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     runId,
     entry,
     prevOutput,
-    prevStep,
     stepResults,
-    serializedStepGraph,
     resume,
     executionContext,
     emitter,
     abortController,
-    runtimeContext,
+    requestContext,
     writableStream,
     disableScorers,
     tracingContext
   }) {
     const conditionalSpan = tracingContext?.currentSpan?.createChildSpan({
-      type: AISpanType.WORKFLOW_CONDITIONAL,
+      type: SpanType.WORKFLOW_CONDITIONAL,
       name: `conditional: '${entry.conditions.length} conditions'`,
       input: prevOutput,
       attributes: {
@@ -1398,7 +1367,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       entry.conditions.map(
         (cond, index) => this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
           const evalSpan = conditionalSpan?.createChildSpan({
-            type: AISpanType.WORKFLOW_CONDITIONAL_EVAL,
+            type: SpanType.WORKFLOW_CONDITIONAL_EVAL,
             name: `condition: '${index}'`,
             input: prevOutput,
             attributes: {
@@ -1407,47 +1376,55 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             tracingPolicy: this.options?.tracingPolicy
           });
           try {
-            const result = await cond({
-              runId,
-              workflowId,
-              mastra: this.mastra,
-              runtimeContext,
-              runCount: -1,
-              inputData: prevOutput,
-              state: executionContext.state,
-              setState: (state) => {
-                executionContext.state = state;
-              },
-              tracingContext: {
-                currentSpan: evalSpan
-              },
-              getInitData: () => stepResults?.input,
-              getStepResult: getStepResult.bind(this, stepResults),
-              // TODO: this function shouldn't have suspend probably?
-              suspend: async (_suspendPayload) => {
-              },
-              bail: () => {
-              },
-              abort: () => {
-                abortController.abort();
-              },
-              [EMITTER_SYMBOL]: emitter,
-              [STREAM_FORMAT_SYMBOL]: executionContext.format,
-              // TODO: add streamVNext support
-              engine: {
-                step: this.inngestStep
-              },
-              abortSignal: abortController.signal,
-              writer: new ToolStream(
+            const result = await cond(
+              createDeprecationProxy(
                 {
-                  prefix: "workflow-step",
-                  callId: randomUUID(),
-                  name: "conditional",
-                  runId
+                  runId,
+                  workflowId,
+                  mastra: this.mastra,
+                  requestContext,
+                  retryCount: -1,
+                  inputData: prevOutput,
+                  state: executionContext.state,
+                  setState: (state) => {
+                    executionContext.state = state;
+                  },
+                  tracingContext: {
+                    currentSpan: evalSpan
+                  },
+                  getInitData: () => stepResults?.input,
+                  getStepResult: getStepResult.bind(this, stepResults),
+                  // TODO: this function shouldn't have suspend probably?
+                  suspend: async (_suspendPayload) => {
+                  },
+                  bail: () => {
+                  },
+                  abort: () => {
+                    abortController.abort();
+                  },
+                  [EMITTER_SYMBOL]: emitter,
+                  [STREAM_FORMAT_SYMBOL]: executionContext.format,
+                  engine: {
+                    step: this.inngestStep
+                  },
+                  abortSignal: abortController.signal,
+                  writer: new ToolStream(
+                    {
+                      prefix: "workflow-step",
+                      callId: randomUUID(),
+                      name: "conditional",
+                      runId
+                    },
+                    writableStream
+                  )
                 },
-                writableStream
+                {
+                  paramName: "runCount",
+                  deprecationMessage: runCountDeprecationMessage,
+                  logger: this.logger
+                }
               )
-            });
+            );
             evalSpan?.end({
               output: result,
               attributes: {
@@ -1475,13 +1452,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       }
     });
     const results = await Promise.all(
-      stepsToRun.map(
-        (step, index) => this.executeEntry({
-          workflowId,
-          runId,
-          entry: step,
-          serializedStepGraph,
-          prevStep,
+      stepsToRun.map(async (step, index) => {
+        const currStepResult = stepResults[step.step.id];
+        if (currStepResult && currStepResult.status === "success") {
+          return currStepResult;
+        }
+        const result = await this.executeStep({
+          step: step.step,
+          prevOutput,
           stepResults,
           resume,
           executionContext: {
@@ -1491,31 +1469,32 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             suspendedPaths: executionContext.suspendedPaths,
             resumeLabels: executionContext.resumeLabels,
             retryConfig: executionContext.retryConfig,
-            executionSpan: executionContext.executionSpan,
             state: executionContext.state
           },
           emitter,
           abortController,
-          runtimeContext,
+          requestContext,
           writableStream,
           disableScorers,
           tracingContext: {
             currentSpan: conditionalSpan
           }
-        })
-      )
+        });
+        stepResults[step.step.id] = result;
+        return result;
+      })
     );
-    const hasFailed = results.find((result) => result.result.status === "failed");
-    const hasSuspended = results.find((result) => result.result.status === "suspended");
+    const hasFailed = results.find((result) => result.status === "failed");
+    const hasSuspended = results.find((result) => result.status === "suspended");
     if (hasFailed) {
-      execResults = { status: "failed", error: hasFailed.result.error };
+      execResults = { status: "failed", error: hasFailed.error };
     } else if (hasSuspended) {
-      execResults = { status: "suspended", suspendPayload: hasSuspended.result.suspendPayload };
+      execResults = { status: "suspended", suspendPayload: hasSuspended.suspendPayload };
     } else {
       execResults = {
         status: "success",
         output: results.reduce((acc, result, index) => {
-          if (result.result.status === "success") {
+          if (result.status === "success") {
             acc[stepsToRun[index].step.id] = result.output;
           }
           return acc;