@mastra/inngest 0.11.10 → 0.12.0-alpha.1

package/src/index.ts

@@ -1,8 +1,13 @@
 import { randomUUID } from 'crypto';
 import type { ReadableStream } from 'node:stream/web';
 import { subscribe } from '@inngest/realtime';
-import type { Agent, Mastra, ToolExecutionContext, WorkflowRun, WorkflowRuns } 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 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 {
@@ -160,6 +165,7 @@ export class InngestRun<
         context: {} as any,
         activePaths: [],
         suspendedPaths: {},
+        waitingPaths: {},
         timestamp: Date.now(),
         status: 'running',
       },
@@ -483,6 +489,7 @@ export class InngestWorkflow<
           value: {},
           context: {},
           activePaths: [],
+          waitingPaths: {},
           serializedStepGraph: this.serializedStepGraph,
           suspendedPaths: {},
           result: undefined,
@@ -556,6 +563,7 @@ export class InngestWorkflow<
           runtimeContext: new RuntimeContext(), // TODO
           resume,
           abortController: new AbortController(),
+          currentSpan: undefined, // TODO: Pass actual parent AI span from workflow execution context
         });
 
         return { result, runId };
@@ -678,7 +686,7 @@ export function createStep<
       outputSchema: z.object({
         text: z.string(),
       }),
-      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort }) => {
+      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort, tracingContext }) => {
         let streamPromise = {} as {
           promise: Promise<string>;
           resolve: (value: string) => void;
@@ -701,6 +709,7 @@ export function createStep<
           // resourceId: inputData.resourceId,
           // threadId: inputData.threadId,
           runtimeContext,
+          tracingContext,
           onFinish: result => {
             streamPromise.resolve(result.text);
           },
@@ -756,11 +765,12 @@ export function createStep<
       id: params.id,
       inputSchema: params.inputSchema,
       outputSchema: params.outputSchema,
-      execute: async ({ inputData, mastra, runtimeContext }) => {
+      execute: async ({ inputData, mastra, runtimeContext, tracingContext }) => {
         return params.execute({
           context: inputData,
-          mastra,
+          mastra: wrapMastra(mastra, tracingContext),
           runtimeContext,
+          tracingContext,
         });
       },
     };
@@ -869,6 +879,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     };
     runtimeContext: RuntimeContext;
     abortController: AbortController;
+    currentSpan?: AnyAISpan;
   }): Promise<TOutput> {
     await params.emitter.emit('watch-v2', {
       type: 'start',
@@ -959,49 +970,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     return base as TOutput;
   }
 
-  async superExecuteStep({
-    workflowId,
-    runId,
-    step,
-    stepResults,
-    executionContext,
-    resume,
-    prevOutput,
-    emitter,
-    abortController,
-    runtimeContext,
-    writableStream,
-  }: {
-    workflowId: string;
-    runId: string;
-    step: Step<string, any, any>;
-    stepResults: Record<string, StepResult<any, any, any, any>>;
-    executionContext: ExecutionContext;
-    resume?: {
-      steps: string[];
-      resumePayload: any;
-    };
-    prevOutput: any;
-    emitter: Emitter;
-    abortController: AbortController;
-    runtimeContext: RuntimeContext;
-    writableStream?: WritableStream<ChunkType>;
-  }): Promise<StepResult<any, any, any, any>> {
-    return super.executeStep({
-      workflowId,
-      runId,
-      step,
-      stepResults,
-      executionContext,
-      resume,
-      prevOutput,
-      emitter,
-      abortController,
-      runtimeContext,
-      writableStream,
-    });
-  }
-
   // async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
   //   await this.inngestStep.sleep(id, duration);
   // }
@@ -1016,6 +984,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController,
     runtimeContext,
     writableStream,
+    tracingContext,
   }: {
     workflowId: string;
     runId: string;
@@ -1040,9 +1009,19 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     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 () => {
@@ -1053,6 +1032,9 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           runtimeContext,
           inputData: prevOutput,
           runCount: -1,
+          tracingContext: {
+            currentSpan: sleepSpan,
+          },
           getInitData: () => stepResults?.input as any,
           getStepResult: (step: any) => {
             if (!step?.id) {
@@ -1087,9 +1069,22 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           ),
         });
       });
+
+      // Update sleep span with dynamic duration
+      sleepSpan?.update({
+        attributes: {
+          durationMs: duration,
+        },
+      });
     }
 
-    await this.inngestStep.sleep(entry.id, !duration || duration < 0 ? 0 : 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({
@@ -1102,6 +1097,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController,
     runtimeContext,
     writableStream,
+    tracingContext,
   }: {
     workflowId: string;
     runId: string;
@@ -1126,9 +1122,20 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController: AbortController;
     runtimeContext: 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();
@@ -1139,6 +1146,9 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           runtimeContext,
           inputData: prevOutput,
           runCount: -1,
+          tracingContext: {
+            currentSpan: sleepUntilSpan,
+          },
           getInitData: () => stepResults?.input as any,
           getStepResult: (step: any) => {
             if (!step?.id) {
@@ -1173,13 +1183,28 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           ),
         });
       });
+
+      // 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;
     }
 
-    await this.inngestStep.sleepUntil(entry.id, date);
+    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> {
@@ -1205,6 +1230,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController,
     runtimeContext,
     writableStream,
+    tracingContext,
   }: {
     step: Step<string, any, any>;
     stepResults: Record<string, StepResult<any, any, any, any>>;
@@ -1219,7 +1245,17 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController: AbortController;
     runtimeContext: RuntimeContext;
     writableStream?: WritableStream<ChunkType>;
+    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 () => {
@@ -1453,7 +1489,18 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     }
 
     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;
 
@@ -1465,6 +1512,9 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           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];
@@ -1532,7 +1582,9 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
 
       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;
         }
       }
 
@@ -1579,6 +1631,8 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
         });
       }
 
+      stepAISpan?.end({ output: execResults });
+
       return { result: execResults, executionContext, stepResults };
     });
 
@@ -1623,6 +1677,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             context: stepResults as any,
             activePaths: [],
             suspendedPaths: executionContext.suspendedPaths,
+            waitingPaths: {},
             serializedStepGraph,
             status: workflowStatus,
             result,
@@ -1649,6 +1704,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController,
     runtimeContext,
     writableStream,
+    tracingContext,
   }: {
     workflowId: string;
     runId: string;
@@ -1672,12 +1728,31 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController: AbortController;
     runtimeContext: RuntimeContext;
     writableStream?: WritableStream<ChunkType>;
+    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,
@@ -1686,6 +1761,9 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
                 runtimeContext,
                 runCount: -1,
                 inputData: prevOutput,
+                tracingContext: {
+                  currentSpan: evalSpan,
+                },
                 getInitData: () => stepResults?.input as any,
                 getStepResult: (step: any) => {
                   if (!step?.id) {
@@ -1721,9 +1799,23 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
                   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;
             }
           }),
@@ -1732,16 +1824,25 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     ).filter((index: any): index is number => index !== null);
 
     const stepsToRun = entry.steps.filter((_, index) => truthyIndexes.includes(index));
+
+    // 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,
-          serializedStepGraph,
           executionContext: {
             workflowId,
             runId,
@@ -1754,6 +1855,9 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           abortController,
           runtimeContext,
           writableStream,
+          tracingContext: {
+            currentSpan: conditionalSpan,
+          },
         }),
       ),
     );
@@ -1779,6 +1883,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;
   }
 }