@mastra/inngest 0.0.0-vnext-inngest-20250508131921 → 0.0.0-vnext-20251104230439

package/dist/index.js

@@ -1,34 +1,53 @@
 import { randomUUID } from 'crypto';
+import { ReadableStream } from 'stream/web';
 import { subscribe } from '@inngest/realtime';
-import { RuntimeContext } from '@mastra/core/di';
-import { Run, NewWorkflow, cloneStep, createStep, DefaultExecutionEngine } from '@mastra/core/workflows/vNext';
+import { RequestContext } from '@mastra/core/di';
+import { wrapMastra, AISpanType } from '@mastra/core/observability';
+import { ChunkFrom, WorkflowRunOutput } from '@mastra/core/stream';
+import { ToolStream, Tool } from '@mastra/core/tools';
+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';
+import { z } from 'zod';
 
 // src/index.ts
-function serve({ mastra, inngest }) {
-  const wfs = mastra.vnext_getWorkflows();
-  const functions = Object.values(wfs).flatMap((wf) => {
-    if (wf instanceof InngestWorkflow) {
-      wf.__registerMastra(mastra);
-      return wf.getFunctions();
-    }
-    return [];
-  });
+function serve({
+  mastra,
+  inngest,
+  functions: userFunctions = [],
+  registerOptions
+}) {
+  const wfs = mastra.listWorkflows();
+  const workflowFunctions = Array.from(
+    new Set(
+      Object.values(wfs).flatMap((wf) => {
+        if (wf instanceof InngestWorkflow) {
+          wf.__registerMastra(mastra);
+          return wf.getFunctions();
+        }
+        return [];
+      })
+    )
+  );
   return serve$1({
+    ...registerOptions,
     client: inngest,
-    functions
+    functions: [...workflowFunctions, ...userFunctions]
   });
 }
 var InngestRun = class extends Run {
   inngest;
+  serializedStepGraph;
   #mastra;
   constructor(params, inngest) {
     super(params);
     this.inngest = inngest;
+    this.serializedStepGraph = params.serializedStepGraph;
     this.#mastra = params.mastra;
   }
   async getRuns(eventId) {
-    const response = await fetch(`${this.inngest.apiBaseUrl}/v1/events/${eventId}/runs`, {
+    const response = await fetch(`${this.inngest.apiBaseUrl ?? "https://api.inngest.com"}/v1/events/${eventId}/runs`, {
       headers: {
         Authorization: `Bearer ${process.env.INNGEST_SIGNING_KEY}`
       }
@@ -38,35 +57,98 @@ var InngestRun = class extends Run {
   }
   async getRunOutput(eventId) {
     let runs = await this.getRuns(eventId);
-    while (runs?.[0]?.status !== "Completed") {
+    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" || runs?.[0]?.status === "Cancelled") {
-        throw new Error(`Function run ${runs?.[0]?.status}`);
+      if (runs?.[0]?.status === "Failed") {
+        const snapshot = await storage?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId
+        });
+        return {
+          output: { result: { steps: snapshot?.context, status: "failed", error: runs?.[0]?.output?.message } }
+        };
+      }
+      if (runs?.[0]?.status === "Cancelled") {
+        const snapshot = await storage?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId
+        });
+        return { output: { result: { steps: snapshot?.context, status: "canceled" } } };
       }
     }
     return runs?.[0];
   }
-  async start({
-    inputData
+  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 storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (snapshot) {
+      await storage?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        snapshot: {
+          ...snapshot,
+          status: "canceled"
+        }
+      });
+    }
+  }
+  async start(params) {
+    return this._start(params);
+  }
+  async _start({
+    inputData,
+    initialState,
+    outputOptions,
+    tracingOptions,
+    format
   }) {
     await this.#mastra.getStorage()?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId,
+      resourceId: this.resourceId,
       snapshot: {
         runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
         value: {},
         context: {},
         activePaths: [],
         suspendedPaths: {},
-        timestamp: Date.now()
+        resumeLabels: {},
+        waitingPaths: {},
+        timestamp: Date.now(),
+        status: "running"
       }
     });
+    const inputDataToUse = await this._validateInput(inputData);
+    const initialStateToUse = await this._validateInitialState(initialState ?? {});
     const eventOutput = await this.inngest.send({
       name: `workflow.${this.workflowId}`,
       data: {
-        inputData,
-        runId: this.runId
+        inputData: inputDataToUse,
+        initialState: initialStateToUse,
+        runId: this.runId,
+        resourceId: this.resourceId,
+        outputOptions,
+        tracingOptions,
+        format
       }
     });
     const eventId = eventOutput.ids[0];
@@ -78,27 +160,45 @@ var InngestRun = class extends Run {
     if (result.status === "failed") {
       result.error = new Error(result.error);
     }
-    this.cleanup?.();
+    if (result.status !== "suspended") {
+      this.cleanup?.();
+    }
     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 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
     });
+    const suspendedStep = this.workflowSteps[steps?.[0] ?? ""];
+    const resumeDataToUse = await this._validateResumeData(params.resumeData, suspendedStep);
     const eventOutput = await this.inngest.send({
       name: `workflow.${this.workflowId}`,
       data: {
-        inputData: params.resumeData,
+        inputData: resumeDataToUse,
+        initialState: snapshot?.value ?? {},
         runId: this.runId,
+        workflowId: this.workflowId,
         stepResults: snapshot?.context,
         resume: {
           steps,
           stepResults: snapshot?.context,
-          resumePayload: params.resumeData,
+          resumePayload: resumeDataToUse,
           // @ts-ignore
           resumePath: snapshot?.suspendedPaths?.[steps?.[0]]
         }
@@ -116,6 +216,7 @@ var InngestRun = class extends Run {
     return result;
   }
   watch(cb) {
+    let active = true;
     const streamPromise = subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
@@ -123,40 +224,175 @@ var InngestRun = class extends Run {
         app: this.inngest
       },
       (message) => {
-        cb(message.data);
+        if (active) {
+          cb(message.data);
+        }
       }
     );
     return () => {
-      streamPromise.then((stream) => {
-        stream.cancel();
+      active = false;
+      streamPromise.then(async (stream) => {
+        return stream.cancel();
       }).catch((err) => {
         console.error(err);
       });
     };
   }
+  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 {
+      }
+    });
+    this.closeStreamAction = async () => {
+      await writer.write({
+        type: "finish",
+        // @ts-ignore
+        payload: { runId: this.runId }
+      });
+      unwatch();
+      try {
+        await writer.close();
+      } catch (err) {
+        console.error("Error closing stream:", err);
+      } finally {
+        writer.releaseLock();
+      }
+    };
+    this.executionResults = this._start({ inputData, requestContext, format: "legacy" }).then((result) => {
+      if (result.status !== "suspended") {
+        this.closeStreamAction?.().catch(() => {
+        });
+      }
+      return result;
+    });
+    return {
+      stream: readable,
+      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 NewWorkflow {
+var InngestWorkflow = class _InngestWorkflow extends Workflow {
   #mastra;
   inngest;
   function;
+  flowControlConfig;
   constructor(params, inngest) {
-    super(params);
+    const { concurrency, rateLimit, throttle, debounce, priority, ...workflowParams } = params;
+    super(workflowParams);
+    const flowControlEntries = Object.entries({ concurrency, rateLimit, throttle, debounce, priority }).filter(
+      ([_, value]) => value !== void 0
+    );
+    this.flowControlConfig = flowControlEntries.length > 0 ? Object.fromEntries(flowControlEntries) : void 0;
     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();
     if (!storage) {
       this.logger.debug("Cannot get workflow runs. Mastra engine is not initialized");
-      return null;
+      return this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null;
     }
     const run = await storage.getWorkflowRunById({ runId, workflowName: this.id });
     return run ?? (this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null);
@@ -179,21 +415,51 @@ var InngestWorkflow = class _InngestWorkflow extends NewWorkflow {
       }
     }
   }
-  createRun(options) {
+  async createRun(options) {
     const runIdToUse = options?.runId || randomUUID();
     const run = this.runs.get(runIdToUse) ?? new InngestRun(
       {
         workflowId: this.id,
         runId: runIdToUse,
+        resourceId: options?.resourceId,
         executionEngine: this.executionEngine,
         executionGraph: this.executionGraph,
+        serializedStepGraph: this.serializedStepGraph,
         mastra: this.#mastra,
         retryConfig: this.retryConfig,
-        cleanup: () => this.runs.delete(runIdToUse)
+        cleanup: () => this.runs.delete(runIdToUse),
+        workflowSteps: this.steps
       },
       this.inngest
     );
     this.runs.set(runIdToUse, run);
+    const shouldPersistSnapshot = this.options.shouldPersistSnapshot({
+      workflowStatus: run.workflowRunStatus,
+      stepResults: {}
+    });
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, false);
+    if (!workflowSnapshotInStorage && shouldPersistSnapshot) {
+      await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+        workflowName: this.id,
+        runId: runIdToUse,
+        resourceId: options?.resourceId,
+        snapshot: {
+          runId: runIdToUse,
+          status: "pending",
+          value: {},
+          context: {},
+          activePaths: [],
+          waitingPaths: {},
+          serializedStepGraph: this.serializedStepGraph,
+          suspendedPaths: {},
+          resumeLabels: {},
+          result: void 0,
+          error: void 0,
+          // @ts-ignore
+          timestamp: Date.now()
+        }
+      });
+    }
     return run;
   }
   getFunction() {
@@ -201,11 +467,17 @@ var InngestWorkflow = class _InngestWorkflow extends NewWorkflow {
       return this.function;
     }
     this.function = this.inngest.createFunction(
-      // @ts-ignore
-      { id: `workflow.${this.id}`, retries: this.retryConfig?.attempts ?? 0 },
+      {
+        id: `workflow.${this.id}`,
+        // @ts-ignore
+        retries: this.retryConfig?.attempts ?? 0,
+        cancelOn: [{ event: `cancel.workflow.${this.id}` }],
+        // Spread flow control configuration
+        ...this.flowControlConfig
+      },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
-        let { inputData, runId, resume } = 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();
@@ -219,25 +491,52 @@ var InngestWorkflow = class _InngestWorkflow extends NewWorkflow {
             try {
               await publish({
                 channel: `workflow:${this.id}:${runId}`,
-                topic: "watch",
+                topic: event2,
                 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);
+        const engine = new InngestExecutionEngine(this.#mastra, step, attempt, this.options);
         const result = await engine.execute({
           workflowId: this.id,
           runId,
+          resourceId,
           graph: this.executionGraph,
+          serializedStepGraph: this.serializedStepGraph,
           input: inputData,
+          initialState,
           emitter,
           retryConfig: this.retryConfig,
-          runtimeContext: new RuntimeContext(),
+          requestContext: new RequestContext(),
           // TODO
-          resume
+          resume,
+          format,
+          abortController: new AbortController(),
+          // currentSpan: undefined, // TODO: Pass actual parent AI 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") {
+            throw new NonRetriableError(`Workflow failed`, {
+              cause: result
+            });
+          }
+          return result;
         });
         return { result, runId };
       }
@@ -261,118 +560,403 @@ var InngestWorkflow = class _InngestWorkflow extends NewWorkflow {
     return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
   }
 };
-function cloneWorkflow(workflow, opts) {
-  const wf = new InngestWorkflow(
-    {
-      id: opts.id,
-      inputSchema: workflow.inputSchema,
-      outputSchema: workflow.outputSchema,
-      steps: workflow.stepDefs,
-      mastra: workflow.mastra
-    },
-    workflow.inngest
-  );
-  wf.setStepFlow(workflow.stepGraph);
-  wf.commit();
-  return wf;
+function isAgent(params) {
+  return params?.component === "AGENT";
+}
+function isTool(params) {
+  return params instanceof Tool;
+}
+function createStep(params, agentOptions) {
+  if (isAgent(params)) {
+    return {
+      id: params.name,
+      description: params.getDescription(),
+      // @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,
+        [STREAM_FORMAT_SYMBOL]: streamFormat,
+        requestContext,
+        tracingContext,
+        abortSignal,
+        abort,
+        writer
+      }) => {
+        let streamPromise = {};
+        streamPromise.promise = new Promise((resolve, reject) => {
+          streamPromise.resolve = resolve;
+          streamPromise.reject = reject;
+        });
+        const toolData = {
+          name: params.name,
+          args: inputData
+        };
+        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
+          });
+          stream = fullStream;
+        } else {
+          const modelOutput = await params.stream(inputData.prompt, {
+            ...agentOptions ?? {},
+            requestContext,
+            tracingContext,
+            onFinish: (result) => {
+              streamPromise.resolve(result.text);
+              void agentOptions?.onFinish?.(result);
+            },
+            abortSignal
+          });
+          stream = modelOutput.fullStream;
+        }
+        if (streamFormat === "legacy") {
+          await emitter.emit("watch", {
+            type: "tool-call-streaming-start",
+            ...toolData ?? {}
+          });
+          for await (const chunk of stream) {
+            if (chunk.type === "text-delta") {
+              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();
+        }
+        return {
+          text: await streamPromise.promise
+        };
+      },
+      component: params.component
+    };
+  }
+  if (isTool(params)) {
+    if (!params.inputSchema || !params.outputSchema) {
+      throw new Error("Tool must have input and output schemas defined");
+    }
+    return {
+      // TODO: tool probably should have strong id type
+      // @ts-ignore
+      id: params.id,
+      description: params.description,
+      inputSchema: params.inputSchema,
+      outputSchema: params.outputSchema,
+      execute: async ({ inputData, mastra, requestContext, tracingContext, suspend, resumeData }) => {
+        return params.execute({
+          context: inputData,
+          mastra: wrapMastra(mastra, tracingContext),
+          requestContext,
+          tracingContext,
+          suspend,
+          resumeData
+        });
+      },
+      component: "TOOL"
+    };
+  }
+  return {
+    id: params.id,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    execute: params.execute
+  };
 }
 function init(inngest) {
   return {
     createWorkflow(params) {
-      return new InngestWorkflow(params, inngest);
+      return new InngestWorkflow(
+        params,
+        inngest
+      );
     },
     createStep,
-    cloneStep,
-    cloneWorkflow
+    cloneStep(step, opts) {
+      return {
+        id: opts.id,
+        description: step.description,
+        inputSchema: step.inputSchema,
+        outputSchema: step.outputSchema,
+        resumeSchema: step.resumeSchema,
+        suspendSchema: step.suspendSchema,
+        stateSchema: step.stateSchema,
+        execute: step.execute,
+        component: step.component
+      };
+    },
+    cloneWorkflow(workflow, opts) {
+      const wf = new Workflow({
+        id: opts.id,
+        inputSchema: workflow.inputSchema,
+        outputSchema: workflow.outputSchema,
+        steps: workflow.stepDefs,
+        mastra: workflow.mastra
+      });
+      wf.setStepFlow(workflow.stepGraph);
+      wf.commit();
+      return wf;
+    }
   };
 }
 var InngestExecutionEngine = class extends DefaultExecutionEngine {
   inngestStep;
   inngestAttempts;
-  constructor(mastra, inngestStep, inngestAttempts = 0) {
-    super({ mastra });
+  constructor(mastra, inngestStep, inngestAttempts = 0, options) {
+    super({ mastra, options });
     this.inngestStep = inngestStep;
     this.inngestAttempts = inngestAttempts;
   }
-  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?.payload?.__workflow_meta?.path;
+          const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
           return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
         }
         return [];
       });
       base.suspended = suspendedStepIds;
     }
-    executionSpan?.end();
     return base;
   }
-  async superExecuteStep({
+  // async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
+  //   await this.inngestStep.sleep(id, duration);
+  // }
+  async executeSleep({
     workflowId,
     runId,
-    step,
+    entry,
+    prevOutput,
     stepResults,
+    emitter,
+    abortController,
+    requestContext,
     executionContext,
-    resume,
+    writableStream,
+    tracingContext
+  }) {
+    let { duration, fn } = entry;
+    const sleepSpan = tracingContext?.currentSpan?.createChildSpan({
+      type: AISpanType.WORKFLOW_SLEEP,
+      name: `sleep: ${duration ? `${duration}ms` : "dynamic"}`,
+      attributes: {
+        durationMs: duration,
+        sleepType: fn ? "dynamic" : "fixed"
+      },
+      tracingPolicy: this.options?.tracingPolicy
+    });
+    if (fn) {
+      const stepCallId = randomUUID();
+      duration = await this.inngestStep.run(`workflow.${workflowId}.sleep.${entry.id}`, async () => {
+        return await fn(
+          createDeprecationProxy(
+            {
+              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
+              )
+            },
+            {
+              paramName: "runCount",
+              deprecationMessage: runCountDeprecationMessage,
+              logger: this.logger
+            }
+          )
+        );
+      });
+      sleepSpan?.update({
+        attributes: {
+          durationMs: duration
+        }
+      });
+    }
+    try {
+      await this.inngestStep.sleep(entry.id, !duration || duration < 0 ? 0 : duration);
+      sleepSpan?.end();
+    } catch (e) {
+      sleepSpan?.error({ error: e });
+      throw e;
+    }
+  }
+  async executeSleepUntil({
+    workflowId,
+    runId,
+    entry,
     prevOutput,
+    stepResults,
     emitter,
-    runtimeContext
+    abortController,
+    requestContext,
+    executionContext,
+    writableStream,
+    tracingContext
   }) {
-    return super.executeStep({
-      workflowId,
-      runId,
-      step,
-      stepResults,
-      executionContext,
-      resume,
-      prevOutput,
-      emitter,
-      runtimeContext
+    let { date, fn } = entry;
+    const sleepUntilSpan = tracingContext?.currentSpan?.createChildSpan({
+      type: AISpanType.WORKFLOW_SLEEP,
+      name: `sleepUntil: ${date ? date.toISOString() : "dynamic"}`,
+      attributes: {
+        untilDate: date,
+        durationMs: date ? Math.max(0, date.getTime() - Date.now()) : void 0,
+        sleepType: fn ? "dynamic" : "fixed"
+      },
+      tracingPolicy: this.options?.tracingPolicy
     });
+    if (fn) {
+      date = await this.inngestStep.run(`workflow.${workflowId}.sleepUntil.${entry.id}`, async () => {
+        const stepCallId = randomUUID();
+        return await fn(
+          createDeprecationProxy(
+            {
+              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
+              )
+            },
+            {
+              paramName: "runCount",
+              deprecationMessage: runCountDeprecationMessage,
+              logger: this.logger
+            }
+          )
+        );
+      });
+      if (date && !(date instanceof Date)) {
+        date = new Date(date);
+      }
+      const time = !date ? 0 : date.getTime() - Date.now();
+      sleepUntilSpan?.update({
+        attributes: {
+          durationMs: Math.max(0, time)
+        }
+      });
+    }
+    if (!(date instanceof Date)) {
+      sleepUntilSpan?.end();
+      return;
+    }
+    try {
+      await this.inngestStep.sleepUntil(entry.id, date);
+      sleepUntilSpan?.end();
+    } catch (e) {
+      sleepUntilSpan?.error({ error: e });
+      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,
@@ -381,91 +965,113 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     resume,
     prevOutput,
     emitter,
-    runtimeContext
+    abortController,
+    requestContext,
+    tracingContext,
+    writableStream,
+    disableScorers
   }) {
-    await this.inngestStep.run(
+    const stepAISpan = tracingContext?.currentSpan?.createChildSpan({
+      name: `workflow step: '${step.id}'`,
+      type: AISpanType.WORKFLOW_STEP,
+      input: prevOutput,
+      attributes: {
+        stepId: step.id
+      },
+      tracingPolicy: this.options?.tracingPolicy
+    });
+    const { inputData, validationError } = await validateStepInput({
+      prevOutput,
+      step,
+      validateInputs: this.options?.validateInputs ?? false
+    });
+    const startedAt = 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",
+          type: "workflow-step-start",
           payload: {
-            currentStep: {
-              id: step.id,
-              status: "running"
-            },
-            workflowState: {
-              status: "running",
-              steps: {
-                ...stepResults,
-                [step.id]: {
-                  status: "running"
-                }
-              },
-              result: null,
-              error: null
-            }
-          },
-          eventTimestamp: Date.now()
+            id: step.id,
+            status: "running",
+            payload: inputData,
+            startedAt: startedAt2
+          }
         });
+        return startedAt2;
       }
     );
     if (step instanceof InngestWorkflow) {
       const isResume = !!resume?.steps?.length;
       let result;
       let runId;
-      if (isResume) {
-        runId = stepResults[resume?.steps?.[0]]?.payload?.__workflow_meta?.runId ?? randomUUID();
-        const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
-          workflowName: step.id,
-          runId
-        });
-        const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
-          function: step.getFunction(),
-          data: {
-            inputData: prevOutput,
-            runId,
-            resume: {
+      try {
+        if (isResume) {
+          runId = stepResults[resume?.steps?.[0]]?.suspendPayload?.__workflow_meta?.runId ?? randomUUID();
+          const snapshot = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
+            workflowName: step.id,
+            runId
+          });
+          const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
+            function: step.getFunction(),
+            data: {
+              inputData,
+              initialState: executionContext.state ?? snapshot?.value ?? {},
               runId,
-              steps: resume.steps.slice(1),
-              stepResults: snapshot?.context,
-              resumePayload: resume.resumePayload,
-              // @ts-ignore
-              resumePath: snapshot?.suspendedPaths?.[resume.steps?.[1]]
+              resume: {
+                runId,
+                steps: resume.steps.slice(1),
+                stepResults: snapshot?.context,
+                resumePayload: resume.resumePayload,
+                // @ts-ignore
+                resumePath: snapshot?.suspendedPaths?.[resume.steps?.[1]]
+              },
+              outputOptions: { includeState: true }
             }
-          }
-        });
-        result = invokeResp.result;
-        runId = invokeResp.runId;
-      } else {
-        const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
-          function: step.getFunction(),
-          data: {
-            inputData: prevOutput
-          }
-        });
-        result = invokeResp.result;
-        runId = invokeResp.runId;
+          });
+          result = invokeResp.result;
+          runId = invokeResp.runId;
+          executionContext.state = invokeResp.result.state;
+        } else {
+          const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
+            function: step.getFunction(),
+            data: {
+              inputData,
+              initialState: executionContext.state ?? {},
+              outputOptions: { includeState: true }
+            }
+          });
+          result = invokeResp.result;
+          runId = invokeResp.runId;
+          executionContext.state = invokeResp.result.state;
+        }
+      } catch (e) {
+        const errorCause = e?.cause;
+        if (errorCause && typeof errorCause === "object") {
+          result = errorCause;
+          runId = errorCause.runId || randomUUID();
+        } else {
+          runId = randomUUID();
+          result = {
+            status: "failed",
+            error: e instanceof Error ? e : new Error(String(e)),
+            steps: {},
+            input: inputData
+          };
+        }
       }
       const res = await this.inngestStep.run(
         `workflow.${executionContext.workflowId}.step.${step.id}.nestedwf-results`,
         async () => {
           if (result.status === "failed") {
             await emitter.emit("watch", {
-              type: "watch",
+              type: "workflow-step-result",
               payload: {
-                currentStep: {
-                  id: step.id,
-                  status: "failed",
-                  error: result?.error
-                },
-                workflowState: {
-                  status: "running",
-                  steps: stepResults,
-                  result: null,
-                  error: null
-                }
-              },
-              eventTimestamp: Date.now()
+                id: step.id,
+                status: "failed",
+                error: result?.error,
+                payload: prevOutput
+              }
             });
             return { executionContext, result: { status: "failed", error: result?.error } };
           } else if (result.status === "suspended") {
@@ -474,50 +1080,27 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               return stepRes2?.status === "suspended";
             });
             for (const [stepName, stepResult] of suspendedSteps) {
-              const suspendPath = [stepName, ...stepResult?.payload?.__workflow_meta?.path ?? []];
+              const suspendPath = [stepName, ...stepResult?.suspendPayload?.__workflow_meta?.path ?? []];
               executionContext.suspendedPaths[step.id] = executionContext.executionPath;
               await emitter.emit("watch", {
-                type: "watch",
+                type: "workflow-step-suspended",
                 payload: {
-                  currentStep: {
-                    id: step.id,
-                    status: "suspended",
-                    payload: { ...stepResult?.payload, __workflow_meta: { runId, path: suspendPath } }
-                  },
-                  workflowState: {
-                    status: "running",
-                    steps: stepResults,
-                    result: null,
-                    error: null
-                  }
-                },
-                eventTimestamp: Date.now()
+                  id: step.id,
+                  status: "suspended"
+                }
               });
               return {
                 executionContext,
                 result: {
                   status: "suspended",
-                  payload: { ...stepResult?.payload, __workflow_meta: { runId, path: suspendPath } }
+                  payload: stepResult.payload,
+                  suspendPayload: {
+                    ...stepResult?.suspendPayload,
+                    __workflow_meta: { runId, path: suspendPath }
+                  }
                 }
               };
             }
-            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: {
@@ -527,110 +1110,243 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             };
           }
           await emitter.emit("watch", {
-            type: "watch",
+            type: "workflow-step-result",
             payload: {
-              currentStep: {
-                id: step.id,
-                status: "success",
-                output: result?.result
-              },
-              workflowState: {
-                status: "running",
-                steps: stepResults,
-                result: null,
-                error: null
-              }
-            },
-            eventTimestamp: Date.now()
+              id: step.id,
+              status: "success",
+              output: result?.result
+            }
+          });
+          await emitter.emit("watch", {
+            type: "workflow-step-finish",
+            payload: {
+              id: step.id,
+              metadata: {}
+            }
           });
           return { executionContext, result: { status: "success", output: result?.result } };
         }
       );
       Object.assign(executionContext, res.executionContext);
-      return res.result;
+      return {
+        ...res.result,
+        startedAt,
+        endedAt: Date.now(),
+        payload: inputData,
+        resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
+        resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+      };
     }
-    const stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
-      let execResults;
-      let suspended;
-      try {
-        const result = await step.execute({
-          mastra: this.mastra,
-          runtimeContext,
-          inputData: prevOutput,
-          resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
-          getInitData: () => stepResults?.input,
-          getStepResult: (step2) => {
-            const result2 = stepResults[step2.id];
-            if (result2?.status === "success") {
-              return result2.output;
+    const stepCallId = randomUUID();
+    let stepRes;
+    try {
+      stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
+        let execResults;
+        let suspended;
+        let bailed;
+        try {
+          if (validationError) {
+            throw validationError;
+          }
+          const result = await step.execute({
+            runId: executionContext.runId,
+            mastra: this.mastra,
+            requestContext,
+            writer: new ToolStream(
+              {
+                prefix: "workflow-step",
+                callId: stepCallId,
+                name: step.id,
+                runId: executionContext.runId
+              },
+              writableStream
+            ),
+            state: executionContext?.state ?? {},
+            setState: (state) => {
+              executionContext.state = state;
+            },
+            inputData,
+            resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : void 0,
+            tracingContext: {
+              currentSpan: stepAISpan
+            },
+            getInitData: () => stepResults?.input,
+            getStepResult: getStepResult.bind(this, stepResults),
+            suspend: async (suspendPayload, suspendOptions) => {
+              executionContext.suspendedPaths[step.id] = executionContext.executionPath;
+              if (suspendOptions?.resumeLabel) {
+                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 };
+            },
+            bail: (result2) => {
+              bailed = { payload: result2 };
+            },
+            resume: {
+              steps: resume?.steps?.slice(1) || [],
+              resumePayload: resume?.resumePayload,
+              // @ts-ignore
+              runId: stepResults[step.id]?.suspendPayload?.__workflow_meta?.runId
+            },
+            [EMITTER_SYMBOL]: emitter,
+            [STREAM_FORMAT_SYMBOL]: executionContext.format,
+            engine: {
+              step: this.inngestStep
+            },
+            abortSignal: abortController.signal
+          });
+          const endedAt = Date.now();
+          execResults = {
+            status: "success",
+            output: result,
+            startedAt,
+            endedAt,
+            payload: inputData,
+            resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
+            resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
+          };
+        } catch (e) {
+          const stepFailure = {
+            status: "failed",
+            payload: inputData,
+            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 = stepFailure;
+          const fallbackErrorMessage = `Step ${step.id} failed`;
+          stepAISpan?.error({ error: new Error(execResults.error ?? fallbackErrorMessage) });
+          throw new RetryAfterError(execResults.error ?? fallbackErrorMessage, executionContext.retryConfig.delay, {
+            cause: execResults
+          });
+        }
+        if (suspended) {
+          execResults = {
+            status: "suspended",
+            suspendPayload: suspended.payload,
+            payload: inputData,
+            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: inputData,
+            endedAt: Date.now(),
+            startedAt
+          };
+        }
+        if (execResults.status === "suspended") {
+          await emitter.emit("watch", {
+            type: "workflow-step-suspended",
+            payload: {
+              id: step.id,
+              ...execResults
             }
-            return null;
-          },
-          suspend: async (suspendPayload) => {
-            executionContext.suspendedPaths[step.id] = executionContext.executionPath;
-            suspended = { payload: suspendPayload };
-          },
-          resume: {
-            steps: resume?.steps?.slice(1) || [],
-            resumePayload: resume?.resumePayload,
-            // @ts-ignore
-            runId: stepResults[step.id]?.payload?.__workflow_meta?.runId
-          },
-          emitter
-        });
-        execResults = { status: "success", output: result };
-      } catch (e) {
-        execResults = { status: "failed", error: e instanceof Error ? e.message : String(e) };
-      }
-      if (suspended) {
-        execResults = { status: "suspended", payload: suspended.payload };
-      }
-      if (execResults.status === "failed") {
-        if (executionContext.retryConfig.attempts > 0 && this.inngestAttempts < executionContext.retryConfig.attempts) {
-          throw execResults.error;
+          });
+        } else {
+          await emitter.emit("watch", {
+            type: "workflow-step-result",
+            payload: {
+              id: step.id,
+              ...execResults
+            }
+          });
+          await emitter.emit("watch", {
+            type: "workflow-step-finish",
+            payload: {
+              id: step.id,
+              metadata: {}
+            }
+          });
         }
-      }
-      await emitter.emit("watch", {
-        type: "watch",
-        payload: {
-          currentStep: {
-            id: step.id,
-            status: execResults.status,
-            output: execResults.output
-          },
-          workflowState: {
-            status: "running",
-            steps: stepResults,
-            result: null,
-            error: null
-          }
-        },
-        eventTimestamp: Date.now()
+        stepAISpan?.end({ output: execResults });
+        return { result: execResults, executionContext, stepResults };
       });
-      return { result: execResults, executionContext, stepResults };
-    });
+    } catch (e) {
+      const stepFailure = e instanceof Error ? e?.cause : {
+        status: "failed",
+        error: e instanceof Error ? e.message : String(e),
+        payload: inputData,
+        startedAt,
+        endedAt: Date.now()
+      };
+      stepRes = {
+        result: stepFailure,
+        executionContext,
+        stepResults: {
+          ...stepResults,
+          [step.id]: stepFailure
+        }
+      };
+    }
+    if (disableScorers !== false && stepRes.result.status === "success") {
+      await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}.score`, async () => {
+        if (step.scorers) {
+          await this.runScorers({
+            scorers: step.scorers,
+            runId: executionContext.runId,
+            input: inputData,
+            output: stepRes.result,
+            workflowId: executionContext.workflowId,
+            stepId: step.id,
+            requestContext,
+            disableScorers,
+            tracingContext: { currentSpan: stepAISpan }
+          });
+        }
+      });
+    }
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
     Object.assign(stepResults, stepRes.stepResults);
+    executionContext.state = stepRes.executionContext.state;
     return stepRes.result;
   }
   async persistStepUpdate({
     workflowId,
     runId,
     stepResults,
-    executionContext
+    resourceId,
+    executionContext,
+    serializedStepGraph,
+    workflowStatus,
+    result,
+    error
   }) {
     await this.inngestStep.run(
       `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
       async () => {
+        const shouldPersistSnapshot = this.options.shouldPersistSnapshot({ stepResults, workflowStatus });
+        if (!shouldPersistSnapshot) {
+          return;
+        }
         await this.mastra?.getStorage()?.persistWorkflowSnapshot({
           workflowName: workflowId,
           runId,
+          resourceId,
           snapshot: {
             runId,
-            value: {},
+            value: executionContext.state,
             context: stepResults,
             activePaths: [],
             suspendedPaths: executionContext.suspendedPaths,
+            resumeLabels: executionContext.resumeLabels,
+            waitingPaths: {},
+            serializedStepGraph,
+            status: workflowStatus,
+            result,
+            error,
             // @ts-ignore
             timestamp: Date.now()
           }
@@ -643,53 +1359,123 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     runId,
     entry,
     prevOutput,
-    prevStep,
     stepResults,
     resume,
     executionContext,
     emitter,
-    runtimeContext
+    abortController,
+    requestContext,
+    writableStream,
+    disableScorers,
+    tracingContext
   }) {
+    const conditionalSpan = tracingContext?.currentSpan?.createChildSpan({
+      type: AISpanType.WORKFLOW_CONDITIONAL,
+      name: `conditional: '${entry.conditions.length} conditions'`,
+      input: prevOutput,
+      attributes: {
+        conditionCount: entry.conditions.length
+      },
+      tracingPolicy: this.options?.tracingPolicy
+    });
     let execResults;
     const truthyIndexes = (await Promise.all(
       entry.conditions.map(
         (cond, index) => this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
+          const evalSpan = conditionalSpan?.createChildSpan({
+            type: AISpanType.WORKFLOW_CONDITIONAL_EVAL,
+            name: `condition: '${index}'`,
+            input: prevOutput,
+            attributes: {
+              conditionIndex: index
+            },
+            tracingPolicy: this.options?.tracingPolicy
+          });
           try {
-            const result = await cond({
-              mastra: this.mastra,
-              runtimeContext,
-              inputData: prevOutput,
-              getInitData: () => stepResults?.input,
-              getStepResult: (step) => {
-                if (!step?.id) {
-                  return null;
-                }
-                const result2 = stepResults[step.id];
-                if (result2?.status === "success") {
-                  return result2.output;
+            const result = await cond(
+              createDeprecationProxy(
+                {
+                  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
+                  )
+                },
+                {
+                  paramName: "runCount",
+                  deprecationMessage: runCountDeprecationMessage,
+                  logger: this.logger
                 }
-                return null;
-              },
-              // TODO: this function shouldn't have suspend probably?
-              suspend: async (_suspendPayload) => {
-              },
-              emitter
+              )
+            );
+            evalSpan?.end({
+              output: result,
+              attributes: {
+                result: !!result
+              }
             });
             return result ? index : null;
           } catch (e) {
+            evalSpan?.error({
+              error: e instanceof Error ? e : new Error(String(e)),
+              attributes: {
+                result: false
+              }
+            });
             return null;
           }
         })
       )
     )).filter((index) => index !== null);
     const stepsToRun = entry.steps.filter((_, index) => truthyIndexes.includes(index));
+    conditionalSpan?.update({
+      attributes: {
+        truthyIndexes,
+        selectedSteps: stepsToRun.map((s) => s.type === "step" ? s.step.id : `control-${s.type}`)
+      }
+    });
     const results = await Promise.all(
-      stepsToRun.map(
-        (step, index) => this.executeEntry({
-          workflowId,
-          runId,
-          entry: step,
-          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: {
@@ -697,20 +1483,29 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             runId,
             executionPath: [...executionContext.executionPath, index],
             suspendedPaths: executionContext.suspendedPaths,
+            resumeLabels: executionContext.resumeLabels,
             retryConfig: executionContext.retryConfig,
-            executionSpan: executionContext.executionSpan
+            state: executionContext.state
           },
           emitter,
-          runtimeContext
-        })
-      )
+          abortController,
+          requestContext,
+          writableStream,
+          disableScorers,
+          tracingContext: {
+            currentSpan: conditionalSpan
+          }
+        });
+        stepResults[step.step.id] = result;
+        return result;
+      })
     );
     const hasFailed = results.find((result) => result.status === "failed");
     const hasSuspended = results.find((result) => result.status === "suspended");
     if (hasFailed) {
       execResults = { status: "failed", error: hasFailed.error };
     } else if (hasSuspended) {
-      execResults = { status: "suspended", payload: hasSuspended.payload };
+      execResults = { status: "suspended", suspendPayload: hasSuspended.suspendPayload };
     } else {
       execResults = {
         status: "success",
@@ -722,8 +1517,19 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         }, {})
       };
     }
+    if (execResults.status === "failed") {
+      conditionalSpan?.error({
+        error: new Error(execResults.error)
+      });
+    } else {
+      conditionalSpan?.end({
+        output: execResults.output || execResults
+      });
+    }
     return execResults;
   }
 };
 
-export { InngestExecutionEngine, InngestRun, InngestWorkflow, init, serve };
+export { InngestExecutionEngine, InngestRun, InngestWorkflow, createStep, init, serve };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map