@mastra/inngest 0.0.0-vnext-inngest-20250506123700

package/src/index.ts

@@ -0,0 +1,898 @@
+import {
+  NewWorkflow,
+  type NewStep as Step,
+  DefaultExecutionEngine,
+  Run,
+  cloneStep,
+} from '@mastra/core/workflows/vNext';
+import type {
+  ExecuteFunction,
+  ExecutionContext,
+  ExecutionEngine,
+  ExecutionGraph,
+  NewStep,
+  NewWorkflowConfig,
+  StepFlowEntry,
+  StepResult,
+  WorkflowResult,
+} from '@mastra/core/workflows/vNext';
+import { type Span } from '@opentelemetry/api';
+import { Inngest, type BaseContext } from 'inngest';
+import { subscribe } from '@inngest/realtime';
+import { serve as inngestServe } from 'inngest/hono';
+import { type Mastra } from '@mastra/core';
+import type { z } from 'zod';
+import { RuntimeContext } from '@mastra/core/di';
+import { randomUUID } from 'crypto';
+
+import { createStep } from '@mastra/core/workflows/vNext';
+
+export function serve({ mastra, ingest }: { mastra: Mastra; ingest: Inngest }): ReturnType<typeof inngestServe> {
+  const wfs = mastra.vnext_getWorkflows();
+  const functions = Object.values(wfs).flatMap(wf => {
+    if (wf instanceof InngestWorkflow) {
+      return wf.getFunctions();
+    }
+    return [];
+  });
+  return inngestServe({
+    client: ingest,
+    functions,
+  });
+}
+
+export class InngestRun<
+  TSteps extends NewStep<string, any, any>[] = NewStep<string, any, any>[],
+  TInput extends z.ZodType<any> = z.ZodType<any>,
+  TOutput extends z.ZodType<any> = z.ZodType<any>,
+> extends Run<TSteps, TInput, TOutput> {
+  private inngest: Inngest;
+  #mastra: Mastra;
+
+  constructor(
+    params: {
+      workflowId: string;
+      runId: string;
+      executionEngine: ExecutionEngine;
+      executionGraph: ExecutionGraph;
+      mastra?: Mastra;
+      retryConfig?: {
+        attempts?: number;
+        delay?: number;
+      };
+    },
+    inngest: Inngest,
+  ) {
+    super(params);
+    this.inngest = inngest;
+    this.#mastra = params.mastra!;
+  }
+
+  async getRuns(eventId: string) {
+    const response = await fetch(`${this.inngest.apiBaseUrl}/v1/events/${eventId}/runs`, {
+      headers: {
+        Authorization: `Bearer ${process.env.INNGEST_SIGNING_KEY}`,
+      },
+    });
+    const json = await response.json();
+    return (json as any).data;
+  }
+
+  async getRunOutput(eventId: string) {
+    let runs = await this.getRuns(eventId);
+    while (runs?.[0]?.status !== 'Completed') {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      runs = await this.getRuns(eventId);
+      if (runs?.[0]?.status === 'Failed' || runs?.[0]?.status === 'Cancelled') {
+        throw new Error(`Function run ${runs?.[0]?.status}`);
+      }
+    }
+    return runs?.[0];
+  }
+
+  async start({
+    inputData,
+    runtimeContext,
+  }: {
+    inputData?: z.infer<TInput>;
+    runtimeContext?: RuntimeContext;
+  }): Promise<WorkflowResult<TOutput, TSteps>> {
+    const eventOutput = await this.inngest.send({
+      name: `workflow.${this.workflowId}`,
+      data: {
+        inputData,
+        runId: this.runId,
+      },
+    });
+
+    const eventId = eventOutput.ids[0];
+    if (!eventId) {
+      throw new Error('Event ID is not set');
+    }
+    const runOutput = await this.getRunOutput(eventId);
+    const result = runOutput?.output?.result;
+    if (result.status === 'failed') {
+      result.error = new Error(result.error);
+    }
+    return result;
+  }
+
+  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,
+    );
+    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId,
+    });
+
+    const eventOutput = await this.inngest.send({
+      name: `workflow.${this.workflowId}`,
+      data: {
+        inputData: params.resumeData,
+        runId: this.runId,
+        stepResults: snapshot?.context as any,
+        resume: {
+          steps,
+          stepResults: snapshot?.context as any,
+          resumePayload: params.resumeData,
+          // @ts-ignore
+          resumePath: snapshot?.suspendedPaths?.[steps?.[0]] as any,
+        },
+      },
+    });
+
+    const eventId = eventOutput.ids[0];
+    if (!eventId) {
+      throw new Error('Event ID is not set');
+    }
+    const runOutput = await this.getRunOutput(eventId);
+    const result = runOutput?.output?.result;
+    if (result.status === 'failed') {
+      result.error = new Error(result.error);
+    }
+    return result;
+  }
+
+  watch(cb: (event: any) => void): () => void {
+    const streamPromise = subscribe(
+      {
+        channel: `workflow:${this.workflowId}:${this.runId}`,
+        topics: ['watch'],
+        app: this.inngest,
+      },
+      (message: any) => {
+        cb(message.data);
+      },
+    );
+
+    return () => {
+      streamPromise.then((stream: any) => {
+        stream.cancel();
+      });
+    };
+  }
+}
+
+export class InngestWorkflow<
+  TSteps extends NewStep<string, any, any>[] = NewStep<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> {
+  #mastra: Mastra;
+  public inngest: Inngest;
+
+  private function: ReturnType<Inngest['createFunction']> | undefined;
+
+  constructor(params: NewWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest) {
+    super(params);
+    this.#mastra = params.mastra!;
+    this.inngest = inngest;
+  }
+
+  __registerMastra(mastra: Mastra) {
+    this.#mastra = mastra;
+    this.executionEngine.__registerMastra(mastra);
+
+    if (this.executionGraph.steps.length) {
+      for (const step of this.executionGraph.steps) {
+        if (step.type === 'step' && step.step instanceof InngestWorkflow) {
+          step.step.__registerMastra(mastra);
+        }
+      }
+    }
+  }
+
+  createRun(options?: { runId?: string }): Run<TSteps, TInput, TOutput> {
+    const runIdToUse = options?.runId || randomUUID();
+
+    // Return a new Run instance with object parameters
+    return new InngestRun(
+      {
+        workflowId: this.id,
+        runId: runIdToUse,
+        executionEngine: this.executionEngine,
+        executionGraph: this.executionGraph,
+        mastra: this.#mastra,
+        retryConfig: this.retryConfig,
+      },
+      this.inngest,
+    );
+  }
+
+  getFunction() {
+    if (this.function) {
+      return this.function;
+    }
+    this.function = this.inngest.createFunction(
+      // @ts-ignore
+      { id: `workflow.${this.id}`, retries: this.retryConfig?.attempts ?? 0 },
+      { event: `workflow.${this.id}` },
+      async ({ event, step, attempt, publish }) => {
+        let { inputData, runId, resume } = event.data;
+
+        if (!runId) {
+          runId = await step.run(`workflow.${this.id}.runIdGen`, async () => {
+            return randomUUID();
+          });
+        }
+
+        const emitter = {
+          emit: async (event: string, data: any) => {
+            if (!publish) {
+              return;
+            }
+
+            try {
+              await publish({
+                channel: `workflow:${this.id}:${runId}`,
+                topic: 'watch',
+                data,
+              });
+            } catch (err: any) {
+              this.logger.error('Error emitting event: ' + (err?.stack ?? err?.message ?? err));
+            }
+          },
+        };
+
+        const engine = new InngestExecutionEngine(this.#mastra, step, attempt);
+        const result = await engine.execute<z.infer<TInput>, WorkflowResult<TOutput, TSteps>>({
+          workflowId: this.id,
+          runId,
+          graph: this.executionGraph,
+          input: inputData,
+          emitter,
+          retryConfig: this.retryConfig,
+          runtimeContext: new RuntimeContext(), // TODO
+          resume,
+        });
+
+        return { result, runId };
+      },
+    );
+    return this.function;
+  }
+
+  getNestedFunctions(steps: StepFlowEntry[]): ReturnType<Inngest['createFunction']>[] {
+    return steps.flatMap(step => {
+      if (step.type === 'step' || step.type === 'loop' || step.type === 'foreach') {
+        if (step.step instanceof InngestWorkflow) {
+          return [step.step.getFunction(), ...step.step.getNestedFunctions(step.step.executionGraph.steps)];
+        }
+        return [];
+      } else if (step.type === 'parallel' || step.type === 'conditional') {
+        return this.getNestedFunctions(step.steps);
+      }
+
+      return [];
+    });
+  }
+
+  getFunctions() {
+    return [this.getFunction(), ...this.getNestedFunctions(this.executionGraph.steps)];
+  }
+}
+
+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>[],
+>(
+  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,
+  );
+
+  wf.setStepFlow(workflow.stepGraph);
+  wf.commit();
+  return wf;
+}
+
+export function init(inngest: Inngest) {
+  return {
+    createWorkflow<
+      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);
+    },
+    createStep,
+    cloneStep,
+    cloneWorkflow,
+  };
+}
+
+export class InngestExecutionEngine extends DefaultExecutionEngine {
+  private inngestStep: BaseContext<Inngest>['step'];
+  private inngestAttempts: number;
+
+  constructor(mastra: Mastra, inngestStep: BaseContext<Inngest>['step'], inngestAttempts: number = 0) {
+    super({ mastra });
+    this.inngestStep = inngestStep;
+    this.inngestAttempts = inngestAttempts;
+  }
+
+  protected async fmtReturnValue<TOutput>(
+    executionSpan: Span | undefined,
+    emitter: { emit: (event: string, data: any) => Promise<void> },
+    stepResults: Record<string, StepResult<any>>,
+    lastOutput: StepResult<any>,
+    error?: Error | string,
+  ): Promise<TOutput> {
+    const base: any = {
+      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;
+          return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
+        }
+
+        return [];
+      });
+      base.suspended = suspendedStepIds;
+    }
+
+    executionSpan?.end();
+    return base as TOutput;
+  }
+
+  async superExecuteStep({
+    workflowId,
+    runId,
+    step,
+    stepResults,
+    executionContext,
+    resume,
+    prevOutput,
+    emitter,
+    runtimeContext,
+  }: {
+    workflowId: string;
+    runId: string;
+    step: Step<string, any, any>;
+    stepResults: Record<string, StepResult<any>>;
+    executionContext: ExecutionContext;
+    resume?: {
+      steps: string[];
+      resumePayload: any;
+    };
+    prevOutput: any;
+    emitter: { emit: (event: string, data: any) => Promise<void> };
+    runtimeContext: RuntimeContext;
+  }): Promise<StepResult<any>> {
+    return super.executeStep({
+      workflowId,
+      runId,
+      step,
+      stepResults,
+      executionContext,
+      resume,
+      prevOutput,
+      emitter,
+      runtimeContext,
+    });
+  }
+
+  async executeStep({
+    step,
+    stepResults,
+    executionContext,
+    resume,
+    prevOutput,
+    emitter,
+    runtimeContext,
+  }: {
+    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 };
+    };
+    resume?: {
+      steps: string[];
+      resumePayload: any;
+      runId?: string;
+    };
+    prevOutput: any;
+    emitter: { emit: (event: string, data: any) => Promise<void> };
+    runtimeContext: RuntimeContext;
+  }): Promise<StepResult<any>> {
+    await this.inngestStep.run(
+      `workflow.${executionContext.workflowId}.run.${executionContext.runId}.step.${step.id}.running_ev`,
+      async () => {
+        await emitter.emit('watch', {
+          type: 'watch',
+          payload: {
+            currentStep: {
+              id: step.id,
+              status: 'running',
+            },
+            workflowState: {
+              status: 'running',
+              steps: {
+                ...stepResults,
+                [step.id]: {
+                  status: 'running',
+                },
+              },
+              result: null,
+              error: null,
+            },
+          },
+          eventTimestamp: Date.now(),
+        });
+      },
+    );
+
+    if (step instanceof InngestWorkflow) {
+      const isResume = !!resume?.steps?.length;
+      let result: WorkflowResult<any, any>;
+      let runId: string;
+      if (isResume) {
+        // @ts-ignore
+        runId = stepResults[resume?.steps?.[0]]?.payload?.__workflow_meta?.runId ?? randomUUID();
+
+        const snapshot: any = await this.mastra?.getStorage()?.loadWorkflowSnapshot({
+          workflowName: step.id,
+          runId: runId,
+        });
+
+        const invokeResp = (await this.inngestStep.invoke(`workflow.${executionContext.workflowId}.step.${step.id}`, {
+          function: step.getFunction(),
+          data: {
+            inputData: prevOutput,
+            runId: runId,
+            resume: {
+              runId: runId,
+              steps: resume.steps.slice(1),
+              stepResults: snapshot?.context as any,
+              resumePayload: resume.resumePayload,
+              // @ts-ignore
+              resumePath: snapshot?.suspendedPaths?.[resume.steps?.[1]] as any,
+            },
+          },
+        })) as any;
+        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,
+          },
+        })) as any;
+        result = invokeResp.result;
+        runId = invokeResp.runId;
+      }
+
+      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',
+              payload: {
+                currentStep: {
+                  id: step.id,
+                  status: 'failed',
+                  error: result?.error,
+                },
+                workflowState: {
+                  status: 'running',
+                  steps: stepResults,
+                  result: null,
+                  error: null,
+                },
+              },
+              eventTimestamp: Date.now(),
+            });
+
+            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>;
+              return stepRes?.status === 'suspended';
+            });
+
+            for (const [stepName, stepResult] of suspendedSteps) {
+              // @ts-ignore
+              const suspendPath: string[] = [stepName, ...(stepResult?.payload?.__workflow_meta?.path ?? [])];
+              executionContext.suspendedPaths[step.id] = executionContext.executionPath;
+
+              await emitter.emit('watch', {
+                type: 'watch',
+                payload: {
+                  currentStep: {
+                    id: step.id,
+                    status: 'suspended',
+                    payload: { ...(stepResult as any)?.payload, __workflow_meta: { runId: runId, path: suspendPath } },
+                  },
+                  workflowState: {
+                    status: 'running',
+                    steps: stepResults,
+                    result: null,
+                    error: null,
+                  },
+                },
+                eventTimestamp: Date.now(),
+              });
+
+              return {
+                executionContext,
+                result: {
+                  status: 'suspended',
+                  payload: { ...(stepResult as any)?.payload, __workflow_meta: { runId: 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: {
+                status: 'suspended',
+                payload: {},
+              },
+            };
+          }
+
+          // is success
+
+          await emitter.emit('watch', {
+            type: 'watch',
+            payload: {
+              currentStep: {
+                id: step.id,
+                status: 'success',
+                output: result?.result,
+              },
+              workflowState: {
+                status: 'running',
+                steps: stepResults,
+                result: null,
+                error: null,
+              },
+            },
+            eventTimestamp: Date.now(),
+          });
+
+          return { executionContext, result: { status: 'success', output: result?.result } };
+        },
+      );
+
+      Object.assign(executionContext, res.executionContext);
+      return res.result as StepResult<any>;
+    }
+
+    const stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
+      let execResults: any;
+      let suspended: { payload: any } | undefined;
+      try {
+        const result = await step.execute({
+          mastra: this.mastra!,
+          runtimeContext,
+          inputData: prevOutput,
+          resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : undefined,
+          getInitData: () => stepResults?.input as any,
+          getStepResult: (step: any) => {
+            const result = stepResults[step.id];
+            if (result?.status === 'success') {
+              return result.output;
+            }
+
+            return null;
+          },
+          suspend: async (suspendPayload: any) => {
+            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;
+        }
+      }
+
+      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(),
+      });
+
+      return { result: execResults, executionContext, stepResults };
+    });
+
+    // @ts-ignore
+    Object.assign(executionContext.suspendedPaths, stepRes.executionContext.suspendedPaths);
+    // @ts-ignore
+    Object.assign(stepResults, stepRes.stepResults);
+
+    // @ts-ignore
+    return stepRes.result;
+  }
+
+  async persistStepUpdate({
+    workflowId,
+    runId,
+    stepResults,
+    executionContext,
+  }: {
+    workflowId: string;
+    runId: string;
+    stepResults: Record<string, StepResult<any>>;
+    executionContext: ExecutionContext;
+  }) {
+    await this.inngestStep.run(
+      `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
+      async () => {
+        await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+          workflowName: workflowId,
+          runId,
+          snapshot: {
+            runId,
+            value: {},
+            context: stepResults as any,
+            activePaths: [],
+            suspendedPaths: executionContext.suspendedPaths,
+            // @ts-ignore
+            timestamp: Date.now(),
+          },
+        });
+      },
+    );
+  }
+
+  async executeConditional({
+    workflowId,
+    runId,
+    entry,
+    prevOutput,
+    prevStep,
+    stepResults,
+    resume,
+    executionContext,
+    emitter,
+    runtimeContext,
+  }: {
+    workflowId: string;
+    runId: string;
+    entry: { type: 'conditional'; steps: StepFlowEntry[]; conditions: ExecuteFunction<any, any, any, any>[] };
+    prevStep: StepFlowEntry;
+    prevOutput: any;
+    stepResults: Record<string, StepResult<any>>;
+    resume?: {
+      steps: string[];
+      stepResults: Record<string, StepResult<any>>;
+      resumePayload: any;
+      resumePath: number[];
+    };
+    executionContext: ExecutionContext;
+    emitter: { emit: (event: string, data: any) => Promise<void> };
+    runtimeContext: RuntimeContext;
+  }): Promise<StepResult<any>> {
+    let execResults: any;
+    const truthyIndexes = (
+      await Promise.all(
+        entry.conditions.map((cond, index) =>
+          this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
+            try {
+              const result = await cond({
+                mastra: this.mastra!,
+                runtimeContext,
+                inputData: prevOutput,
+                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) => {},
+                emitter,
+              });
+              return result ? index : null;
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            } catch (e: unknown) {
+              e;
+              return null;
+            }
+          }),
+        ),
+      )
+    ).filter((index: any): index is number => index !== null);
+
+    const stepsToRun = entry.steps.filter((_, index) => truthyIndexes.includes(index));
+    const results: StepResult<any>[] = await Promise.all(
+      stepsToRun.map((step, index) =>
+        this.executeEntry({
+          workflowId,
+          runId,
+          entry: step,
+          prevStep,
+          stepResults,
+          resume,
+          executionContext: {
+            workflowId,
+            runId,
+            executionPath: [...executionContext.executionPath, index],
+            suspendedPaths: executionContext.suspendedPaths,
+            retryConfig: executionContext.retryConfig,
+            executionSpan: executionContext.executionSpan,
+          },
+          emitter,
+          runtimeContext,
+        }),
+      ),
+    );
+    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 };
+    } else {
+      execResults = {
+        status: 'success',
+        output: results.reduce((acc: Record<string, any>, result, index) => {
+          if (result.status === 'success') {
+            // @ts-ignore
+            acc[stepsToRun[index]!.step.id] = result.output;
+          }
+
+          return acc;
+        }, {}),
+      };
+    }
+
+    return execResults;
+  }
+}