@mastra/inngest 0.0.0-support-d1-client-20250701191943 → 0.0.0-suspendRuntimeContextTypeFix-20250930142630

package/dist/index.js

@@ -1,16 +1,22 @@
 import { randomUUID } from 'crypto';
 import { subscribe } from '@inngest/realtime';
+import { wrapMastra, AISpanType } from '@mastra/core/ai-tracing';
 import { RuntimeContext } from '@mastra/core/di';
-import { Tool } from '@mastra/core/tools';
-import { Run, Workflow, DefaultExecutionEngine } from '@mastra/core/workflows';
-import { EMITTER_SYMBOL } from '@mastra/core/workflows/_constants';
+import { ToolStream, Tool } from '@mastra/core/tools';
+import { Run, Workflow, DefaultExecutionEngine, getStepResult, validateStepInput } from '@mastra/core/workflows';
+import { EMITTER_SYMBOL, STREAM_FORMAT_SYMBOL } from '@mastra/core/workflows/_constants';
 import { serve as serve$1 } from 'inngest/hono';
 import { z } from 'zod';
 
 // src/index.ts
-function serve({ mastra, inngest }) {
+function serve({
+  mastra,
+  inngest,
+  functions: userFunctions = [],
+  registerOptions
+}) {
   const wfs = mastra.getWorkflows();
-  const functions = Array.from(
+  const workflowFunctions = Array.from(
     new Set(
       Object.values(wfs).flatMap((wf) => {
         if (wf instanceof InngestWorkflow) {
@@ -22,8 +28,9 @@ function serve({ mastra, inngest }) {
     )
   );
   return serve$1({
+    ...registerOptions,
     client: inngest,
-    functions
+    functions: [...workflowFunctions, ...userFunctions]
   });
 }
 var InngestRun = class extends Run {
@@ -83,6 +90,7 @@ var InngestRun = class extends Run {
       await this.#mastra?.storage?.persistWorkflowSnapshot({
         workflowName: this.workflowId,
         runId: this.runId,
+        resourceId: this.resourceId,
         snapshot: {
           ...snapshot,
           status: "canceled"
@@ -96,6 +104,7 @@ var InngestRun = class extends Run {
     await this.#mastra.getStorage()?.persistWorkflowSnapshot({
       workflowName: this.workflowId,
       runId: this.runId,
+      resourceId: this.resourceId,
       snapshot: {
         runId: this.runId,
         serializedStepGraph: this.serializedStepGraph,
@@ -103,15 +112,18 @@ var InngestRun = class extends Run {
         context: {},
         activePaths: [],
         suspendedPaths: {},
+        waitingPaths: {},
         timestamp: Date.now(),
         status: "running"
       }
     });
+    const inputDataToUse = await this._validateInput(inputData);
     const eventOutput = await this.inngest.send({
       name: `workflow.${this.workflowId}`,
       data: {
-        inputData,
-        runId: this.runId
+        inputData: inputDataToUse,
+        runId: this.runId,
+        resourceId: this.resourceId
       }
     });
     const eventId = eventOutput.ids[0];
@@ -147,16 +159,19 @@ var InngestRun = class extends Run {
       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,
         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]]
         }
@@ -201,7 +216,11 @@ var InngestRun = class extends Run {
     const writer = writable.getWriter();
     const unwatch = this.watch(async (event) => {
       try {
-        await writer.write(event);
+        const e = {
+          ...event,
+          type: event.type.replace("workflow-", "")
+        };
+        await writer.write(e);
       } catch {
       }
     }, "watch-v2");
@@ -232,8 +251,14 @@ 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;
   }
@@ -254,27 +279,6 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
     const run = await storage.getWorkflowRunById({ runId, workflowName: this.id });
     return run ?? (this.runs.get(runId) ? { ...this.runs.get(runId), workflowName: this.id } : null);
   }
-  async getWorkflowRunExecutionResult(runId) {
-    const storage = this.#mastra?.getStorage();
-    if (!storage) {
-      this.logger.debug("Cannot get workflow run execution result. Mastra storage is not initialized");
-      return null;
-    }
-    const run = await storage.getWorkflowRunById({ runId, workflowName: this.id });
-    if (!run?.snapshot) {
-      return null;
-    }
-    if (typeof run.snapshot === "string") {
-      return null;
-    }
-    return {
-      status: run.snapshot.status,
-      result: run.snapshot.result,
-      error: run.snapshot.error,
-      payload: run.snapshot.context?.input,
-      steps: run.snapshot.context
-    };
-  }
   __registerMastra(mastra) {
     this.#mastra = mastra;
     this.executionEngine.__registerMastra(mastra);
@@ -293,23 +297,14 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       }
     }
   }
-  createRun(options) {
-    const runIdToUse = options?.runId || randomUUID();
-    const run = this.runs.get(runIdToUse) ?? new InngestRun(
-      {
-        workflowId: this.id,
-        runId: runIdToUse,
-        executionEngine: this.executionEngine,
-        executionGraph: this.executionGraph,
-        serializedStepGraph: this.serializedStepGraph,
-        mastra: this.#mastra,
-        retryConfig: this.retryConfig,
-        cleanup: () => this.runs.delete(runIdToUse)
-      },
-      this.inngest
+  /**
+   * @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."
     );
-    this.runs.set(runIdToUse, run);
-    return run;
   }
   async createRunAsync(options) {
     const runIdToUse = options?.runId || randomUUID();
@@ -317,27 +312,31 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       {
         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 workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse);
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse, false);
     if (!workflowSnapshotInStorage) {
       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: {},
           result: void 0,
@@ -358,11 +357,13 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
         id: `workflow.${this.id}`,
         // @ts-ignore
         retries: this.retryConfig?.attempts ?? 0,
-        cancelOn: [{ event: `cancel.workflow.${this.id}` }]
+        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, runId, resourceId, resume } = event.data;
         if (!runId) {
           runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
             return randomUUID();
@@ -394,6 +395,7 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
         const result = await engine.execute({
           workflowId: this.id,
           runId,
+          resourceId,
           graph: this.executionGraph,
           serializedStepGraph: this.serializedStepGraph,
           input: inputData,
@@ -402,7 +404,9 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
           runtimeContext: new RuntimeContext(),
           // TODO
           resume,
-          abortController: new AbortController()
+          abortController: new AbortController(),
+          currentSpan: void 0
+          // TODO: Pass actual parent AI span from workflow execution context
         });
         return { result, runId };
       }
@@ -436,17 +440,16 @@ function createStep(params) {
   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, runtimeContext, abortSignal, abort }) => {
+      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort, tracingContext }) => {
         let streamPromise = {};
         streamPromise.promise = new Promise((resolve, reject) => {
           streamPromise.resolve = resolve;
@@ -456,14 +459,9 @@ function createStep(params) {
           name: params.name,
           args: inputData
         };
-        await emitter.emit("watch-v2", {
-          type: "tool-call-streaming-start",
-          ...toolData
-        });
         const { fullStream } = await params.stream(inputData.prompt, {
-          // resourceId: inputData.resourceId,
-          // threadId: inputData.threadId,
           runtimeContext,
+          tracingContext,
           onFinish: (result) => {
             streamPromise.resolve(result.text);
           },
@@ -472,34 +470,28 @@ function createStep(params) {
         if (abortSignal.aborted) {
           return abort();
         }
+        await emitter.emit("watch-v2", {
+          type: "tool-call-streaming-start",
+          ...toolData ?? {}
+        });
         for await (const chunk of fullStream) {
-          switch (chunk.type) {
-            case "text-delta":
-              await emitter.emit("watch-v2", {
-                type: "tool-call-delta",
-                ...toolData,
-                argsTextDelta: chunk.textDelta
-              });
-              break;
-            case "step-start":
-            case "step-finish":
-            case "finish":
-              break;
-            case "tool-call":
-            case "tool-result":
-            case "tool-call-streaming-start":
-            case "tool-call-delta":
-            case "source":
-            case "file":
-            default:
-              await emitter.emit("watch-v2", chunk);
-              break;
+          if (chunk.type === "text-delta") {
+            await emitter.emit("watch-v2", {
+              type: "tool-call-delta",
+              ...toolData ?? {},
+              argsTextDelta: chunk.textDelta
+            });
           }
         }
+        await emitter.emit("watch-v2", {
+          type: "tool-call-streaming-finish",
+          ...toolData ?? {}
+        });
         return {
           text: await streamPromise.promise
         };
-      }
+      },
+      component: params.component
     };
   }
   if (isTool(params)) {
@@ -510,15 +502,20 @@ function createStep(params) {
       // 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, runtimeContext }) => {
+      execute: async ({ inputData, mastra, runtimeContext, tracingContext, suspend, resumeData }) => {
         return params.execute({
           context: inputData,
-          mastra,
-          runtimeContext
+          mastra: wrapMastra(mastra, tracingContext),
+          runtimeContext,
+          tracingContext,
+          suspend,
+          resumeData
         });
-      }
+      },
+      component: "TOOL"
     };
   }
   return {
@@ -543,7 +540,8 @@ function init(inngest) {
         description: step.description,
         inputSchema: step.inputSchema,
         outputSchema: step.outputSchema,
-        execute: step.execute
+        execute: step.execute,
+        component: step.component
       };
     },
     cloneWorkflow(workflow, opts) {
@@ -563,19 +561,19 @@ function init(inngest) {
 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 execute(params) {
     await params.emitter.emit("watch-v2", {
-      type: "start",
+      type: "workflow-start",
       payload: { runId: params.runId }
     });
     const result = await super.execute(params);
     await params.emitter.emit("watch-v2", {
-      type: "finish",
+      type: "workflow-finish",
       payload: { runId: params.runId }
     });
     return result;
@@ -637,33 +635,169 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     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,
+    runtimeContext,
     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({
+          runId,
+          workflowId,
+          mastra: this.mastra,
+          runtimeContext,
+          inputData: prevOutput,
+          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(
+            {
+              prefix: "workflow-step",
+              callId: stepCallId,
+              name: "sleep",
+              runId
+            },
+            writableStream
+          )
+        });
+      });
+      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,
     abortController,
-    runtimeContext
+    runtimeContext,
+    executionContext,
+    writableStream,
+    tracingContext
   }) {
-    return super.executeStep({
-      workflowId,
-      runId,
-      step,
-      stepResults,
-      executionContext,
-      resume,
-      prevOutput,
-      emitter,
-      abortController,
-      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
     });
-  }
-  async executeSleep({ id, duration }) {
-    await this.inngestStep.sleep(id, duration);
+    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,
+          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(
+            {
+              prefix: "workflow-step",
+              callId: stepCallId,
+              name: "sleep",
+              runId
+            },
+            writableStream
+          )
+        });
+      });
+      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}`, {
@@ -683,8 +817,25 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     prevOutput,
     emitter,
     abortController,
-    runtimeContext
+    runtimeContext,
+    tracingContext,
+    writableStream,
+    disableScorers
   }) {
+    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 () => {
@@ -711,10 +862,12 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           eventTimestamp: Date.now()
         });
         await emitter.emit("watch-v2", {
-          type: "step-start",
+          type: "workflow-step-start",
           payload: {
             id: step.id,
-            status: "running"
+            status: "running",
+            payload: inputData,
+            startedAt: startedAt2
           }
         });
         return startedAt2;
@@ -733,7 +886,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
           function: step.getFunction(),
           data: {
-            inputData: prevOutput,
+            inputData,
             runId,
             resume: {
               runId,
@@ -751,7 +904,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         const invokeResp = await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
           function: step.getFunction(),
           data: {
-            inputData: prevOutput
+            inputData
           }
         });
         result = invokeResp.result;
@@ -779,7 +932,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               eventTimestamp: Date.now()
             });
             await emitter.emit("watch-v2", {
-              type: "step-result",
+              type: "workflow-step-result",
               payload: {
                 id: step.id,
                 status: "failed",
@@ -814,7 +967,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
                 eventTimestamp: Date.now()
               });
               await emitter.emit("watch-v2", {
-                type: "step-suspended",
+                type: "workflow-step-suspended",
                 payload: {
                   id: step.id,
                   status: "suspended"
@@ -871,7 +1024,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             eventTimestamp: Date.now()
           });
           await emitter.emit("watch-v2", {
-            type: "step-result",
+            type: "workflow-step-result",
             payload: {
               id: step.id,
               status: "success",
@@ -879,7 +1032,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             }
           });
           await emitter.emit("watch-v2", {
-            type: "step-finish",
+            type: "workflow-step-finish",
             payload: {
               id: step.id,
               metadata: {}
@@ -896,20 +1049,21 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       let suspended;
       let bailed;
       try {
+        if (validationError) {
+          throw validationError;
+        }
         const result = await step.execute({
           runId: executionContext.runId,
           mastra: this.mastra,
           runtimeContext,
-          inputData: prevOutput,
+          writableStream,
+          inputData,
           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;
-            }
-            return null;
+          tracingContext: {
+            currentSpan: stepAISpan
           },
+          getInitData: () => stepResults?.input,
+          getStepResult: getStepResult.bind(this, stepResults),
           suspend: async (suspendPayload) => {
             executionContext.suspendedPaths[step.id] = executionContext.executionPath;
             suspended = { payload: suspendPayload };
@@ -935,14 +1089,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           output: result,
           startedAt,
           endedAt,
-          payload: prevOutput,
+          payload: inputData,
           resumedAt: resume?.steps[0] === step.id ? startedAt : void 0,
           resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : void 0
         };
       } catch (e) {
         execResults = {
           status: "failed",
-          payload: prevOutput,
+          payload: inputData,
           error: e instanceof Error ? e.message : String(e),
           endedAt: Date.now(),
           startedAt,
@@ -954,18 +1108,20 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         execResults = {
           status: "suspended",
           suspendedPayload: suspended.payload,
-          payload: prevOutput,
+          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: prevOutput, endedAt: Date.now(), startedAt };
+        execResults = { status: "bailed", output: bailed.payload, payload: inputData, endedAt: Date.now(), startedAt };
       }
       if (execResults.status === "failed") {
         if (executionContext.retryConfig.attempts > 0 && this.inngestAttempts < executionContext.retryConfig.attempts) {
-          throw execResults.error;
+          const error = new Error(execResults.error);
+          stepAISpan?.error({ error });
+          throw error;
         }
       }
       await emitter.emit("watch", {
@@ -986,7 +1142,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       });
       if (execResults.status === "suspended") {
         await emitter.emit("watch-v2", {
-          type: "step-suspended",
+          type: "workflow-step-suspended",
           payload: {
             id: step.id,
             ...execResults
@@ -994,22 +1150,40 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         });
       } else {
         await emitter.emit("watch-v2", {
-          type: "step-result",
+          type: "workflow-step-result",
           payload: {
             id: step.id,
             ...execResults
           }
         });
         await emitter.emit("watch-v2", {
-          type: "step-finish",
+          type: "workflow-step-finish",
           payload: {
             id: step.id,
             metadata: {}
           }
         });
       }
+      stepAISpan?.end({ output: execResults });
       return { result: execResults, executionContext, stepResults };
     });
+    if (disableScorers !== false) {
+      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,
+            runtimeContext,
+            disableScorers,
+            tracingContext: { currentSpan: stepAISpan }
+          });
+        }
+      });
+    }
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
     Object.assign(stepResults, stepRes.stepResults);
     return stepRes.result;
@@ -1018,6 +1192,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     workflowId,
     runId,
     stepResults,
+    resourceId,
     executionContext,
     serializedStepGraph,
     workflowStatus,
@@ -1030,12 +1205,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         await this.mastra?.getStorage()?.persistWorkflowSnapshot({
           workflowName: workflowId,
           runId,
+          resourceId,
           snapshot: {
             runId,
             value: {},
             context: stepResults,
             activePaths: [],
             suspendedPaths: executionContext.suspendedPaths,
+            waitingPaths: {},
             serializedStepGraph,
             status: workflowStatus,
             result,
@@ -1059,30 +1236,46 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     executionContext,
     emitter,
     abortController,
-    runtimeContext
+    runtimeContext,
+    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({
               runId,
+              workflowId,
               mastra: this.mastra,
               runtimeContext,
               runCount: -1,
               inputData: prevOutput,
-              getInitData: () => stepResults?.input,
-              getStepResult: (step) => {
-                if (!step?.id) {
-                  return null;
-                }
-                const result2 = stepResults[step.id];
-                if (result2?.status === "success") {
-                  return result2.output;
-                }
-                return null;
+              tracingContext: {
+                currentSpan: evalSpan
               },
+              getInitData: () => stepResults?.input,
+              getStepResult: getStepResult.bind(this, stepResults),
               // TODO: this function shouldn't have suspend probably?
               suspend: async (_suspendPayload) => {
               },
@@ -1092,29 +1285,58 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
                 abortController.abort();
               },
               [EMITTER_SYMBOL]: emitter,
+              [STREAM_FORMAT_SYMBOL]: executionContext.format,
+              // TODO: add streamVNext support
               engine: {
                 step: this.inngestStep
               },
-              abortSignal: abortController.signal
+              abortSignal: abortController.signal,
+              writer: new ToolStream(
+                {
+                  prefix: "workflow-step",
+                  callId: randomUUID(),
+                  name: "conditional",
+                  runId
+                },
+                writableStream
+              )
+            });
+            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,
+          serializedStepGraph,
           prevStep,
           stepResults,
           resume,
-          serializedStepGraph,
           executionContext: {
             workflowId,
             runId,
@@ -1125,7 +1347,12 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           },
           emitter,
           abortController,
-          runtimeContext
+          runtimeContext,
+          writableStream,
+          disableScorers,
+          tracingContext: {
+            currentSpan: conditionalSpan
+          }
         })
       )
     );
@@ -1146,8 +1373,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, createStep, init, serve };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map