@mastra/inngest 0.0.0-custom-instrumentation-20250626084921 → 0.0.0-fix-generate-title-20250616171351

package/src/index.ts

@@ -1,9 +1,8 @@
 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 { Agent, Tool } from '@mastra/core';
+import type { Mastra, ToolExecutionContext, WorkflowRun, WorkflowRuns } from '@mastra/core';
 import { RuntimeContext } from '@mastra/core/di';
-import { Tool } from '@mastra/core/tools';
 import { Workflow, Run, DefaultExecutionEngine } from '@mastra/core/workflows';
 import type {
   ExecuteFunction,
@@ -17,9 +16,7 @@ import type {
   WorkflowResult,
   SerializedStepFlowEntry,
   StepFailure,
-  Emitter,
   WatchEvent,
-  StreamEvent,
 } from '@mastra/core/workflows';
 import { EMITTER_SYMBOL } from '@mastra/core/workflows/_constants';
 import type { Span } from '@opentelemetry/api';
@@ -90,8 +87,7 @@ export class InngestRun<
 
   async getRunOutput(eventId: string) {
     let runs = await this.getRuns(eventId);
-
-    while (runs?.[0]?.status !== 'Completed' || runs?.[0]?.event_id !== 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') {
@@ -101,13 +97,6 @@ export class InngestRun<
     return runs?.[0];
   }
 
-  async sendEvent(event: string, data: any) {
-    await this.inngest.send({
-      name: `user-event-${event}`,
-      data,
-    });
-  }
-
   async start({
     inputData,
   }: {
@@ -159,27 +148,6 @@ 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,
@@ -217,72 +185,28 @@ export class InngestRun<
     return result;
   }
 
-  watch(cb: (event: WatchEvent) => void, type: 'watch' | 'watch-v2' = 'watch'): () => void {
-    let active = true;
+  watch(cb: (event: any) => void): () => void {
     const streamPromise = subscribe(
       {
         channel: `workflow:${this.workflowId}:${this.runId}`,
-        topics: [type],
+        topics: ['watch'],
         app: this.inngest,
       },
       (message: any) => {
-        if (active) {
-          cb(message.data);
-        }
+        cb(message.data);
       },
     );
 
     return () => {
-      active = false;
       streamPromise
-        .then(async (stream: Awaited<typeof streamPromise>) => {
-          return stream.cancel();
+        .then((stream: any) => {
+          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<
@@ -410,49 +334,6 @@ export class InngestWorkflow<
     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<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);
-
-    await this.mastra?.getStorage()?.persistWorkflowSnapshot({
-      workflowName: this.id,
-      runId: runIdToUse,
-      snapshot: {
-        runId: runIdToUse,
-        status: 'pending',
-        value: {},
-        context: {},
-        activePaths: [],
-        serializedStepGraph: this.serializedStepGraph,
-        suspendedPaths: {},
-        result: undefined,
-        error: undefined,
-        // @ts-ignore
-        timestamp: Date.now(),
-      },
-    });
-
-    return run;
-  }
-
   getFunction() {
     if (this.function) {
       return this.function;
@@ -479,22 +360,13 @@ export class InngestWorkflow<
             try {
               await publish({
                 channel: `workflow:${this.id}:${runId}`,
-                topic: event,
+                topic: 'watch',
                 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);
@@ -536,14 +408,6 @@ export class InngestWorkflow<
   }
 }
 
-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>,
@@ -587,6 +451,7 @@ export function createStep<
     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>,
@@ -617,7 +482,7 @@ export function createStep<
         execute: (context: ToolExecutionContext<TStepInput>) => Promise<any>;
       }),
 ): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema, InngestEngineType> {
-  if (isAgent(params)) {
+  if (params instanceof Agent) {
     return {
       id: params.name,
       // @ts-ignore
@@ -692,7 +557,7 @@ export function createStep<
     };
   }
 
-  if (isTool(params)) {
+  if (params instanceof Tool) {
     if (!params.inputSchema || !params.outputSchema) {
       throw new Error('Tool must have input and output schemas defined');
     }
@@ -766,12 +631,11 @@ export function init(inngest: Inngest) {
         any,
         InngestEngineType
       >[],
-      TPrevSchema extends z.ZodType<any> = TInput,
     >(
-      workflow: Workflow<InngestEngineType, TSteps, string, TInput, TOutput, TPrevSchema>,
+      workflow: Workflow<InngestEngineType, TSteps, string, TInput, TOutput, TInput>,
       opts: { id: TWorkflowId },
-    ): Workflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {
-      const wf: Workflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> = new Workflow({
+    ): Workflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TInput> {
+      const wf = new Workflow({
         id: opts.id,
         inputSchema: workflow.inputSchema,
         outputSchema: workflow.outputSchema,
@@ -796,44 +660,9 @@ 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;
-  }): 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: Emitter,
+    emitter: { emit: (event: string, data: any) => Promise<void> },
     stepResults: Record<string, StepResult<any, any, any, any>>,
     lastOutput: StepResult<any, any, any, any>,
     error?: Error | string,
@@ -926,7 +755,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
       resumePayload: any;
     };
     prevOutput: any;
-    emitter: Emitter;
+    emitter: { emit: (event: string, data: any) => Promise<void> };
     runtimeContext: RuntimeContext;
   }): Promise<StepResult<any, any, any, any>> {
     return super.executeStep({
@@ -946,19 +775,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     await this.inngestStep.sleep(id, duration);
   }
 
-  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({
     step,
     stepResults,
@@ -983,13 +799,12 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
       runId?: string;
     };
     prevOutput: any;
-    emitter: Emitter;
+    emitter: { emit: (event: string, data: any) => Promise<void> };
     runtimeContext: RuntimeContext;
   }): Promise<StepResult<any, any, any, any>> {
-    const startedAt = await this.inngestStep.run(
+    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: {
@@ -1011,15 +826,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           },
           eventTimestamp: Date.now(),
         });
-
-        await emitter.emit('watch-v2', {
-          type: 'step-start',
-          payload: {
-            id: step.id,
-          },
-        });
-
-        return startedAt;
       },
     );
 
@@ -1086,14 +892,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
               eventTimestamp: Date.now(),
             });
 
-            await emitter.emit('watch-v2', {
-              type: 'step-result',
-              payload: {
-                id: step.id,
-                status: 'failed',
-              },
-            });
-
             return { executionContext, result: { status: 'failed', error: result?.error } };
           } else if (result.status === 'suspended') {
             const suspendedSteps = Object.entries(result.steps).filter(([_stepName, stepResult]) => {
@@ -1124,13 +922,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
                 eventTimestamp: Date.now(),
               });
 
-              await emitter.emit('watch-v2', {
-                type: 'step-suspended',
-                payload: {
-                  id: step.id,
-                },
-              });
-
               return {
                 executionContext,
                 result: {
@@ -1187,14 +978,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             eventTimestamp: Date.now(),
           });
 
-          await emitter.emit('watch-v2', {
-            type: 'step-finish',
-            payload: {
-              id: step.id,
-              metadata: {},
-            },
-          });
-
           return { executionContext, result: { status: 'success', output: result?.result } };
         },
       );
@@ -1206,8 +989,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     const stepRes = await this.inngestStep.run(`workflow.${executionContext.workflowId}.step.${step.id}`, async () => {
       let execResults: any;
       let suspended: { payload: any } | undefined;
-      let bailed: { payload: any } | undefined;
-
       try {
         const result = await step.execute({
           runId: executionContext.runId,
@@ -1228,9 +1009,6 @@ 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,
@@ -1242,41 +1020,14 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             step: this.inngestStep,
           },
         });
-        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,
-        };
+
+        execResults = { status: 'success', output: result };
       } catch (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,
-        };
+        execResults = { status: 'failed', error: e instanceof Error ? e.message : String(e) };
       }
 
       if (suspended) {
-        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 };
+        execResults = { status: 'suspended', payload: suspended.payload };
       }
 
       if (execResults.status === 'failed') {
@@ -1290,11 +1041,12 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
         payload: {
           currentStep: {
             id: step.id,
-            ...execResults,
+            status: execResults.status,
+            output: execResults.output,
           },
           workflowState: {
             status: 'running',
-            steps: { ...stepResults, [step.id]: execResults },
+            steps: stepResults,
             result: null,
             error: null,
           },
@@ -1302,34 +1054,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
         eventTimestamp: Date.now(),
       });
 
-      if (execResults.status === 'suspended') {
-        await emitter.emit('watch-v2', {
-          type: 'step-suspended',
-          payload: {
-            id: step.id,
-            status: execResults.status,
-            output: execResults.status === 'success' ? execResults?.output : undefined,
-          },
-        });
-      } else {
-        await emitter.emit('watch-v2', {
-          type: 'step-result',
-          payload: {
-            id: step.id,
-            status: execResults.status,
-            output: execResults.status === 'success' ? execResults?.output : undefined,
-          },
-        });
-
-        await emitter.emit('watch-v2', {
-          type: 'step-finish',
-          payload: {
-            id: step.id,
-            metadata: {},
-          },
-        });
-      }
-
       return { result: execResults, executionContext, stepResults };
     });
 
@@ -1416,7 +1140,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
       resumePath: number[];
     };
     executionContext: ExecutionContext;
-    emitter: Emitter;
+    emitter: { emit: (event: string, data: any) => Promise<void> };
     runtimeContext: RuntimeContext;
   }): Promise<StepResult<any, any, any, any>> {
     let execResults: any;
@@ -1446,7 +1170,6 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
 
                 // TODO: this function shouldn't have suspend probably?
                 suspend: async (_suspendPayload: any) => {},
-                bail: () => {},
                 [EMITTER_SYMBOL]: emitter,
                 engine: {
                   step: this.inngestStep,
@@ -1493,7 +1216,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     if (hasFailed) {
       execResults = { status: 'failed', error: hasFailed.result.error };
     } else if (hasSuspended) {
-      execResults = { status: 'suspended', payload: hasSuspended.result.suspendPayload };
+      execResults = { status: 'suspended', payload: hasSuspended.result.payload };
     } else {
       execResults = {
         status: 'success',