@mastra/inngest 0.0.0-vnext-inngest-20250506123700 → 0.0.0-vnext-inngest-20250506132005

package/src/index.test.ts

@@ -42,12 +42,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Basic Workflow Execution', () => {
     it('should execute a single step workflow successfully', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
       const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
       const step1 = createStep({
         id: 'step1',
@@ -80,7 +80,7 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
@@ -107,12 +107,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should execute multiple steps in parallel', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn().mockImplementation(async () => {
         return { value: 'step1' };
@@ -157,14 +157,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -187,12 +186,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should execute steps sequentially', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const executionOrder: string[] = [];
 
@@ -241,14 +240,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -272,12 +270,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Variable Resolution', () => {
     it('should resolve trigger data', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
 
@@ -316,14 +314,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -340,12 +337,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should provide access to step results and trigger data via getStepResult helper', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn().mockImplementation(async ({ inputData }) => {
         // Test accessing trigger data with correct type
@@ -406,14 +403,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -435,12 +431,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should resolve trigger data from context', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
       const triggerSchema = z.object({
@@ -476,14 +472,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -503,12 +498,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should resolve trigger data from getInitData', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
       const triggerSchema = z.object({
@@ -554,14 +549,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -583,12 +577,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should resolve variables from previous steps', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn<any>().mockResolvedValue({
         nested: { value: 'step1-data' },
@@ -639,14 +633,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -670,12 +663,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Simple Conditions', () => {
     it('should follow conditional chains', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn().mockImplementation(() => {
         return Promise.resolve({ status: 'success' });
@@ -745,14 +738,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -774,12 +766,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should handle failing dependencies', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       let err: Error | undefined;
       const step1Action = vi.fn<any>().mockImplementation(() => {
@@ -824,14 +816,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -857,12 +848,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should support simple string conditions', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn<any>().mockResolvedValue({ status: 'success' });
       const step2Action = vi.fn<any>().mockResolvedValue({ result: 'step2' });
@@ -932,14 +923,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -961,12 +951,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should support custom condition functions', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn<any>().mockResolvedValue({ count: 5 });
       const step2Action = vi.fn<any>();
@@ -1018,14 +1008,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1050,12 +1039,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Error Handling', () => {
     it('should handle step execution errors', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const error = new Error('Step execution failed');
       const failingAction = vi.fn<any>().mockRejectedValue(error);
@@ -1089,14 +1078,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1119,12 +1107,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should handle step execution errors within branches', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const error = new Error('Step execution failed');
       const failingAction = vi.fn<any>().mockRejectedValue(error);
@@ -1176,14 +1164,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1208,12 +1195,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should handle step execution errors within nested workflows', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const error = new Error('Step execution failed');
       const failingAction = vi.fn<any>().mockRejectedValue(error);
@@ -1268,10 +1255,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'main-workflow': mainWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1295,12 +1290,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Complex Conditions', () => {
     it('should handle nested AND/OR conditions', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn<any>().mockResolvedValue({
         status: 'partial',
@@ -1395,14 +1390,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1423,12 +1417,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Loops', () => {
     it('should run an until loop', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const increment = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -1495,10 +1489,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1520,12 +1522,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should run a while loop', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const increment = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -1592,10 +1594,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1619,12 +1629,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('foreach', () => {
     it('should run a single item concurrency (default) for loop', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const startTime = Date.now();
       const map = vi.fn().mockImplementation(async ({ inputData }) => {
@@ -1675,10 +1685,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1706,12 +1724,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('if-else branching', () => {
     it('should run the if-then branch', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const start = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -1822,10 +1840,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1848,12 +1874,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should run the else branch', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const start = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -1965,10 +1991,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -1993,12 +2027,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Schema Validation', () => {
     it.skip('should validate trigger data against schema', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const triggerSchema = z.object({
         required: z.string(),
@@ -2054,12 +2088,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('multiple chains', () => {
     it('should run multiple chains in parallel', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1 = createStep({
         id: 'step1',
@@ -2136,14 +2170,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -2163,12 +2196,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Retry', () => {
     it('should retry a step default 0 times', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1 = createStep({
         id: 'step1',
@@ -2205,14 +2238,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -2233,12 +2265,12 @@ describe('MastraInngestWorkflow', ctx => {
 
     // Need to fix so we can throw for inngest to recognize retries
     it.skip('should retry a step with a custom retry config', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1 = createStep({
         id: 'step1',
@@ -2269,7 +2301,7 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
@@ -2289,12 +2321,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Interoperability (Actions)', () => {
     it('should be able to use all action types in a workflow', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn<any>().mockResolvedValue({ name: 'step1' });
 
@@ -2340,14 +2372,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -2368,13 +2399,13 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Watch', () => {
     it('should watch workflow state changes and call onTransition', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         middleware: [realtimeMiddleware()],
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn<any>().mockResolvedValue({ result: 'success1' });
       const step2Action = vi.fn<any>().mockResolvedValue({ result: 'success2' });
@@ -2414,14 +2445,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -2557,13 +2587,13 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should unsubscribe from transitions when unwatch is called', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         middleware: [realtimeMiddleware()],
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const step1Action = vi.fn<any>().mockResolvedValue({ result: 'success1' });
       const step2Action = vi.fn<any>().mockResolvedValue({ result: 'success2' });
@@ -2603,14 +2633,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -2662,12 +2691,12 @@ describe('MastraInngestWorkflow', ctx => {
       }
     });
     it('should return the correct runId', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const workflow = createWorkflow({
         id: 'test-workflow',
@@ -2684,13 +2713,13 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should handle basic suspend and resume flow', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         middleware: [realtimeMiddleware()],
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const getUserInputAction = vi.fn().mockResolvedValue({ userInput: 'test input' });
       const promptAgentAction = vi
@@ -2779,10 +2808,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': promptEvalWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -2837,13 +2874,13 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should handle parallel steps with conditional suspend', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         middleware: [realtimeMiddleware()],
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const getUserInputAction = vi.fn().mockResolvedValue({ userInput: 'test input' });
       const promptAgentAction = vi.fn().mockResolvedValue({ modelOutput: 'test output' });
@@ -2928,14 +2965,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -2999,13 +3035,13 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should handle complex workflow with multiple suspends', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         middleware: [realtimeMiddleware()],
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const getUserInputAction = vi.fn().mockResolvedValue({ userInput: 'test input' });
       const promptAgentAction = vi.fn().mockResolvedValue({ modelOutput: 'test output' });
@@ -3133,14 +3169,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -3229,12 +3264,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should handle basic suspend and resume flow with async await syntax', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
       const getUserInputAction = vi.fn().mockResolvedValue({ userInput: 'test input' });
       const promptAgentAction = vi
         .fn()
@@ -3325,10 +3360,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': promptEvalWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -3414,12 +3457,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Accessing Mastra', () => {
     it('should be able to access the deprecated mastra primitives', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
       let telemetry: Telemetry | undefined;
       const step1 = createStep({
         id: 'step1',
@@ -3448,14 +3491,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -3476,12 +3518,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Agent as step', () => {
     it('should be able to use an agent as a step', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const workflow = createWorkflow({
         id: 'test-workflow',
@@ -3554,14 +3596,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -3588,12 +3629,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should be able to use an agent in parallel', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
       const finalStep = createStep({
@@ -3693,14 +3734,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -3735,12 +3775,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Nested workflows', () => {
     it('should be able to nest workflows', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const start = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -3834,10 +3874,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -3871,12 +3919,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should be able to nest workflows with conditions', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const start = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -3980,10 +4028,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -4018,12 +4074,12 @@ describe('MastraInngestWorkflow', ctx => {
 
     describe('new if else branching syntax with nested workflows', () => {
       it('should execute if-branch', async ctx => {
-        const ingest = new Inngest({
+        const inngest = new Inngest({
           id: 'mastra',
           baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         });
 
-        const { createWorkflow, createStep } = init(ingest);
+        const { createWorkflow, createStep } = init(inngest);
 
         const start = vi.fn().mockImplementation(async ({ inputData }) => {
           // Get the current value (either from trigger or previous increment)
@@ -4131,13 +4187,21 @@ describe('MastraInngestWorkflow', ctx => {
           vnext_workflows: {
             'test-workflow': counterWorkflow,
           },
+          server: {
+            apiRoutes: [
+              {
+                path: '/inngest/api',
+                method: 'ALL',
+                createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+              },
+            ],
+          },
         });
 
         const app = await createHonoServer(mastra);
         app.use('*', async (ctx, next) => {
           await next();
         });
-        app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
         const srv = serve({
           fetch: app.fetch,
@@ -4171,12 +4235,12 @@ describe('MastraInngestWorkflow', ctx => {
       });
 
       it('should execute else-branch', async ctx => {
-        const ingest = new Inngest({
+        const inngest = new Inngest({
           id: 'mastra',
           baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         });
 
-        const { createWorkflow, createStep } = init(ingest);
+        const { createWorkflow, createStep } = init(inngest);
 
         const start = vi.fn().mockImplementation(async ({ inputData }) => {
           // Get the current value (either from trigger or previous increment)
@@ -4284,13 +4348,21 @@ describe('MastraInngestWorkflow', ctx => {
           vnext_workflows: {
             'test-workflow': counterWorkflow,
           },
+          server: {
+            apiRoutes: [
+              {
+                path: '/inngest/api',
+                method: 'ALL',
+                createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+              },
+            ],
+          },
         });
 
         const app = await createHonoServer(mastra);
         app.use('*', async (ctx, next) => {
           await next();
         });
-        app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
         const srv = serve({
           fetch: app.fetch,
@@ -4325,12 +4397,12 @@ describe('MastraInngestWorkflow', ctx => {
       });
 
       it('should execute nested else and if-branch', async ctx => {
-        const ingest = new Inngest({
+        const inngest = new Inngest({
           id: 'mastra',
           baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         });
 
-        const { createWorkflow, createStep } = init(ingest);
+        const { createWorkflow, createStep } = init(inngest);
 
         const start = vi.fn().mockImplementation(async ({ inputData }) => {
           // Get the current value (either from trigger or previous increment)
@@ -4475,13 +4547,21 @@ describe('MastraInngestWorkflow', ctx => {
           vnext_workflows: {
             'test-workflow': counterWorkflow,
           },
+          server: {
+            apiRoutes: [
+              {
+                path: '/inngest/api',
+                method: 'ALL',
+                createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+              },
+            ],
+          },
         });
 
         const app = await createHonoServer(mastra);
         app.use('*', async (ctx, next) => {
           await next();
         });
-        app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
         const srv = serve({
           fetch: app.fetch,
@@ -4518,12 +4598,12 @@ describe('MastraInngestWorkflow', ctx => {
 
     describe('suspending and resuming nested workflows', () => {
       it('should be able to suspend nested workflow step', async ctx => {
-        const ingest = new Inngest({
+        const inngest = new Inngest({
           id: 'mastra',
           baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         });
 
-        const { createWorkflow, createStep } = init(ingest);
+        const { createWorkflow, createStep } = init(inngest);
 
         const start = vi.fn().mockImplementation(async ({ inputData, resume }) => {
           // Get the current value (either from trigger or previous increment)
@@ -4625,10 +4705,18 @@ describe('MastraInngestWorkflow', ctx => {
           vnext_workflows: {
             'test-workflow': counterWorkflow,
           },
+          server: {
+            apiRoutes: [
+              {
+                path: '/inngest/api',
+                method: 'ALL',
+                createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+              },
+            ],
+          },
         });
 
         const app = await createHonoServer(mastra);
-        app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
         const srv = serve({
           fetch: app.fetch,
@@ -4669,12 +4757,12 @@ describe('MastraInngestWorkflow', ctx => {
 
     describe('Workflow results', () => {
       it('should be able to spec out workflow result via variables', async ctx => {
-        const ingest = new Inngest({
+        const inngest = new Inngest({
           id: 'mastra',
           baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
         });
 
-        const { createWorkflow, createStep } = init(ingest);
+        const { createWorkflow, createStep } = init(inngest);
 
         const start = vi.fn().mockImplementation(async ({ inputData }) => {
           // Get the current value (either from trigger or previous increment)
@@ -4767,6 +4855,15 @@ describe('MastraInngestWorkflow', ctx => {
           vnext_workflows: {
             'test-workflow': counterWorkflow,
           },
+          server: {
+            apiRoutes: [
+              {
+                path: '/inngest/api',
+                method: 'ALL',
+                createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+              },
+            ],
+          },
         });
 
         const app = await createHonoServer(mastra);
@@ -4774,7 +4871,6 @@ describe('MastraInngestWorkflow', ctx => {
           'middleware', ctx.req.method, ctx.req.url;
           await next();
         });
-        app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
         const srv = serve({
           fetch: app.fetch,
@@ -4808,12 +4904,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should be able to suspend nested workflow step in a nested workflow step', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const start = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -4946,10 +5042,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -5004,12 +5108,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should be able clone workflows as steps', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep, cloneStep, cloneWorkflow } = init(ingest);
+      const { createWorkflow, createStep, cloneStep, cloneWorkflow } = init(inngest);
 
       const start = vi.fn().mockImplementation(async ({ inputData }) => {
         // Get the current value (either from trigger or previous increment)
@@ -5107,10 +5211,18 @@ describe('MastraInngestWorkflow', ctx => {
         vnext_workflows: {
           'test-workflow': counterWorkflow,
         },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -5146,12 +5258,12 @@ describe('MastraInngestWorkflow', ctx => {
 
   describe('Accessing Mastra', () => {
     it('should be able to access the deprecated mastra primitives', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       let telemetry: Telemetry | undefined;
       const step1 = createStep({
@@ -5181,14 +5293,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -5210,12 +5321,12 @@ describe('MastraInngestWorkflow', ctx => {
   // TODO: can we support this on inngest?
   describe.skip('Dependency Injection', () => {
     it('should inject runtimeContext dependencies into steps during run', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const runtimeContext = new RuntimeContext();
       const testValue = 'test-dependency';
@@ -5247,14 +5358,13 @@ describe('MastraInngestWorkflow', ctx => {
             {
               path: '/inngest/api',
               method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, ingest }),
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
             },
           ],
         },
       });
 
       const app = await createHonoServer(mastra);
-      app.all('/inngest/api', inngestServe({ mastra, ingest }));
 
       const srv = serve({
         fetch: app.fetch,
@@ -5271,12 +5381,12 @@ describe('MastraInngestWorkflow', ctx => {
     });
 
     it('should inject runtimeContext dependencies into steps during resume', async ctx => {
-      const ingest = new Inngest({
+      const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
       });
 
-      const { createWorkflow, createStep } = init(ingest);
+      const { createWorkflow, createStep } = init(inngest);
 
       const initialStorage = new DefaultStorage({
         config: {
@@ -5335,4 +5445,4 @@ describe('MastraInngestWorkflow', ctx => {
       expect(result?.steps.step1.output.injectedValue).toBe(testValue + '2');
     });
   });
-}, 30e3);
+}, 40e3);