@mastra/inngest 0.12.2 → 0.12.3-alpha.1

package/src/index.test.ts

@@ -6,6 +6,8 @@ import { realtimeMiddleware } from '@inngest/realtime';
 import { Agent } from '@mastra/core/agent';
 import { Mastra } from '@mastra/core/mastra';
 import { RuntimeContext } from '@mastra/core/runtime-context';
+import type { MastraScorer } from '@mastra/core/scores';
+import { createScorer, runExperiment } from '@mastra/core/scores';
 import { Telemetry } from '@mastra/core/telemetry';
 import { createTool } from '@mastra/core/tools';
 import type { StreamEvent } from '@mastra/core/workflows';
@@ -7813,5 +7815,269 @@ describe('MastraInngestWorkflow', () => {
         },
       ]);
     });
+
+    describe('Workflow integration', () => {
+      let mockScorers: MastraScorer[];
+      beforeEach(() => {
+        const createMockScorer = (name: string, score: number = 0.8): MastraScorer => {
+          const scorer = createScorer({
+            description: 'Mock scorer',
+            name,
+          }).generateScore(() => {
+            return score;
+          });
+
+          vi.spyOn(scorer, 'run');
+
+          return scorer;
+        };
+
+        vi.clearAllMocks();
+        mockScorers = [createMockScorer('toxicity', 0.9), createMockScorer('relevance', 0.7)];
+      });
+
+      it('should run experiment with workflow target', async ctx => {
+        const inngest = new Inngest({
+          id: 'mastra',
+          baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+          middleware: [realtimeMiddleware()],
+        });
+
+        const { createWorkflow, createStep } = init(inngest);
+
+        // Create a simple workflow
+        const mockStep = createStep({
+          id: 'test-step',
+          inputSchema: z.object({ input: z.string() }),
+          outputSchema: z.object({ output: z.string() }),
+          execute: async ({ inputData }) => {
+            return { output: `Processed: ${inputData.input}` };
+          },
+        });
+
+        const workflow = createWorkflow({
+          id: 'test-workflow',
+          inputSchema: z.object({ input: z.string() }),
+          outputSchema: z.object({ output: z.string() }),
+        })
+          .then(mockStep)
+          .commit();
+
+        const mastra = new Mastra({
+          storage: new DefaultStorage({
+            url: ':memory:',
+          }),
+          workflows: {
+            'test-workflow': workflow,
+          },
+          server: {
+            apiRoutes: [
+              {
+                path: '/inngest/api',
+                method: 'ALL',
+                createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+              },
+            ],
+          },
+        });
+
+        const app = await createHonoServer(mastra);
+
+        const srv = (globServer = serve({
+          fetch: app.fetch,
+          port: (ctx as any).handlerPort,
+        }));
+
+        await resetInngest();
+
+        const result = await runExperiment({
+          data: [
+            { input: { input: 'Test input 1' }, groundTruth: 'Expected 1' },
+            { input: { input: 'Test input 2' }, groundTruth: 'Expected 2' },
+          ],
+          scorers: [mockScorers[0]],
+          target: workflow,
+        });
+        srv.close();
+        expect(result.scores.toxicity).toBe(0.9);
+        expect(result.summary.totalItems).toBe(2);
+      });
+    });
+  });
+
+  describe.sequential('Flow Control Configuration', () => {
+    it('should accept workflow configuration with flow control properties', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-flow-control',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1 = createStep({
+        id: 'step1',
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      // Test workflow with flow control configuration
+      const workflow = createWorkflow({
+        id: 'flow-control-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        // Flow control properties
+        concurrency: {
+          limit: 5,
+          key: 'event.data.userId',
+        },
+        rateLimit: {
+          period: '1h',
+          limit: 100,
+        },
+        priority: {
+          run: 'event.data.priority ?? 50',
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('flow-control-test');
+
+      // Verify that function creation includes flow control config
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
+
+    it('should handle workflow configuration with partial flow control properties', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-partial-flow-control',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1 = createStep({
+        id: 'step1',
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      // Test workflow with only some flow control properties
+      const workflow = createWorkflow({
+        id: 'partial-flow-control-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        // Only concurrency control
+        concurrency: {
+          limit: 10,
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('partial-flow-control-test');
+
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
+
+    it('should handle workflow configuration without flow control properties (backward compatibility)', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-backward-compat',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1 = createStep({
+        id: 'step1',
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      // Test workflow without any flow control properties (existing behavior)
+      const workflow = createWorkflow({
+        id: 'backward-compat-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        retryConfig: {
+          attempts: 3,
+          delay: 1000,
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('backward-compat-test');
+
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
+
+    it('should support all flow control configuration types', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-all-flow-control',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1 = createStep({
+        id: 'step1',
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      // Test workflow with all flow control configuration types
+      const workflow = createWorkflow({
+        id: 'all-flow-control-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        // All flow control properties
+        concurrency: {
+          limit: 5,
+          key: 'event.data.userId',
+        },
+        rateLimit: {
+          period: '1m',
+          limit: 10,
+        },
+        throttle: {
+          period: '10s',
+          limit: 1,
+          key: 'event.data.organizationId',
+        },
+        debounce: {
+          period: '5s',
+          key: 'event.data.messageId',
+        },
+        priority: {
+          run: 'event.data.priority ?? 0',
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('all-flow-control-test');
+
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
   });
 }, 40e3);

package/src/index.ts

@@ -33,6 +33,30 @@ import type { Inngest, BaseContext } from 'inngest';
 import { serve as inngestServe } from 'inngest/hono';
 import { z } from 'zod';
 
+// Extract Inngest's native flow control configuration types
+type InngestCreateFunctionConfig = Parameters<Inngest['createFunction']>[0];
+
+// Extract specific flow control properties (excluding batching)
+export type InngestFlowControlConfig = Pick<
+  InngestCreateFunctionConfig,
+  'concurrency' | 'rateLimit' | 'throttle' | 'debounce' | 'priority'
+>;
+
+// Union type for Inngest workflows with flow control
+export type InngestWorkflowConfig<
+  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, any>[] = Step<string, any, any, any, any, any>[],
+> = WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps> & InngestFlowControlConfig;
+
+// Compile-time compatibility assertion
+type _AssertInngestCompatibility =
+  InngestFlowControlConfig extends Pick<Parameters<Inngest['createFunction']>[0], keyof InngestFlowControlConfig>
+    ? true
+    : never;
+const _compatibilityCheck: _AssertInngestCompatibility = true;
+
 export type InngestEngineType = {
   step: any;
 };
@@ -342,9 +366,19 @@ export class InngestWorkflow<
   public inngest: Inngest;
 
   private function: ReturnType<Inngest['createFunction']> | undefined;
+  private readonly flowControlConfig?: InngestFlowControlConfig;
+
+  constructor(params: InngestWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest) {
+    const { concurrency, rateLimit, throttle, debounce, priority, ...workflowParams } = params;
+
+    super(workflowParams as WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>);
+
+    const flowControlEntries = Object.entries({ concurrency, rateLimit, throttle, debounce, priority }).filter(
+      ([_, value]) => value !== undefined,
+    );
+
+    this.flowControlConfig = flowControlEntries.length > 0 ? Object.fromEntries(flowControlEntries) : undefined;
 
-  constructor(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest) {
-    super(params);
     this.#mastra = params.mastra!;
     this.inngest = inngest;
   }
@@ -513,6 +547,8 @@ export class InngestWorkflow<
         // @ts-ignore
         retries: this.retryConfig?.attempts ?? 0,
         cancelOn: [{ event: `cancel.workflow.${this.id}` }],
+        // Spread flow control configuration
+        ...this.flowControlConfig,
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
@@ -801,7 +837,7 @@ export function init(inngest: Inngest) {
         any,
         InngestEngineType
       >[],
-    >(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>) {
+    >(params: InngestWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>) {
       return new InngestWorkflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TInput>(params, inngest);
     },
     createStep,
@@ -1230,6 +1266,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController,
     runtimeContext,
     writableStream,
+    disableScorers,
     tracingContext,
   }: {
     step: Step<string, any, any>;
@@ -1245,6 +1282,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController: AbortController;
     runtimeContext: RuntimeContext;
     writableStream?: WritableStream<ChunkType>;
+    disableScorers?: boolean;
     tracingContext?: TracingContext;
   }): Promise<StepResult<any, any, any, any>> {
     const stepAISpan = tracingContext?.currentSpan?.createChildSpan({
@@ -1636,6 +1674,23 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
       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
@@ -1704,6 +1759,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController,
     runtimeContext,
     writableStream,
+    disableScorers,
     tracingContext,
   }: {
     workflowId: string;
@@ -1728,6 +1784,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     abortController: AbortController;
     runtimeContext: RuntimeContext;
     writableStream?: WritableStream<ChunkType>;
+    disableScorers?: boolean;
     tracingContext?: TracingContext;
   }): Promise<StepResult<any, any, any, any>> {
     const conditionalSpan = tracingContext?.currentSpan?.createChildSpan({
@@ -1855,6 +1912,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           abortController,
           runtimeContext,
           writableStream,
+          disableScorers,
           tracingContext: {
             currentSpan: conditionalSpan,
           },