@mastra/inngest 0.0.0-course-20250527170450 → 0.0.0-fix-generate-title-20250616171351

package/src/index.ts

@@ -1,8 +1,9 @@
 import { randomUUID } from 'crypto';
 import { subscribe } from '@inngest/realtime';
-import type { Mastra, WorkflowRun, WorkflowRuns } from '@mastra/core';
+import { Agent, Tool } from '@mastra/core';
+import type { Mastra, ToolExecutionContext, WorkflowRun, WorkflowRuns } from '@mastra/core';
 import { RuntimeContext } from '@mastra/core/di';
-import { Workflow, createStep, Run, DefaultExecutionEngine, cloneStep } from '@mastra/core/workflows';
+import { Workflow, Run, DefaultExecutionEngine } from '@mastra/core/workflows';
 import type {
   ExecuteFunction,
   ExecutionContext,
@@ -13,12 +14,19 @@ import type {
   StepFlowEntry,
   StepResult,
   WorkflowResult,
+  SerializedStepFlowEntry,
+  StepFailure,
+  WatchEvent,
 } 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.getWorkflows();
@@ -36,11 +44,13 @@ export function serve({ mastra, inngest }: { mastra: Mastra; inngest: Inngest })
 }
 
 export class InngestRun<
+  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 +59,7 @@ export class InngestRun<
       runId: string;
       executionEngine: ExecutionEngine;
       executionGraph: ExecutionGraph;
+      serializedStepGraph: SerializedStepFlowEntry[];
       mastra?: Mastra;
       retryConfig?: {
         attempts?: number;
@@ -60,11 +71,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}`,
       },
@@ -96,11 +108,13 @@ export class InngestRun<
       runId: this.runId,
       snapshot: {
         runId: this.runId,
+        serializedStepGraph: this.serializedStepGraph,
         value: {},
         context: {} as any,
         activePaths: [],
         suspendedPaths: {},
         timestamp: Date.now(),
+        status: 'running',
       },
     });
 
@@ -196,12 +210,13 @@ export class InngestRun<
 }
 
 export class InngestWorkflow<
+  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 Workflow<TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {
+> extends Workflow<TEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {
   #mastra: Mastra;
   public inngest: Inngest;
 
@@ -233,7 +248,10 @@ export class InngestWorkflow<
     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 WorkflowRun;
 
@@ -243,6 +261,32 @@ export class InngestWorkflow<
     );
   }
 
+  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);
@@ -266,11 +310,11 @@ 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<TSteps, TInput, TOutput> =
+    const run: Run<TEngineType, TSteps, TInput, TOutput> =
       this.runs.get(runIdToUse) ??
       new InngestRun(
         {
@@ -278,6 +322,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),
@@ -329,6 +374,7 @@ export class InngestWorkflow<
           workflowId: this.id,
           runId,
           graph: this.executionGraph,
+          serializedStepGraph: this.serializedStepGraph,
           input: inputData,
           emitter,
           retryConfig: this.retryConfig,
@@ -362,29 +408,185 @@ 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>[],
+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 (params instanceof Agent) {
+    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 }) => {
+        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,
+          onFinish: result => {
+            streamPromise.resolve(result.text);
+          },
+        });
 
-  wf.setStepFlow(workflow.stepGraph);
-  wf.commit();
-  return wf;
+        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 (params instanceof Tool) {
+    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 }) => {
+        return params.execute({
+          context: inputData,
+          mastra,
+          runtimeContext,
+        });
+      },
+    };
+  }
+
+  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) {
@@ -393,13 +595,58 @@ 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>[],
+      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(params, inngest);
+      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
+      >[],
+    >(
+      workflow: Workflow<InngestEngineType, TSteps, string, TInput, TOutput, TInput>,
+      opts: { id: TWorkflowId },
+    ): Workflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TInput> {
+      const wf = new Workflow({
+        id: opts.id,
+        inputSchema: workflow.inputSchema,
+        outputSchema: workflow.outputSchema,
+        steps: workflow.stepDefs,
+        mastra: workflow.mastra,
+      });
+
+      wf.setStepFlow(workflow.stepGraph);
+      wf.commit();
+      return wf;
+    },
   };
 }
 
@@ -524,6 +771,10 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     });
   }
 
+  async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
+    await this.inngestStep.sleep(id, duration);
+  }
+
   async executeStep({
     step,
     stepResults,
@@ -740,6 +991,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
       let suspended: { payload: any } | undefined;
       try {
         const result = await step.execute({
+          runId: executionContext.runId,
           mastra: this.mastra!,
           runtimeContext,
           inputData: prevOutput,
@@ -763,7 +1015,10 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             // @ts-ignore
             runId: stepResults[step.id]?.payload?.__workflow_meta?.runId,
           },
-          emitter,
+          [EMITTER_SYMBOL]: emitter,
+          engine: {
+            step: this.inngestStep,
+          },
         });
 
         execResults = { status: 'success', output: result };
@@ -816,11 +1071,19 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     runId,
     stepResults,
     executionContext,
+    serializedStepGraph,
+    workflowStatus,
+    result,
+    error,
   }: {
     workflowId: string;
     runId: string;
     stepResults: Record<string, StepResult<any, any, any, any>>;
+    serializedStepGraph: SerializedStepFlowEntry[];
     executionContext: ExecutionContext;
+    workflowStatus: 'success' | 'failed' | 'suspended' | 'running';
+    result?: Record<string, any>;
+    error?: string | Error;
   }) {
     await this.inngestStep.run(
       `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
@@ -834,6 +1097,10 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             context: stepResults as any,
             activePaths: [],
             suspendedPaths: executionContext.suspendedPaths,
+            serializedStepGraph,
+            status: workflowStatus,
+            result,
+            error,
             // @ts-ignore
             timestamp: Date.now(),
           },
@@ -849,6 +1116,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     prevOutput,
     prevStep,
     stepResults,
+    serializedStepGraph,
     resume,
     executionContext,
     emitter,
@@ -856,8 +1124,13 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
   }: {
     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, any, any, any>>;
     resume?: {
@@ -877,6 +1150,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           this.inngestStep.run(`workflow.${workflowId}.conditional.${index}`, async () => {
             try {
               const result = await cond({
+                runId,
                 mastra: this.mastra!,
                 runtimeContext,
                 inputData: prevOutput,
@@ -897,6 +1171,9 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
                 // TODO: this function shouldn't have suspend probably?
                 suspend: async (_suspendPayload: any) => {},
                 [EMITTER_SYMBOL]: emitter,
+                engine: {
+                  step: this.inngestStep,
+                },
               });
               return result ? index : null;
               // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -909,7 +1186,7 @@ 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, any, any, any>[] = await Promise.all(
+    const results: { result: StepResult<any, any, any, any> }[] = await Promise.all(
       stepsToRun.map((step, index) =>
         this.executeEntry({
           workflowId,
@@ -918,6 +1195,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           prevStep,
           stepResults,
           resume,
+          serializedStepGraph,
           executionContext: {
             workflowId,
             runId,
@@ -931,17 +1209,19 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
         }),
       ),
     );
-    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.payload };
     } 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;
           }