@mastra/inngest 0.0.0-vector-sources-20250516175436 → 0.0.0-vector-query-tool-provider-options-20250828222356

package/src/index.ts

@@ -1,34 +1,55 @@
 import { randomUUID } from 'crypto';
+import type { ReadableStream } from 'node:stream/web';
 import { subscribe } from '@inngest/realtime';
-import type { Mastra, VNextWorkflowRun, VNextWorkflowRuns } from '@mastra/core';
+import type { Agent } from '@mastra/core/agent';
+import { AISpanType, wrapMastra } from '@mastra/core/ai-tracing';
+import type { TracingContext, AnyAISpan } from '@mastra/core/ai-tracing';
 import { RuntimeContext } from '@mastra/core/di';
-import { NewWorkflow, createStep, Run, DefaultExecutionEngine, cloneStep } from '@mastra/core/workflows/vNext';
+import type { Mastra } from '@mastra/core/mastra';
+import type { WorkflowRun, WorkflowRuns } from '@mastra/core/storage';
+import type { ToolExecutionContext } from '@mastra/core/tools';
+import { Tool, ToolStream } from '@mastra/core/tools';
+import { Workflow, Run, DefaultExecutionEngine } from '@mastra/core/workflows';
 import type {
   ExecuteFunction,
   ExecutionContext,
   ExecutionEngine,
   ExecutionGraph,
-  NewStep,
-  NewStep as Step,
-  NewWorkflowConfig,
+  Step,
+  WorkflowConfig,
   StepFlowEntry,
   StepResult,
   WorkflowResult,
-} from '@mastra/core/workflows/vNext';
+  SerializedStepFlowEntry,
+  StepFailure,
+  Emitter,
+  WatchEvent,
+  StreamEvent,
+  ChunkType,
+} from '@mastra/core/workflows';
+import { EMITTER_SYMBOL } from '@mastra/core/workflows/_constants';
 import type { Span } from '@opentelemetry/api';
 import type { Inngest, BaseContext } from 'inngest';
 import { serve as inngestServe } from 'inngest/hono';
-import type { z } from 'zod';
+import { z } from 'zod';
+
+export type InngestEngineType = {
+  step: any;
+};
 
 export function serve({ mastra, inngest }: { mastra: Mastra; inngest: Inngest }): ReturnType<typeof inngestServe> {
-  const wfs = mastra.vnext_getWorkflows();
-  const functions = Object.values(wfs).flatMap(wf => {
-    if (wf instanceof InngestWorkflow) {
-      wf.__registerMastra(mastra);
-      return wf.getFunctions();
-    }
-    return [];
-  });
+  const wfs = mastra.getWorkflows();
+  const functions = Array.from(
+    new Set(
+      Object.values(wfs).flatMap(wf => {
+        if (wf instanceof InngestWorkflow) {
+          wf.__registerMastra(mastra);
+          return wf.getFunctions();
+        }
+        return [];
+      }),
+    ),
+  );
   return inngestServe({
     client: inngest,
     functions,
@@ -36,11 +57,13 @@ export function serve({ mastra, inngest }: { mastra: Mastra; inngest: Inngest })
 }
 
 export class InngestRun<
-  TSteps extends NewStep<string, any, any>[] = NewStep<string, any, any>[],
+  TEngineType = InngestEngineType,
+  TSteps extends Step<string, any, any>[] = Step<string, any, any>[],
   TInput extends z.ZodType<any> = z.ZodType<any>,
   TOutput extends z.ZodType<any> = z.ZodType<any>,
-> extends Run<TSteps, TInput, TOutput> {
+> extends Run<TEngineType, TSteps, TInput, TOutput> {
   private inngest: Inngest;
+  serializedStepGraph: SerializedStepFlowEntry[];
   #mastra: Mastra;
 
   constructor(
@@ -49,6 +72,7 @@ export class InngestRun<
       runId: string;
       executionEngine: ExecutionEngine;
       executionGraph: ExecutionGraph;
+      serializedStepGraph: SerializedStepFlowEntry[];
       mastra?: Mastra;
       retryConfig?: {
         attempts?: number;
@@ -60,11 +84,12 @@ export class InngestRun<
   ) {
     super(params);
     this.inngest = inngest;
+    this.serializedStepGraph = params.serializedStepGraph;
     this.#mastra = params.mastra!;
   }
 
   async getRuns(eventId: string) {
-    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}`,
       },
@@ -75,16 +100,55 @@ export class InngestRun<
 
   async getRunOutput(eventId: string) {
     let runs = await this.getRuns(eventId);
-    while (runs?.[0]?.status !== 'Completed') {
+
+    while (runs?.[0]?.status !== 'Completed' || runs?.[0]?.event_id !== eventId) {
       await new Promise(resolve => setTimeout(resolve, 1000));
       runs = await this.getRuns(eventId);
-      if (runs?.[0]?.status === 'Failed' || runs?.[0]?.status === 'Cancelled') {
+      if (runs?.[0]?.status === 'Failed') {
+        console.log('run', runs?.[0]);
         throw new Error(`Function run ${runs?.[0]?.status}`);
+      } else if (runs?.[0]?.status === 'Cancelled') {
+        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId,
+        });
+        return { output: { result: { steps: snapshot?.context, status: 'canceled' } } };
       }
     }
     return runs?.[0];
   }
 
+  async sendEvent(event: string, data: any) {
+    await this.inngest.send({
+      name: `user-event-${event}`,
+      data,
+    });
+  }
+
+  async cancel() {
+    await this.inngest.send({
+      name: `cancel.workflow.${this.workflowId}`,
+      data: {
+        runId: this.runId,
+      },
+    });
+
+    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId,
+    });
+    if (snapshot) {
+      await this.#mastra?.storage?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        snapshot: {
+          ...snapshot,
+          status: 'canceled' as any,
+        },
+      });
+    }
+  }
+
   async start({
     inputData,
   }: {
@@ -96,11 +160,14 @@ export class InngestRun<
       runId: this.runId,
       snapshot: {
         runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
         value: {},
         context: {} as any,
         activePaths: [],
         suspendedPaths: {},
+        waitingPaths: {},
         timestamp: Date.now(),
+        status: 'running',
       },
     });
 
@@ -122,7 +189,9 @@ export class InngestRun<
       result.error = new Error(result.error);
     }
 
-    this.cleanup?.();
+    if (result.status !== 'suspended') {
+      this.cleanup?.();
+    }
     return result;
   }
 
@@ -134,6 +203,27 @@ export class InngestRun<
       | string
       | string[];
     runtimeContext?: RuntimeContext;
+  }): Promise<WorkflowResult<TOutput, TSteps>> {
+    const p = this._resume(params).then(result => {
+      if (result.status !== 'suspended') {
+        this.closeStreamAction?.().catch(() => {});
+      }
+
+      return result;
+    });
+
+    this.executionResults = p;
+    return p;
+  }
+
+  async _resume<TResumeSchema extends z.ZodType<any>>(params: {
+    resumeData?: z.infer<TResumeSchema>;
+    step:
+      | Step<string, any, any, TResumeSchema, any>
+      | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>]
+      | string
+      | string[];
+    runtimeContext?: RuntimeContext;
   }): Promise<WorkflowResult<TOutput, TSteps>> {
     const steps: string[] = (Array.isArray(params.step) ? params.step : [params.step]).map(step =>
       typeof step === 'string' ? step : step?.id,
@@ -148,6 +238,7 @@ export class InngestRun<
       data: {
         inputData: params.resumeData,
         runId: this.runId,
+        workflowId: this.workflowId,
         stepResults: snapshot?.context as any,
         resume: {
           steps,
@@ -171,43 +262,88 @@ export class InngestRun<
     return result;
   }
 
-  watch(cb: (event: any) => void): () => void {
+  watch(cb: (event: WatchEvent) => void, type: 'watch' | 'watch-v2' = 'watch'): () => void {
+    let active = true;
     const streamPromise = subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: ['watch'],
+        topics: [type],
         app: this.inngest,
       },
       (message: any) => {
-        cb(message.data);
+        if (active) {
+          cb(message.data);
+        }
       },
     );
 
     return () => {
+      active = false;
       streamPromise
-        .then((stream: any) => {
-          stream.cancel();
+        .then(async (stream: Awaited<typeof streamPromise>) => {
+          return stream.cancel();
         })
         .catch(err => {
           console.error(err);
         });
     };
   }
+
+  stream({ inputData, runtimeContext }: { inputData?: z.infer<TInput>; runtimeContext?: RuntimeContext } = {}): {
+    stream: ReadableStream<StreamEvent>;
+    getWorkflowState: () => Promise<WorkflowResult<TOutput, TSteps>>;
+  } {
+    const { readable, writable } = new TransformStream<StreamEvent, StreamEvent>();
+
+    const writer = writable.getWriter();
+    const unwatch = this.watch(async event => {
+      try {
+        // watch-v2 events are data stream events, so we need to cast them to the correct type
+        await writer.write(event as any);
+      } catch {}
+    }, 'watch-v2');
+
+    this.closeStreamAction = async () => {
+      unwatch();
+
+      try {
+        await writer.close();
+      } catch (err) {
+        console.error('Error closing stream:', err);
+      } finally {
+        writer.releaseLock();
+      }
+    };
+
+    this.executionResults = this.start({ inputData, runtimeContext }).then(result => {
+      if (result.status !== 'suspended') {
+        this.closeStreamAction?.().catch(() => {});
+      }
+
+      return result;
+    });
+
+    return {
+      stream: readable as ReadableStream<StreamEvent>,
+      getWorkflowState: () => this.executionResults!,
+    };
+  }
 }
 
 export class InngestWorkflow<
-  TSteps extends NewStep<string, any, any>[] = NewStep<string, any, any>[],
+  TEngineType = InngestEngineType,
+  TSteps extends Step<string, any, any>[] = Step<string, any, any>[],
   TWorkflowId extends string = string,
   TInput extends z.ZodType<any> = z.ZodType<any>,
   TOutput extends z.ZodType<any> = z.ZodType<any>,
   TPrevSchema extends z.ZodType<any> = TInput,
-> extends NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {
+> extends Workflow<TEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {
   #mastra: Mastra;
   public inngest: Inngest;
 
   private function: ReturnType<Inngest['createFunction']> | undefined;
 
-  constructor(params: NewWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest) {
+  constructor(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest) {
     super(params);
     this.#mastra = params.mastra!;
     this.inngest = inngest;
@@ -226,25 +362,52 @@ export class InngestWorkflow<
       return { runs: [], total: 0 };
     }
 
-    return storage.getWorkflowRuns({ workflowName: this.id, ...(args ?? {}) }) as unknown as VNextWorkflowRuns;
+    return storage.getWorkflowRuns({ workflowName: this.id, ...(args ?? {}) }) as unknown as WorkflowRuns;
   }
 
-  async getWorkflowRunById(runId: string): Promise<VNextWorkflowRun | null> {
+  async getWorkflowRunById(runId: string): Promise<WorkflowRun | null> {
     const storage = this.#mastra?.getStorage();
     if (!storage) {
       this.logger.debug('Cannot get workflow runs. Mastra engine is not initialized');
-      return null;
+      //returning in memory run if no storage is initialized
+      return this.runs.get(runId)
+        ? ({ ...this.runs.get(runId), workflowName: this.id } as unknown as WorkflowRun)
+        : null;
     }
-    const run = (await storage.getWorkflowRunById({ runId, workflowName: this.id })) as unknown as VNextWorkflowRun;
+    const run = (await storage.getWorkflowRunById({ runId, workflowName: this.id })) as unknown as WorkflowRun;
 
     return (
       run ??
-      (this.runs.get(runId)
-        ? ({ ...this.runs.get(runId), workflowName: this.id } as unknown as VNextWorkflowRun)
-        : null)
+      (this.runs.get(runId) ? ({ ...this.runs.get(runId), workflowName: this.id } as unknown as WorkflowRun) : null)
     );
   }
 
+  async getWorkflowRunExecutionResult(runId: string): Promise<WatchEvent['payload']['workflowState'] | null> {
+    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 as any,
+    };
+  }
+
   __registerMastra(mastra: Mastra) {
     this.#mastra = mastra;
     this.executionEngine.__registerMastra(mastra);
@@ -268,11 +431,35 @@ export class InngestWorkflow<
     }
   }
 
-  createRun(options?: { runId?: string }): Run<TSteps, TInput, TOutput> {
+  createRun(options?: { runId?: string }): Run<TEngineType, TSteps, TInput, TOutput> {
+    const runIdToUse = options?.runId || randomUUID();
+
+    // Return a new Run instance with object parameters
+    const run: Run<TEngineType, TSteps, TInput, TOutput> =
+      this.runs.get(runIdToUse) ??
+      new InngestRun(
+        {
+          workflowId: this.id,
+          runId: runIdToUse,
+          executionEngine: this.executionEngine,
+          executionGraph: this.executionGraph,
+          serializedStepGraph: this.serializedStepGraph,
+          mastra: this.#mastra,
+          retryConfig: this.retryConfig,
+          cleanup: () => this.runs.delete(runIdToUse),
+        },
+        this.inngest,
+      );
+
+    this.runs.set(runIdToUse, run);
+    return run;
+  }
+
+  async createRunAsync(options?: { runId?: string }): Promise<Run<TEngineType, TSteps, TInput, TOutput>> {
     const runIdToUse = options?.runId || randomUUID();
 
     // Return a new Run instance with object parameters
-    const run: Run<TSteps, TInput, TOutput> =
+    const run: Run<TEngineType, TSteps, TInput, TOutput> =
       this.runs.get(runIdToUse) ??
       new InngestRun(
         {
@@ -280,6 +467,7 @@ export class InngestWorkflow<
           runId: runIdToUse,
           executionEngine: this.executionEngine,
           executionGraph: this.executionGraph,
+          serializedStepGraph: this.serializedStepGraph,
           mastra: this.#mastra,
           retryConfig: this.retryConfig,
           cleanup: () => this.runs.delete(runIdToUse),
@@ -288,6 +476,30 @@ export class InngestWorkflow<
       );
 
     this.runs.set(runIdToUse, run);
+
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse);
+
+    if (!workflowSnapshotInStorage) {
+      await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+        workflowName: this.id,
+        runId: runIdToUse,
+        snapshot: {
+          runId: runIdToUse,
+          status: 'pending',
+          value: {},
+          context: {},
+          activePaths: [],
+          waitingPaths: {},
+          serializedStepGraph: this.serializedStepGraph,
+          suspendedPaths: {},
+          result: undefined,
+          error: undefined,
+          // @ts-ignore
+          timestamp: Date.now(),
+        },
+      });
+    }
+
     return run;
   }
 
@@ -296,8 +508,12 @@ export class InngestWorkflow<
       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}` }],
+      },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
         let { inputData, runId, resume } = event.data;
@@ -317,13 +533,22 @@ export class InngestWorkflow<
             try {
               await publish({
                 channel: `workflow:${this.id}:${runId}`,
-                topic: 'watch',
+                topic: event,
                 data,
               });
             } catch (err: any) {
               this.logger.error('Error emitting event: ' + (err?.stack ?? err?.message ?? err));
             }
           },
+          on: (_event: string, _callback: (data: any) => void) => {
+            // no-op
+          },
+          off: (_event: string, _callback: (data: any) => void) => {
+            // no-op
+          },
+          once: (_event: string, _callback: (data: any) => void) => {
+            // no-op
+          },
         };
 
         const engine = new InngestExecutionEngine(this.#mastra, step, attempt);
@@ -331,11 +556,14 @@ export class InngestWorkflow<
           workflowId: this.id,
           runId,
           graph: this.executionGraph,
+          serializedStepGraph: this.serializedStepGraph,
           input: inputData,
           emitter,
           retryConfig: this.retryConfig,
           runtimeContext: new RuntimeContext(), // TODO
           resume,
+          abortController: new AbortController(),
+          currentSpan: undefined, // TODO: Pass actual parent AI span from workflow execution context
         });
 
         return { result, runId };
@@ -364,29 +592,199 @@ export class InngestWorkflow<
   }
 }
 
-function cloneWorkflow<
-  TWorkflowId extends string = string,
-  TInput extends z.ZodType<any> = z.ZodType<any>,
-  TOutput extends z.ZodType<any> = z.ZodType<any>,
-  TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[],
+function isAgent(params: any): params is Agent<any, any, any> {
+  return params?.component === 'AGENT';
+}
+
+function isTool(params: any): params is Tool<any, any, any> {
+  return params instanceof Tool;
+}
+
+export function createStep<
+  TStepId extends string,
+  TStepInput extends z.ZodType<any>,
+  TStepOutput extends z.ZodType<any>,
+  TResumeSchema extends z.ZodType<any>,
+  TSuspendSchema extends z.ZodType<any>,
+>(params: {
+  id: TStepId;
+  description?: string;
+  inputSchema: TStepInput;
+  outputSchema: TStepOutput;
+  resumeSchema?: TResumeSchema;
+  suspendSchema?: TSuspendSchema;
+  execute: ExecuteFunction<
+    z.infer<TStepInput>,
+    z.infer<TStepOutput>,
+    z.infer<TResumeSchema>,
+    z.infer<TSuspendSchema>,
+    InngestEngineType
+  >;
+}): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema, InngestEngineType>;
+
+export function createStep<
+  TStepId extends string,
+  TStepInput extends z.ZodObject<{ prompt: z.ZodString }>,
+  TStepOutput extends z.ZodObject<{ text: z.ZodString }>,
+  TResumeSchema extends z.ZodType<any>,
+  TSuspendSchema extends z.ZodType<any>,
 >(
-  workflow: InngestWorkflow<TSteps, string, TInput, TOutput>,
-  opts: { id: TWorkflowId },
-): InngestWorkflow<TSteps, TWorkflowId, TInput, TOutput> {
-  const wf = new InngestWorkflow(
-    {
-      id: opts.id,
-      inputSchema: workflow.inputSchema,
-      outputSchema: workflow.outputSchema,
-      steps: workflow.stepDefs,
-      mastra: workflow.mastra,
-    },
-    workflow.inngest,
-  );
+  agent: Agent<TStepId, any, any>,
+): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema, InngestEngineType>;
+
+export function createStep<
+  TSchemaIn extends z.ZodType<any>,
+  TSchemaOut extends z.ZodType<any>,
+  TContext extends ToolExecutionContext<TSchemaIn>,
+>(
+  tool: Tool<TSchemaIn, TSchemaOut, TContext> & {
+    inputSchema: TSchemaIn;
+    outputSchema: TSchemaOut;
+    execute: (context: TContext) => Promise<any>;
+  },
+): Step<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>, InngestEngineType>;
+export function createStep<
+  TStepId extends string,
+  TStepInput extends z.ZodType<any>,
+  TStepOutput extends z.ZodType<any>,
+  TResumeSchema extends z.ZodType<any>,
+  TSuspendSchema extends z.ZodType<any>,
+>(
+  params:
+    | {
+        id: TStepId;
+        description?: string;
+        inputSchema: TStepInput;
+        outputSchema: TStepOutput;
+        resumeSchema?: TResumeSchema;
+        suspendSchema?: TSuspendSchema;
+        execute: ExecuteFunction<
+          z.infer<TStepInput>,
+          z.infer<TStepOutput>,
+          z.infer<TResumeSchema>,
+          z.infer<TSuspendSchema>,
+          InngestEngineType
+        >;
+      }
+    | Agent<any, any, any>
+    | (Tool<TStepInput, TStepOutput, any> & {
+        inputSchema: TStepInput;
+        outputSchema: TStepOutput;
+        execute: (context: ToolExecutionContext<TStepInput>) => Promise<any>;
+      }),
+): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema, InngestEngineType> {
+  if (isAgent(params)) {
+    return {
+      id: params.name,
+      // @ts-ignore
+      inputSchema: z.object({
+        prompt: z.string(),
+        // resourceId: z.string().optional(),
+        // threadId: z.string().optional(),
+      }),
+      // @ts-ignore
+      outputSchema: z.object({
+        text: z.string(),
+      }),
+      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort, tracingContext }) => {
+        let streamPromise = {} as {
+          promise: Promise<string>;
+          resolve: (value: string) => void;
+          reject: (reason?: any) => void;
+        };
+
+        streamPromise.promise = new Promise((resolve, reject) => {
+          streamPromise.resolve = resolve;
+          streamPromise.reject = reject;
+        });
+        const toolData = {
+          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);
+          },
+          abortSignal,
+        });
+
+        if (abortSignal.aborted) {
+          return abort();
+        }
+
+        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;
+          }
+        }
+
+        return {
+          text: await streamPromise.promise,
+        };
+      },
+    };
+  }
+
+  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,
+      inputSchema: params.inputSchema,
+      outputSchema: params.outputSchema,
+      execute: async ({ inputData, mastra, runtimeContext, tracingContext }) => {
+        return params.execute({
+          context: inputData,
+          mastra: wrapMastra(mastra, tracingContext),
+          runtimeContext,
+          tracingContext,
+        });
+      },
+    };
+  }
 
-  wf.setStepFlow(workflow.stepGraph);
-  wf.commit();
-  return wf;
+  return {
+    id: params.id,
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema,
+    resumeSchema: params.resumeSchema,
+    suspendSchema: params.suspendSchema,
+    execute: params.execute,
+  };
 }
 
 export function init(inngest: Inngest) {
@@ -395,13 +793,59 @@ export function init(inngest: Inngest) {
       TWorkflowId extends string = string,
       TInput extends z.ZodType<any> = z.ZodType<any>,
       TOutput extends z.ZodType<any> = z.ZodType<any>,
-      TSteps extends Step<string, any, any>[] = Step<string, any, any>[],
-    >(params: NewWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>) {
-      return new InngestWorkflow(params, inngest);
+      TSteps extends Step<string, any, any, any, any, InngestEngineType>[] = Step<
+        string,
+        any,
+        any,
+        any,
+        any,
+        InngestEngineType
+      >[],
+    >(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>) {
+      return new InngestWorkflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TInput>(params, inngest);
     },
     createStep,
-    cloneStep,
-    cloneWorkflow,
+    cloneStep<TStepId extends string>(
+      step: Step<string, any, any, any, any, InngestEngineType>,
+      opts: { id: TStepId },
+    ): Step<TStepId, any, any, any, any, InngestEngineType> {
+      return {
+        id: opts.id,
+        description: step.description,
+        inputSchema: step.inputSchema,
+        outputSchema: step.outputSchema,
+        execute: step.execute,
+      };
+    },
+    cloneWorkflow<
+      TWorkflowId extends string = string,
+      TInput extends z.ZodType<any> = z.ZodType<any>,
+      TOutput extends z.ZodType<any> = z.ZodType<any>,
+      TSteps extends Step<string, any, any, any, any, InngestEngineType>[] = Step<
+        string,
+        any,
+        any,
+        any,
+        any,
+        InngestEngineType
+      >[],
+      TPrevSchema extends z.ZodType<any> = TInput,
+    >(
+      workflow: Workflow<InngestEngineType, TSteps, string, TInput, TOutput, TPrevSchema>,
+      opts: { id: TWorkflowId },
+    ): Workflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {
+      const wf: Workflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> = 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;
+    },
   };
 }
 
@@ -415,11 +859,48 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     this.inngestAttempts = inngestAttempts;
   }
 
+  async execute<TInput, TOutput>(params: {
+    workflowId: string;
+    runId: string;
+    graph: ExecutionGraph;
+    serializedStepGraph: SerializedStepFlowEntry[];
+    input?: TInput;
+    resume?: {
+      // TODO: add execute path
+      steps: string[];
+      stepResults: Record<string, StepResult<any, any, any, any>>;
+      resumePayload: any;
+      resumePath: number[];
+    };
+    emitter: Emitter;
+    retryConfig?: {
+      attempts?: number;
+      delay?: number;
+    };
+    runtimeContext: RuntimeContext;
+    abortController: AbortController;
+    currentSpan?: AnyAISpan;
+  }): Promise<TOutput> {
+    await params.emitter.emit('watch-v2', {
+      type: 'start',
+      payload: { runId: params.runId },
+    });
+
+    const result = await super.execute<TInput, TOutput>(params);
+
+    await params.emitter.emit('watch-v2', {
+      type: 'finish',
+      payload: { runId: params.runId },
+    });
+
+    return result;
+  }
+
   protected async fmtReturnValue<TOutput>(
     executionSpan: Span | undefined,
-    emitter: { emit: (event: string, data: any) => Promise<void> },
-    stepResults: Record<string, StepResult<any>>,
-    lastOutput: StepResult<any>,
+    emitter: Emitter,
+    stepResults: Record<string, StepResult<any, any, any, any>>,
+    lastOutput: StepResult<any, any, any, any>,
     error?: Error | string,
   ): Promise<TOutput> {
     const base: any = {
@@ -489,41 +970,254 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     return base as TOutput;
   }
 
-  async superExecuteStep({
+  // async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
+  //   await this.inngestStep.sleep(id, duration);
+  // }
+
+  async executeSleep({
     workflowId,
     runId,
-    step,
-    stepResults,
-    executionContext,
-    resume,
+    entry,
     prevOutput,
+    stepResults,
     emitter,
+    abortController,
     runtimeContext,
+    writableStream,
+    tracingContext,
   }: {
     workflowId: string;
     runId: string;
-    step: Step<string, any, any>;
-    stepResults: Record<string, StepResult<any>>;
-    executionContext: ExecutionContext;
+    serializedStepGraph: SerializedStepFlowEntry[];
+    entry: {
+      type: 'sleep';
+      id: string;
+      duration?: number;
+      fn?: ExecuteFunction<any, any, any, any, InngestEngineType>;
+    };
+    prevStep: StepFlowEntry;
+    prevOutput: any;
+    stepResults: Record<string, StepResult<any, any, any, any>>;
     resume?: {
       steps: string[];
+      stepResults: Record<string, StepResult<any, any, any, any>>;
       resumePayload: any;
+      resumePath: number[];
     };
+    executionContext: ExecutionContext;
+    emitter: Emitter;
+    abortController: AbortController;
+    runtimeContext: RuntimeContext;
+    writableStream?: WritableStream<ChunkType>;
+    tracingContext?: TracingContext;
+  }): Promise<void> {
+    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',
+      },
+    });
+
+    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 as any,
+          getStepResult: (step: any) => {
+            if (!step?.id) {
+              return null;
+            }
+
+            const result = stepResults[step.id];
+            if (result?.status === 'success') {
+              return result.output;
+            }
+
+            return null;
+          },
+
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload: any): Promise<any> => {},
+          bail: () => {},
+          abort: () => {
+            abortController?.abort();
+          },
+          [EMITTER_SYMBOL]: emitter,
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new ToolStream(
+            {
+              prefix: 'step',
+              callId: stepCallId,
+              name: 'sleep',
+              runId,
+            },
+            writableStream,
+          ),
+        });
+      });
+
+      // Update sleep span with dynamic duration
+      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 as Error });
+      throw e;
+    }
+  }
+
+  async executeSleepUntil({
+    workflowId,
+    runId,
+    entry,
+    prevOutput,
+    stepResults,
+    emitter,
+    abortController,
+    runtimeContext,
+    writableStream,
+    tracingContext,
+  }: {
+    workflowId: string;
+    runId: string;
+    serializedStepGraph: SerializedStepFlowEntry[];
+    entry: {
+      type: 'sleepUntil';
+      id: string;
+      date?: Date;
+      fn?: ExecuteFunction<any, any, any, any, InngestEngineType>;
+    };
+    prevStep: StepFlowEntry;
     prevOutput: any;
-    emitter: { emit: (event: string, data: any) => Promise<void> };
+    stepResults: Record<string, StepResult<any, any, any, any>>;
+    resume?: {
+      steps: string[];
+      stepResults: Record<string, StepResult<any, any, any, any>>;
+      resumePayload: any;
+      resumePath: number[];
+    };
+    executionContext: ExecutionContext;
+    emitter: Emitter;
+    abortController: AbortController;
     runtimeContext: RuntimeContext;
-  }): Promise<StepResult<any>> {
-    return super.executeStep({
-      workflowId,
-      runId,
-      step,
-      stepResults,
-      executionContext,
-      resume,
-      prevOutput,
-      emitter,
-      runtimeContext,
+    writableStream?: WritableStream<ChunkType>;
+    tracingContext?: TracingContext;
+  }): Promise<void> {
+    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()) : undefined,
+        sleepType: fn ? 'dynamic' : 'fixed',
+      },
+    });
+
+    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 as any,
+          getStepResult: (step: any) => {
+            if (!step?.id) {
+              return null;
+            }
+
+            const result = stepResults[step.id];
+            if (result?.status === 'success') {
+              return result.output;
+            }
+
+            return null;
+          },
+
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload: any): Promise<any> => {},
+          bail: () => {},
+          abort: () => {
+            abortController?.abort();
+          },
+          [EMITTER_SYMBOL]: emitter,
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new ToolStream(
+            {
+              prefix: 'step',
+              callId: stepCallId,
+              name: 'sleep',
+              runId,
+            },
+            writableStream,
+          ),
+        });
+      });
+
+      // Update sleep until span with dynamic duration
+      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 as Error });
+      throw e;
+    }
+  }
+
+  async executeWaitForEvent({ event, timeout }: { event: string; timeout?: number }): Promise<any> {
+    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({
@@ -533,29 +1227,41 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     resume,
     prevOutput,
     emitter,
+    abortController,
     runtimeContext,
+    writableStream,
+    disableScorers,
+    tracingContext,
   }: {
     step: Step<string, any, any>;
-    stepResults: Record<string, StepResult<any>>;
-    executionContext: {
-      workflowId: string;
-      runId: string;
-      executionPath: number[];
-      suspendedPaths: Record<string, number[]>;
-      retryConfig: { attempts: number; delay: number };
-    };
+    stepResults: Record<string, StepResult<any, any, any, any>>;
+    executionContext: ExecutionContext;
     resume?: {
       steps: string[];
       resumePayload: any;
       runId?: string;
     };
     prevOutput: any;
-    emitter: { emit: (event: string, data: any) => Promise<void> };
+    emitter: Emitter;
+    abortController: AbortController;
     runtimeContext: RuntimeContext;
-  }): Promise<StepResult<any>> {
-    await this.inngestStep.run(
+    writableStream?: WritableStream<ChunkType>;
+    disableScorers?: boolean;
+    tracingContext?: TracingContext;
+  }): Promise<StepResult<any, any, any, any>> {
+    const stepAISpan = tracingContext?.currentSpan?.createChildSpan({
+      name: `workflow step: '${step.id}'`,
+      type: AISpanType.WORKFLOW_STEP,
+      input: prevOutput,
+      attributes: {
+        stepId: step.id,
+      },
+    });
+
+    const startedAt = await this.inngestStep.run(
       `workflow.${executionContext.workflowId}.run.${executionContext.runId}.step.${step.id}.running_ev`,
       async () => {
+        const startedAt = Date.now();
         await emitter.emit('watch', {
           type: 'watch',
           payload: {
@@ -577,6 +1283,18 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           },
           eventTimestamp: Date.now(),
         });
+
+        await emitter.emit('watch-v2', {
+          type: 'step-start',
+          payload: {
+            id: step.id,
+            status: 'running',
+            payload: prevOutput,
+            startedAt,
+          },
+        });
+
+        return startedAt;
       },
     );
 
@@ -643,10 +1361,20 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
               eventTimestamp: Date.now(),
             });
 
+            await emitter.emit('watch-v2', {
+              type: 'step-result',
+              payload: {
+                id: step.id,
+                status: 'failed',
+                error: result?.error,
+                payload: prevOutput,
+              },
+            });
+
             return { executionContext, result: { status: 'failed', error: result?.error } };
           } else if (result.status === 'suspended') {
             const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult]) => {
-              const stepRes: StepResult<any> = stepResult as StepResult<any>;
+              const stepRes: StepResult<any, any, any, any> = stepResult as StepResult<any, any, any, any>;
               return stepRes?.status === 'suspended';
             });
 
@@ -673,6 +1401,14 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
                 eventTimestamp: Date.now(),
               });
 
+              await emitter.emit('watch-v2', {
+                type: 'step-suspended',
+                payload: {
+                  id: step.id,
+                  status: 'suspended',
+                },
+              });
+
               return {
                 executionContext,
                 result: {
@@ -729,23 +1465,58 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             eventTimestamp: Date.now(),
           });
 
+          await emitter.emit('watch-v2', {
+            type: 'step-result',
+            payload: {
+              id: step.id,
+              status: 'success',
+              output: result?.result,
+            },
+          });
+
+          await emitter.emit('watch-v2', {
+            type: 'step-finish',
+            payload: {
+              id: step.id,
+              metadata: {},
+            },
+          });
+
           return { executionContext, result: { status: 'success', output: result?.result } };
         },
       );
 
       Object.assign(executionContext, res.executionContext);
-      return res.result as StepResult<any>;
+      return res.result as StepResult<any, any, any, any>;
     }
 
     const stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
-      let execResults: any;
+      let execResults: {
+        status: 'success' | 'failed' | 'suspended' | 'bailed';
+        output?: any;
+        startedAt: number;
+        endedAt?: number;
+        payload: any;
+        error?: string;
+        resumedAt?: number;
+        resumePayload?: any;
+        suspendedPayload?: any;
+        suspendedAt?: number;
+      };
       let suspended: { payload: any } | undefined;
+      let bailed: { payload: any } | undefined;
+
       try {
         const result = await step.execute({
+          runId: executionContext.runId,
           mastra: this.mastra!,
           runtimeContext,
+          writableStream,
           inputData: prevOutput,
           resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : undefined,
+          tracingContext: {
+            currentSpan: stepAISpan,
+          },
           getInitData: () => stepResults?.input as any,
           getStepResult: (step: any) => {
             const result = stepResults[step.id];
@@ -759,27 +1530,63 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             executionContext.suspendedPaths[step.id] = executionContext.executionPath;
             suspended = { payload: suspendPayload };
           },
+          bail: (result: any) => {
+            bailed = { payload: result };
+          },
           resume: {
             steps: resume?.steps?.slice(1) || [],
             resumePayload: resume?.resumePayload,
             // @ts-ignore
             runId: stepResults[step.id]?.payload?.__workflow_meta?.runId,
           },
-          emitter,
+          [EMITTER_SYMBOL]: emitter,
+          engine: {
+            step: this.inngestStep,
+          },
+          abortSignal: abortController.signal,
         });
-
-        execResults = { status: 'success', output: result };
+        const endedAt = Date.now();
+
+        execResults = {
+          status: 'success',
+          output: result,
+          startedAt,
+          endedAt,
+          payload: prevOutput,
+          resumedAt: resume?.steps[0] === step.id ? startedAt : undefined,
+          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : undefined,
+        };
       } catch (e) {
-        execResults = { status: 'failed', error: e instanceof Error ? e.message : String(e) };
+        execResults = {
+          status: 'failed',
+          payload: prevOutput,
+          error: e instanceof Error ? e.message : String(e),
+          endedAt: Date.now(),
+          startedAt,
+          resumedAt: resume?.steps[0] === step.id ? startedAt : undefined,
+          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : undefined,
+        };
       }
 
       if (suspended) {
-        execResults = { status: 'suspended', payload: suspended.payload };
+        execResults = {
+          status: 'suspended',
+          suspendedPayload: suspended.payload,
+          payload: prevOutput,
+          suspendedAt: Date.now(),
+          startedAt,
+          resumedAt: resume?.steps[0] === step.id ? startedAt : undefined,
+          resumePayload: resume?.steps[0] === step.id ? resume?.resumePayload : undefined,
+        };
+      } else if (bailed) {
+        execResults = { status: 'bailed', output: bailed.payload, payload: prevOutput, 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;
         }
       }
 
@@ -788,12 +1595,11 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
         payload: {
           currentStep: {
             id: step.id,
-            status: execResults.status,
-            output: execResults.output,
+            ...execResults,
           },
           workflowState: {
             status: 'running',
-            steps: stepResults,
+            steps: { ...stepResults, [step.id]: execResults },
             result: null,
             error: null,
           },
@@ -801,9 +1607,54 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
         eventTimestamp: Date.now(),
       });
 
+      if (execResults.status === 'suspended') {
+        await emitter.emit('watch-v2', {
+          type: 'step-suspended',
+          payload: {
+            id: step.id,
+            ...execResults,
+          },
+        });
+      } else {
+        await emitter.emit('watch-v2', {
+          type: 'step-result',
+          payload: {
+            id: step.id,
+            ...execResults,
+          },
+        });
+
+        await emitter.emit('watch-v2', {
+          type: '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: prevOutput,
+            output: stepRes.result,
+            workflowId: executionContext.workflowId,
+            stepId: step.id,
+            runtimeContext,
+            disableScorers,
+          });
+        }
+      });
+    }
+
     // @ts-ignore
     Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
     // @ts-ignore
@@ -818,11 +1669,20 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     runId,
     stepResults,
     executionContext,
+    serializedStepGraph,
+    workflowStatus,
+    result,
+    error,
   }: {
     workflowId: string;
     runId: string;
-    stepResults: Record<string, StepResult<any>>;
+    stepResults: Record<string, StepResult<any, any, any, any>>;
+    serializedStepGraph: SerializedStepFlowEntry[];
     executionContext: ExecutionContext;
+    workflowStatus: 'success' | 'failed' | 'suspended' | 'running';
+    result?: Record<string, any>;
+    error?: string | Error;
+    runtimeContext: RuntimeContext;
   }) {
     await this.inngestStep.run(
       `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
@@ -836,6 +1696,11 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             context: stepResults as any,
             activePaths: [],
             suspendedPaths: executionContext.suspendedPaths,
+            waitingPaths: {},
+            serializedStepGraph,
+            status: workflowStatus,
+            result,
+            error,
             // @ts-ignore
             timestamp: Date.now(),
           },
@@ -851,37 +1716,75 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     prevOutput,
     prevStep,
     stepResults,
+    serializedStepGraph,
     resume,
     executionContext,
     emitter,
+    abortController,
     runtimeContext,
+    writableStream,
+    disableScorers,
+    tracingContext,
   }: {
     workflowId: string;
     runId: string;
-    entry: { type: 'conditional'; steps: StepFlowEntry[]; conditions: ExecuteFunction<any, any, any, any>[] };
+    entry: {
+      type: 'conditional';
+      steps: StepFlowEntry[];
+      conditions: ExecuteFunction<any, any, any, any, InngestEngineType>[];
+    };
     prevStep: StepFlowEntry;
+    serializedStepGraph: SerializedStepFlowEntry[];
     prevOutput: any;
-    stepResults: Record<string, StepResult<any>>;
+    stepResults: Record<string, StepResult<any, any, any, any>>;
     resume?: {
       steps: string[];
-      stepResults: Record<string, StepResult<any>>;
+      stepResults: Record<string, StepResult<any, any, any, any>>;
       resumePayload: any;
       resumePath: number[];
     };
     executionContext: ExecutionContext;
-    emitter: { emit: (event: string, data: any) => Promise<void> };
+    emitter: Emitter;
+    abortController: AbortController;
     runtimeContext: RuntimeContext;
-  }): Promise<StepResult<any>> {
+    writableStream?: WritableStream<ChunkType>;
+    disableScorers?: boolean;
+    tracingContext?: TracingContext;
+  }): Promise<StepResult<any, any, any, any>> {
+    const conditionalSpan = tracingContext?.currentSpan?.createChildSpan({
+      type: AISpanType.WORKFLOW_CONDITIONAL,
+      name: `conditional: ${entry.conditions.length} conditions`,
+      input: prevOutput,
+      attributes: {
+        conditionCount: entry.conditions.length,
+      },
+    });
+
     let execResults: any;
     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,
+              },
+            });
+
             try {
               const result = await cond({
+                runId,
+                workflowId,
                 mastra: this.mastra!,
                 runtimeContext,
+                runCount: -1,
                 inputData: prevOutput,
+                tracingContext: {
+                  currentSpan: evalSpan,
+                },
                 getInitData: () => stepResults?.input as any,
                 getStepResult: (step: any) => {
                   if (!step?.id) {
@@ -898,11 +1801,42 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
 
                 // TODO: this function shouldn't have suspend probably?
                 suspend: async (_suspendPayload: any) => {},
-                emitter,
+                bail: () => {},
+                abort: () => {
+                  abortController.abort();
+                },
+                [EMITTER_SYMBOL]: emitter,
+                engine: {
+                  step: this.inngestStep,
+                },
+                abortSignal: abortController.signal,
+                writer: new ToolStream(
+                  {
+                    prefix: 'step',
+                    callId: randomUUID(),
+                    name: 'conditional',
+                    runId,
+                  },
+                  writableStream,
+                ),
               });
+
+              evalSpan?.end({
+                output: result,
+                attributes: {
+                  result: !!result,
+                },
+              });
+
               return result ? index : null;
-              // eslint-disable-next-line @typescript-eslint/no-unused-vars
             } catch (e: unknown) {
+              evalSpan?.error({
+                error: e instanceof Error ? e : new Error(String(e)),
+                attributes: {
+                  result: false,
+                },
+              });
+
               return null;
             }
           }),
@@ -911,12 +1845,22 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     ).filter((index: any): index is number => index !== null);
 
     const stepsToRun = entry.steps.filter((_, index) => truthyIndexes.includes(index));
-    const results: StepResult<any>[] = await Promise.all(
+
+    // Update conditional span with evaluation results
+    conditionalSpan?.update({
+      attributes: {
+        truthyIndexes,
+        selectedSteps: stepsToRun.map(s => (s.type === 'step' ? s.step.id : `control-${s.type}`)),
+      },
+    });
+
+    const results: { result: StepResult<any, any, any, any> }[] = await Promise.all(
       stepsToRun.map((step, index) =>
         this.executeEntry({
           workflowId,
           runId,
           entry: step,
+          serializedStepGraph,
           prevStep,
           stepResults,
           resume,
@@ -929,21 +1873,29 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             executionSpan: executionContext.executionSpan,
           },
           emitter,
+          abortController,
           runtimeContext,
+          writableStream,
+          disableScorers,
+          tracingContext: {
+            currentSpan: conditionalSpan,
+          },
         }),
       ),
     );
-    const hasFailed = results.find(result => result.status === 'failed');
-    const hasSuspended = results.find(result => result.status === 'suspended');
+    const hasFailed = results.find(result => result.result.status === 'failed') as {
+      result: StepFailure<any, any, any>;
+    };
+    const hasSuspended = results.find(result => result.result.status === 'suspended');
     if (hasFailed) {
-      execResults = { status: 'failed', error: hasFailed.error };
+      execResults = { status: 'failed', error: hasFailed.result.error };
     } else if (hasSuspended) {
-      execResults = { status: 'suspended', payload: hasSuspended.payload };
+      execResults = { status: 'suspended', payload: hasSuspended.result.suspendPayload };
     } else {
       execResults = {
         status: 'success',
         output: results.reduce((acc: Record<string, any>, result, index) => {
-          if (result.status === 'success') {
+          if (result.result.status === 'success') {
             // @ts-ignore
             acc[stepsToRun[index]!.step.id] = result.output;
           }
@@ -953,6 +1905,16 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
       };
     }
 
+    if (execResults.status === 'failed') {
+      conditionalSpan?.error({
+        error: new Error(execResults.error),
+      });
+    } else {
+      conditionalSpan?.end({
+        output: execResults.output || execResults,
+      });
+    }
+
     return execResults;
   }
 }