npm - @mastra/inngest - Versions diffs - 0.0.0-ai-v5-20250626003446 → 0.0.0-ai-v5-20250710191716 - Mend

@mastra/inngest 0.0.0-ai-v5-20250626003446 → 0.0.0-ai-v5-20250710191716

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/CHANGELOG.md +188 -3
package/LICENSE.md +11 -42
package/dist/_tsup-dts-rollup.d.cts +61 -17
package/dist/_tsup-dts-rollup.d.ts +61 -17
package/dist/index.cjs +233 -25
package/dist/index.js +233 -25
package/docker-compose.yaml +3 -3
package/package.json +15 -14
package/src/index.test.ts +1157 -389
package/src/index.ts +300 -26
package/vitest.config.ts +6 -0

package/src/index.test.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-import { randomUUID } from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { openai } from '@ai-sdk/openai';
@@ -12,9 +11,8 @@ import { createHonoServer } from '@mastra/deployer/server';
 import { DefaultStorage } from '@mastra/libsql';
 import { MockLanguageModelV1, simulateReadableStream } from 'ai/test';
 import { $ } from 'execa';
-import getPort from 'get-port';
 import { Inngest } from 'inngest';
-import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { z } from 'zod';
 import { init, serve as inngestServe } from './index';
@@ -22,28 +20,133 @@ import { init, serve as inngestServe } from './index';
 interface LocalTestContext {
   inngestPort: number;
   handlerPort: number;
-  containerName: string;
+  srv?: any;
+}
+async function resetInngest() {
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  await $`docker-compose restart`;
+  await new Promise(resolve => setTimeout(resolve, 1500));
 }
 describe('MastraInngestWorkflow', () => {
+  let globServer: any;
   beforeEach<LocalTestContext>(async ctx => {
-    const inngestPort = await getPort();
-    const handlerPort = await getPort();
-    const containerName = randomUUID();
-    await $`docker run --rm -d --name ${containerName} -p ${inngestPort}:${inngestPort} inngest/inngest:v1.5.10 inngest dev -p ${inngestPort} -u http://host.docker.internal:${handlerPort}/inngest/api`;
+    ctx.inngestPort = 4000;
+    ctx.handlerPort = 4001;
-    ctx.inngestPort = inngestPort;
-    ctx.handlerPort = handlerPort;
-    ctx.containerName = containerName;
+    globServer?.close();
     vi.restoreAllMocks();
   });
-  afterEach<LocalTestContext>(async ctx => {
-    await $`docker stop ${ctx.containerName}`;
-  });
   describe.sequential('Basic Workflow Execution', () => {
+    it('should be able to bail workflow execution', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+      const { createWorkflow, createStep } = init(inngest);
+      const step1 = createStep({
+        id: 'step1',
+        execute: async ({ bail, inputData }) => {
+          if (inputData.value === 'bail') {
+            return bail({ result: 'bailed' });
+          }
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: async ({ inputData }) => {
+          return { result: 'step2: ' + inputData.result };
+        },
+        inputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({
+          result: z.string(),
+        }),
+        steps: [step1, step2],
+      });
+      workflow.then(step1).then(step2).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 run = await workflow.createRunAsync();
+      console.log('running');
+      const result = await run.start({ inputData: { value: 'bail' } });
+      console.log('result', result);
+      expect(result.steps['step1']).toEqual({
+        status: 'success',
+        output: { result: 'bailed' },
+        payload: { value: 'bail' },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
+      expect(result.steps['step2']).toBeUndefined();
+      const run2 = await workflow.createRunAsync();
+      const result2 = await run2.start({ inputData: { value: 'no-bail' } });
+      srv.close();
+      expect(result2.steps['step1']).toEqual({
+        status: 'success',
+        output: { result: 'step1: no-bail' },
+        payload: { value: 'no-bail' },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
+      expect(result2.steps['step2']).toEqual({
+        status: 'success',
+        output: { result: 'step2: step1: no-bail' },
+        payload: { result: 'step1: no-bail' },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
+    });
     it('should execute a single step workflow successfully', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
@@ -89,13 +192,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
       expect(execute).toHaveBeenCalled();
@@ -164,13 +267,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
       expect(step1Action).toHaveBeenCalled();
@@ -245,13 +348,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
       expect(executionOrder).toMatchObject(['step1', 'step2']);
@@ -264,7 +367,7 @@ describe('MastraInngestWorkflow', () => {
       srv.close();
     });
-    it('should execute a a sleep step', async ctx => {
+    it('should execute a sleep step', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -319,13 +422,199 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
+      }));
+      await resetInngest();
+      const run = await workflow.createRunAsync();
+      const startTime = Date.now();
+      const result = await run.start({ inputData: {} });
+      const endTime = Date.now();
+      expect(execute).toHaveBeenCalled();
+      expect(result.steps['step1']).toMatchObject({
+        status: 'success',
+        output: { result: 'success' },
+        // payload: {},
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
+      });
+      expect(result.steps['step2']).toMatchObject({
+        status: 'success',
+        output: { result: 'slept successfully: success' },
+        // payload: { result: 'success' },
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
+      });
+      expect(endTime - startTime).toBeGreaterThan(1000);
+      srv.close();
+    });
+    it('should execute a sleep step with fn parameter', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+      });
+      const { createWorkflow, createStep } = init(inngest);
+      const execute = vi.fn<any>().mockResolvedValue({ value: 1000 });
+      const step1 = createStep({
+        id: 'step1',
+        execute,
+        inputSchema: z.object({}),
+        outputSchema: z.object({ value: z.number() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: async ({ inputData }) => {
+          return { value: inputData.value + 1000 };
+        },
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
+      });
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          value: z.number(),
+        }),
+        steps: [step1],
+      });
+      workflow
+        .then(step1)
+        .sleep(async ({ inputData }) => {
+          return inputData.value;
+        })
+        .then(step2)
+        .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 run = await workflow.createRunAsync();
+      const startTime = Date.now();
+      const result = await run.start({ inputData: {} });
+      const endTime = Date.now();
+      expect(execute).toHaveBeenCalled();
+      expect(result.steps['step1']).toMatchObject({
+        status: 'success',
+        output: { value: 1000 },
+        // payload: {},
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
+      });
+      expect(result.steps['step2']).toMatchObject({
+        status: 'success',
+        output: { value: 2000 },
+        // payload: { result: 'success' },
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
+      });
+      expect(endTime - startTime).toBeGreaterThan(1000);
+      srv.close();
+    });
+    it('should execute a a sleep until step', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+      });
+      const { createWorkflow, createStep } = init(inngest);
+      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
+      const step1 = createStep({
+        id: 'step1',
+        execute,
+        inputSchema: z.object({}),
+        outputSchema: z.object({ result: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: async ({ inputData }) => {
+          return { result: 'slept successfully: ' + inputData.result };
+        },
+        inputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
       });
-      await new Promise(resolve => setTimeout(resolve, 2000));
-      const run = workflow.createRun();
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          result: z.string(),
+        }),
+        steps: [step1],
+      });
+      workflow
+        .then(step1)
+        .sleepUntil(new Date(Date.now() + 1000))
+        .then(step2)
+        .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 run = await workflow.createRunAsync();
       const startTime = Date.now();
       const result = await run.start({ inputData: {} });
       const endTime = Date.now();
@@ -352,7 +641,195 @@ describe('MastraInngestWorkflow', () => {
       srv.close();
     });
-    it('should execute a a sleep until step', async ctx => {
+    it('should execute a sleep until step with fn parameter', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+      });
+      const { createWorkflow, createStep } = init(inngest);
+      const execute = vi.fn<any>().mockResolvedValue({ value: 1000 });
+      const step1 = createStep({
+        id: 'step1',
+        execute,
+        inputSchema: z.object({}),
+        outputSchema: z.object({ value: z.number() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: async ({ inputData }) => {
+          return { value: inputData.value + 1000 };
+        },
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
+      });
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          value: z.number(),
+        }),
+        steps: [step1],
+      });
+      workflow
+        .then(step1)
+        .sleepUntil(async ({ inputData }) => {
+          return new Date(Date.now() + inputData.value);
+        })
+        .then(step2)
+        .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 run = await workflow.createRunAsync();
+      const startTime = Date.now();
+      const result = await run.start({ inputData: {} });
+      const endTime = Date.now();
+      expect(execute).toHaveBeenCalled();
+      expect(result.steps['step1']).toMatchObject({
+        status: 'success',
+        output: { value: 1000 },
+        // payload: {},
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
+      });
+      expect(result.steps['step2']).toMatchObject({
+        status: 'success',
+        output: { value: 2000 },
+        // payload: { result: 'success' },
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
+      });
+      expect(endTime - startTime).toBeGreaterThan(1000);
+      srv.close();
+    });
+    it('should execute a a waitForEvent step', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+      });
+      const { createWorkflow, createStep } = init(inngest);
+      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
+      const step1 = createStep({
+        id: 'step1',
+        execute,
+        inputSchema: z.object({}),
+        outputSchema: z.object({ result: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: async ({ inputData, resumeData }) => {
+          return { result: inputData.result, resumed: resumeData };
+        },
+        inputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ result: z.string(), resumed: z.any() }),
+        resumeSchema: z.any(),
+      });
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          result: z.string(),
+          resumed: z.any(),
+        }),
+        steps: [step1],
+      });
+      workflow.then(step1).waitForEvent('hello-event', step2).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 run = await workflow.createRunAsync();
+      const startTime = Date.now();
+      setTimeout(() => {
+        run.sendEvent('hello-event', { data: 'hello' });
+      }, 1000);
+      const result = await run.start({ inputData: {} });
+      const endTime = Date.now();
+      expect(execute).toHaveBeenCalled();
+      expect(result.steps['step1']).toMatchObject({
+        status: 'success',
+        output: { result: 'success' },
+        // payload: {},
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
+      });
+      expect(result.steps['step2']).toMatchObject({
+        status: 'success',
+        output: { result: 'success', resumed: { data: 'hello' } },
+        payload: { result: 'success' },
+        // resumePayload: { data: 'hello' },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
+      expect(endTime - startTime).toBeGreaterThan(1000);
+      srv.close();
+    });
+    it('should execute a a waitForEvent step after timeout', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -369,11 +846,12 @@ describe('MastraInngestWorkflow', () => {
       });
       const step2 = createStep({
         id: 'step2',
-        execute: async ({ inputData }) => {
-          return { result: 'slept successfully: ' + inputData.result };
+        execute: async ({ inputData, resumeData }) => {
+          return { result: inputData.result, resumed: resumeData };
         },
         inputSchema: z.object({ result: z.string() }),
-        outputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ result: z.string(), resumed: z.any() }),
+        resumeSchema: z.any(),
       });
       const workflow = createWorkflow({
@@ -381,15 +859,12 @@ describe('MastraInngestWorkflow', () => {
         inputSchema: z.object({}),
         outputSchema: z.object({
           result: z.string(),
+          resumed: z.any(),
         }),
         steps: [step1],
       });
-      workflow
-        .then(step1)
-        .sleepUntil(new Date(Date.now() + 1000))
-        .then(step2)
-        .commit();
+      workflow.then(step1).waitForEvent('hello-event', step2, { timeout: 1000 }).commit();
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -411,13 +886,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const startTime = Date.now();
       const result = await run.start({ inputData: {} });
       const endTime = Date.now();
@@ -432,41 +907,44 @@ describe('MastraInngestWorkflow', () => {
       });
       expect(result.steps['step2']).toMatchObject({
-        status: 'success',
-        output: { result: 'slept successfully: success' },
-        // payload: { result: 'success' },
-        // startedAt: expect.any(Number),
-        // endedAt: expect.any(Number),
+        status: 'failed',
+        error: expect.any(String),
+        payload: { result: 'success' },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
       });
       expect(endTime - startTime).toBeGreaterThan(1000);
       srv.close();
     });
+  });
-    it('should execute a a waitForEvent step', async ctx => {
+  describe('abort', () => {
+    it('should be able to abort workflow execution in between steps', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
       });
       const { createWorkflow, createStep } = init(inngest);
-      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
       const step1 = createStep({
         id: 'step1',
-        execute,
-        inputSchema: z.object({}),
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
         outputSchema: z.object({ result: z.string() }),
       });
       const step2 = createStep({
         id: 'step2',
-        execute: async ({ inputData, resumeData }) => {
-          return { result: inputData.result, resumed: resumeData };
+        execute: async ({ inputData }) => {
+          return { result: 'step2: ' + inputData.result };
         },
         inputSchema: z.object({ result: z.string() }),
-        outputSchema: z.object({ result: z.string(), resumed: z.any() }),
-        resumeSchema: z.any(),
+        outputSchema: z.object({ result: z.string() }),
       });
       const workflow = createWorkflow({
@@ -474,12 +952,11 @@ describe('MastraInngestWorkflow', () => {
         inputSchema: z.object({}),
         outputSchema: z.object({
           result: z.string(),
-          resumed: z.any(),
         }),
-        steps: [step1],
+        steps: [step1, step2],
       });
-      workflow.then(step1).waitForEvent('hello-event', step2).commit();
+      workflow.then(step1).sleep(2000).then(step2).commit();
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -501,66 +978,75 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
+      const run = await workflow.createRunAsync();
+      const p = run.start({ inputData: { value: 'test' } });
-      const run = workflow.createRun();
-      const startTime = Date.now();
       setTimeout(() => {
-        run.sendEvent('hello-event', { data: 'hello' });
+        run.cancel();
       }, 1000);
-      const result = await run.start({ inputData: {} });
-      const endTime = Date.now();
-      expect(execute).toHaveBeenCalled();
-      expect(result.steps['step1']).toMatchObject({
-        status: 'success',
-        output: { result: 'success' },
-        // payload: {},
-        // startedAt: expect.any(Number),
-        // endedAt: expect.any(Number),
-      });
+      const result = await p;
-      expect(result.steps['step2']).toMatchObject({
+      srv.close();
+      expect(result.status).toBe('canceled');
+      expect(result.steps['step1']).toEqual({
         status: 'success',
-        output: { result: 'success', resumed: { data: 'hello' } },
-        payload: { result: 'success' },
-        // resumePayload: { data: 'hello' },
+        output: { result: 'step1: test' },
+        payload: { value: 'test' },
         startedAt: expect.any(Number),
         endedAt: expect.any(Number),
       });
-      expect(endTime - startTime).toBeGreaterThan(1000);
-      srv.close();
+      expect(result.steps['step2']).toBeUndefined();
     });
-    it('should execute a a waitForEvent step after timeout', async ctx => {
+    it('should be able to abort workflow execution during a step', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
       });
       const { createWorkflow, createStep } = init(inngest);
-      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
       const step1 = createStep({
         id: 'step1',
-        execute,
-        inputSchema: z.object({}),
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
         outputSchema: z.object({ result: z.string() }),
       });
       const step2 = createStep({
         id: 'step2',
-        execute: async ({ inputData, resumeData }) => {
-          return { result: inputData.result, resumed: resumeData };
+        execute: async ({ inputData, abortSignal, abort }) => {
+          console.log('abort signal', abortSignal);
+          const timeout: Promise<string> = new Promise((resolve, _reject) => {
+            const ref = setTimeout(() => {
+              resolve('step2: ' + inputData.result);
+            }, 5000);
+            abortSignal.addEventListener('abort', () => {
+              resolve('');
+              clearTimeout(ref);
+            });
+          });
+          const result = await timeout;
+          if (abortSignal.aborted) {
+            return abort();
+          }
+          return { result };
         },
         inputSchema: z.object({ result: z.string() }),
-        outputSchema: z.object({ result: z.string(), resumed: z.any() }),
-        resumeSchema: z.any(),
+        outputSchema: z.object({ result: z.string() }),
       });
       const workflow = createWorkflow({
@@ -568,12 +1054,11 @@ describe('MastraInngestWorkflow', () => {
         inputSchema: z.object({}),
         outputSchema: z.object({
           result: z.string(),
-          resumed: z.any(),
         }),
-        steps: [step1],
+        steps: [step1, step2],
       });
-      workflow.then(step1).waitForEvent('hello-event', step2, { timeout: 1000 }).commit();
+      workflow.then(step1).then(step2).commit();
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -595,37 +1080,40 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
-      const startTime = Date.now();
-      const result = await run.start({ inputData: {} });
-      const endTime = Date.now();
+      const run = await workflow.createRunAsync();
+      const p = run.start({ inputData: { value: 'test' } });
-      expect(execute).toHaveBeenCalled();
-      expect(result.steps['step1']).toMatchObject({
-        status: 'success',
-        output: { result: 'success' },
-        // payload: {},
-        // startedAt: expect.any(Number),
-        // endedAt: expect.any(Number),
-      });
+      setTimeout(() => {
+        run.cancel();
+      }, 1000);
-      expect(result.steps['step2']).toMatchObject({
-        status: 'failed',
-        error: expect.any(String),
-        payload: { result: 'success' },
+      const result = await p;
+      console.log('result', result);
+      srv.close();
+      expect(result.status).toBe('canceled');
+      expect(result.steps['step1']).toEqual({
+        status: 'success',
+        output: { result: 'step1: test' },
+        payload: { value: 'test' },
         startedAt: expect.any(Number),
         endedAt: expect.any(Number),
       });
-      expect(endTime - startTime).toBeGreaterThan(1000);
-      srv.close();
+      // expect(result.steps['step2']).toEqual({
+      //   status: 'canceled',
+      //   payload: { result: 'step1: test' },
+      //   output: undefined,
+      //   startedAt: expect.any(Number),
+      //   endedAt: expect.any(Number),
+      // });
     });
   });
@@ -681,12 +1169,14 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: { inputData: 'test-input' } });
       expect(result.steps.step1).toMatchObject({ status: 'success', output: { result: 'success' } });
@@ -768,12 +1258,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: { inputValue: 'test-input' } });
       expect(step1Action).toHaveBeenCalled();
@@ -835,12 +1326,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await run.start({ inputData: { inputData: 'test-input' } });
       expect(execute).toHaveBeenCalledWith(
@@ -910,12 +1402,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: { cool: 'test-input' } });
       expect(execute).toHaveBeenCalledWith(
@@ -992,12 +1485,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await run.start({ inputData: {} });
       expect(step2Action).toHaveBeenCalledWith(
@@ -1095,12 +1589,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: { status: 'success' } });
       srv.close();
@@ -1171,12 +1666,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       let result: Awaited<ReturnType<typeof run.start>> | undefined = undefined;
       try {
         result = await run.start({ inputData: {} });
@@ -1276,12 +1772,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: { status: 'success' } });
       srv.close();
@@ -1359,12 +1856,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: { count: 5 } });
       srv.close();
@@ -1426,13 +1924,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await expect(run.start({ inputData: {} })).resolves.toMatchObject({
         steps: {
@@ -1510,13 +2008,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
       expect(result.steps).toMatchObject({
@@ -1604,13 +2102,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = mainWorkflow.createRun();
+      const run = await mainWorkflow.createRunAsync();
       const result = await run.start({ inputData: {} });
       expect(result.steps).toMatchObject({
@@ -1732,13 +2230,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
       expect(step2Action).toHaveBeenCalled();
@@ -1834,13 +2332,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { target: 10, value: 0 } });
       expect(increment).toHaveBeenCalledTimes(12);
@@ -1937,13 +2435,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { target: 10, value: 0 } });
       expect(increment).toHaveBeenCalledTimes(12);
@@ -2026,13 +2524,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: [{ value: 1 }, { value: 22 }, { value: 333 }] });
       const endTime = Date.now();
@@ -2179,13 +2677,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 1 } });
       expect(start).toHaveBeenCalledTimes(1);
@@ -2328,15 +2826,17 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 6 } });
+      srv.close();
       expect(start).toHaveBeenCalledTimes(1);
       expect(other).toHaveBeenCalledTimes(1);
       expect(final).toHaveBeenCalledTimes(1);
@@ -2344,8 +2844,6 @@ describe('MastraInngestWorkflow', () => {
       expect(result.steps['else-branch'].output).toMatchObject({ finalValue: 26 + 6 + 1 });
       // @ts-ignore
       expect(result.steps.start.output).toMatchObject({ newValue: 7 });
-      srv.close();
     });
   });
@@ -2400,7 +2898,7 @@ describe('MastraInngestWorkflow', () => {
       ).rejects.toThrow();
       // Should pass validation
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await run.start({
         inputData: {
           required: 'test',
@@ -2500,19 +2998,19 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
+      srv.close();
       expect(result.steps['nested-a']).toMatchObject({ status: 'success', output: { result: 'success3' } });
       expect(result.steps['nested-b']).toMatchObject({ status: 'success', output: { result: 'success5' } });
-      srv.close();
     });
   });
@@ -2566,21 +3064,21 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
+      srv.close();
       expect(result.steps.step1).toMatchObject({ status: 'success', output: { result: 'success' } });
       expect(result.steps.step2).toMatchObject({ status: 'failed', error: 'Step failed' });
       expect(step1.execute).toHaveBeenCalledTimes(1);
       expect(step2.execute).toHaveBeenCalledTimes(1); // 0 retries + 1 initial call
-      srv.close();
     });
     // Need to fix so we can throw for inngest to recognize retries
@@ -2629,7 +3127,7 @@ describe('MastraInngestWorkflow', () => {
       workflow.then(step1).then(step2).commit();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ inputData: {} });
       expect(result.steps.step1).toMatchObject({ status: 'success', output: { result: 'success' } });
@@ -2698,13 +3196,14 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const result = await workflow.createRun().start({ inputData: {} });
+      const run = await workflow.createRunAsync();
+      const result = await run.start({ inputData: {} });
       srv.close();
@@ -2769,13 +3268,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       // Start watching the workflow
       let cnt = 0;
@@ -2786,7 +3285,9 @@ describe('MastraInngestWorkflow', () => {
       });
       const executionResult = await run.start({ inputData: {} });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      srv.close();
       expect(cnt).toBe(5);
       expect(resps.length).toBe(5);
@@ -2898,8 +3399,6 @@ describe('MastraInngestWorkflow', () => {
         status: 'success',
         output: { result: 'success2' },
       });
-      srv.close();
     });
     it('should unsubscribe from transitions when unwatch is called', async ctx => {
@@ -2955,16 +3454,16 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
       const onTransition = vi.fn();
       const onTransition2 = vi.fn();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       run.watch(onTransition);
       run.watch(onTransition2);
@@ -2974,7 +3473,7 @@ describe('MastraInngestWorkflow', () => {
       expect(onTransition).toHaveBeenCalledTimes(5);
       expect(onTransition2).toHaveBeenCalledTimes(5);
-      const run2 = workflow.createRun();
+      const run2 = await workflow.createRunAsync();
       run2.watch(onTransition2);
@@ -2983,7 +3482,7 @@ describe('MastraInngestWorkflow', () => {
       expect(onTransition).toHaveBeenCalledTimes(5);
       expect(onTransition2).toHaveBeenCalledTimes(10);
-      const run3 = workflow.createRun();
+      const run3 = await workflow.createRunAsync();
       run3.watch(onTransition);
@@ -3018,8 +3517,8 @@ describe('MastraInngestWorkflow', () => {
         outputSchema: z.object({}),
         steps: [],
       });
-      const run = workflow.createRun();
-      const run2 = workflow.createRun({ runId: run.runId });
+      const run = await workflow.createRunAsync();
+      const run2 = await workflow.createRunAsync({ runId: run.runId });
       expect(run.runId).toBeDefined();
       expect(run2.runId).toBeDefined();
@@ -3127,13 +3626,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = promptEvalWorkflow.createRun();
+      const run = await promptEvalWorkflow.createRunAsync();
       // Create a promise to track when the workflow is ready to resume
       let resolveWorkflowSuspended: (value: unknown) => void;
@@ -3277,13 +3776,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const started = run.start({ inputData: { input: 'test' } });
@@ -3315,13 +3814,13 @@ describe('MastraInngestWorkflow', () => {
       const initialResult = await started;
+      srv.close();
       expect(initialResult.steps.humanIntervention.status).toBe('suspended');
       expect(initialResult.steps.explainResponse).toBeUndefined();
       expect(humanInterventionAction).toHaveBeenCalledTimes(2);
       expect(explainResponseAction).not.toHaveBeenCalled();
-      srv.close();
       if (!result) {
         throw new Error('Resume failed to return a result');
       }
@@ -3479,13 +3978,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const started = run.start({ inputData: { input: 'test' } });
       let improvedResponseResultPromise: Promise<any | undefined>;
@@ -3536,11 +4035,12 @@ describe('MastraInngestWorkflow', () => {
       // @ts-ignore
       const improvedResponseResult = await improvedResponseResultPromise;
+      srv.close();
       expect(improvedResponseResult?.steps.humanIntervention.status).toBe('suspended');
       expect(improvedResponseResult?.steps.improveResponse.status).toBe('success');
       expect(improvedResponseResult?.steps.evaluateImprovedResponse.status).toBe('success');
-      srv.close();
       if (!result) {
         throw new Error('Resume failed to return a result');
       }
@@ -3673,13 +4173,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = promptEvalWorkflow.createRun();
+      const run = await promptEvalWorkflow.createRunAsync();
       const initialResult = await run.start({ inputData: { input: 'test' } });
       expect(initialResult.steps.promptAgent.status).toBe('suspended');
@@ -3690,7 +4190,11 @@ describe('MastraInngestWorkflow', () => {
       expect(initialResult.steps).toMatchObject({
         input: { input: 'test' },
         getUserInput: { status: 'success', output: { userInput: 'test input' } },
-        promptAgent: { status: 'suspended', payload: { testPayload: 'hello' } },
+        promptAgent: {
+          status: 'suspended',
+          suspendedPayload: { testPayload: 'hello' },
+          payload: { userInput: 'test input' },
+        },
       });
       const newCtx = {
@@ -3728,6 +4232,9 @@ describe('MastraInngestWorkflow', () => {
           completenessScore: { score: 0.7 },
         },
       });
+      srv.close();
       if (!secondResumeResult) {
         throw new Error('Resume failed to return a result');
       }
@@ -3750,8 +4257,6 @@ describe('MastraInngestWorkflow', () => {
       });
       expect(promptAgentAction).toHaveBeenCalledTimes(2);
-      srv.close();
     });
   });
@@ -3797,14 +4302,14 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
       // Access new instance properties directly - should work without warning
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await run.start({ inputData: {} });
       expect(telemetry).toBeDefined();
@@ -3901,13 +4406,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({
         inputData: { prompt1: 'Capital of France, just the name', prompt2: 'Capital of UK, just the name' },
       });
@@ -4038,13 +4543,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({
         inputData: { prompt1: 'Capital of France, just the name', prompt2: 'Capital of UK, just the name' },
       });
@@ -4181,13 +4686,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
       srv.close();
@@ -4333,13 +4838,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
       srv.close();
@@ -4493,12 +4998,13 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
-        const run = counterWorkflow.createRun();
+        const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
         srv.close();
@@ -4652,12 +5158,13 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
-        const run = counterWorkflow.createRun();
+        const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
         srv.close();
@@ -4849,12 +5356,13 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
-        const run = counterWorkflow.createRun();
+        const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 1 } });
         srv.close();
@@ -5002,13 +5510,13 @@ describe('MastraInngestWorkflow', () => {
         const app = await createHonoServer(mastra);
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
-        await new Promise(resolve => setTimeout(resolve, 2000));
+        }));
+        await resetInngest();
-        const run = counterWorkflow.createRun();
+        const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
         expect(begin).toHaveBeenCalledTimes(1);
@@ -5153,12 +5661,13 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
-        const run = counterWorkflow.createRun();
+        const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
         const results = result.steps;
@@ -5334,13 +5843,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
       expect(passthroughStep.execute).toHaveBeenCalledTimes(2);
@@ -5496,13 +6005,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
-      const run = counterWorkflow.createRun();
+      const run = await counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
       srv.close();
@@ -5571,14 +6080,14 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      }));
+      await resetInngest();
       // Access new instance properties directly - should work without warning
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await run.start({ inputData: {} });
       srv.close();
@@ -5634,12 +6143,13 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       const result = await run.start({ runtimeContext });
       srv.close();
@@ -5648,7 +6158,7 @@ describe('MastraInngestWorkflow', () => {
       expect(result.steps.step1.output.injectedValue).toBe(testValue);
     });
-    it('should inject runtimeContext dependencies into steps during resume', async ctx => {
+    it.skip('should inject runtimeContext dependencies into steps during resume', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -5692,7 +6202,7 @@ describe('MastraInngestWorkflow', () => {
       });
       workflow.then(step).commit();
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await run.start({ runtimeContext });
       const resumeruntimeContext = new RuntimeContext();
@@ -5733,11 +6243,81 @@ describe('MastraInngestWorkflow', () => {
       const workflow = createWorkflow({
         id: 'test-workflow',
         inputSchema: z.object({}),
-        outputSchema: z.object({
-          hasEngine: z.boolean(),
-        }),
+        outputSchema: z.object({
+          hasEngine: z.boolean(),
+        }),
+      });
+      workflow.then(step).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 run = await workflow.createRunAsync();
+      const result = await run.start({});
+      srv.close();
+      // @ts-ignore
+      expect(result?.steps.step1.output.hasEngine).toBe(true);
+    });
+  });
+  describe('Streaming', () => {
+    it('should generate a stream', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+      const { createWorkflow, createStep } = init(inngest);
+      const step1Action = vi.fn<any>().mockResolvedValue({ result: 'success1' });
+      const step2Action = vi.fn<any>().mockResolvedValue({ result: 'success2' });
+      const step1 = createStep({
+        id: 'step1',
+        execute: step1Action,
+        inputSchema: z.object({}),
+        outputSchema: z.object({ value: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: step2Action,
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({}),
+      });
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        outputSchema: z.object({}),
+        steps: [step1, step2],
       });
-      workflow.then(step).commit();
+      workflow.then(step1).then(step2).commit();
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -5759,23 +6339,126 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
+      }));
+      await resetInngest();
+      const runId = 'test-run-id';
+      let watchData: StreamEvent[] = [];
+      const run = await workflow.createRunAsync({
+        runId,
       });
-      const run = workflow.createRun();
-      const result = await run.start({});
+      await resetInngest();
+      const { stream, getWorkflowState } = run.stream({ inputData: {} });
+      // Start watching the workflow
+      const collectedStreamData: StreamEvent[] = [];
+      for await (const data of stream) {
+        collectedStreamData.push(JSON.parse(JSON.stringify(data)));
+      }
+      watchData = collectedStreamData;
+      const executionResult = await getWorkflowState();
+      await resetInngest();
       srv.close();
-      // @ts-ignore
-      expect(result?.steps.step1.output.hasEngine).toBe(true);
+      expect(watchData.length).toBe(8);
+      expect(watchData).toMatchObject([
+        {
+          payload: {
+            runId: 'test-run-id',
+          },
+          type: 'start',
+        },
+        {
+          payload: {
+            id: 'step1',
+            status: 'running',
+          },
+          type: 'step-start',
+        },
+        {
+          payload: {
+            id: 'step1',
+            endedAt: expect.any(Number),
+            startedAt: expect.any(Number),
+            payload: {},
+            output: {
+              result: 'success1',
+            },
+            status: 'success',
+          },
+          type: 'step-result',
+        },
+        {
+          payload: {
+            id: 'step1',
+            metadata: {},
+          },
+          type: 'step-finish',
+        },
+        {
+          payload: {
+            id: 'step2',
+            status: 'running',
+          },
+          type: 'step-start',
+        },
+        {
+          payload: {
+            id: 'step2',
+            endedAt: expect.any(Number),
+            startedAt: expect.any(Number),
+            payload: {
+              result: 'success1',
+            },
+            output: {
+              result: 'success2',
+            },
+            status: 'success',
+          },
+          type: 'step-result',
+        },
+        {
+          payload: {
+            id: 'step2',
+            metadata: {},
+          },
+          type: 'step-finish',
+        },
+        {
+          payload: {
+            runId: 'test-run-id',
+          },
+          type: 'finish',
+        },
+      ]);
+      // Verify execution completed successfully
+      expect(executionResult.steps.step1).toMatchObject({
+        status: 'success',
+        output: { result: 'success1' },
+        payload: {},
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
+      expect(executionResult.steps.step2).toMatchObject({
+        status: 'success',
+        output: { result: 'success2' },
+        payload: {
+          result: 'success1',
+        },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
     });
-  });
-  describe('Streaming', () => {
-    it('should generate a stream', async ctx => {
+    it('should handle basic sleep waiting flow', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -5806,7 +6489,7 @@ describe('MastraInngestWorkflow', () => {
         outputSchema: z.object({}),
         steps: [step1, step2],
       });
-      workflow.then(step1).then(step2).commit();
+      workflow.then(step1).sleep(1000).then(step2).commit();
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -5828,18 +6511,19 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
       const runId = 'test-run-id';
       let watchData: StreamEvent[] = [];
-      const run = workflow.createRun({
+      const run = await workflow.createRunAsync({
         runId,
       });
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
       const { stream, getWorkflowState } = run.stream({ inputData: {} });
@@ -5852,73 +6536,112 @@ describe('MastraInngestWorkflow', () => {
       const executionResult = await getWorkflowState();
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
       srv.close();
-      expect(watchData.length).toBe(8);
-      expect(watchData).toMatchInlineSnapshot(`
-        [
-          {
-            "payload": {
-              "runId": "test-run-id",
-            },
-            "type": "start",
+      expect(watchData.length).toBe(11);
+      expect(watchData).toMatchObject([
+        {
+          payload: {
+            runId: 'test-run-id',
           },
-          {
-            "payload": {
-              "id": "step1",
-            },
-            "type": "step-start",
+          type: 'start',
+        },
+        {
+          payload: {
+            id: 'step1',
+            startedAt: expect.any(Number),
+            status: 'running',
+            payload: {},
           },
-          {
-            "payload": {
-              "id": "step1",
-              "output": {
-                "result": "success1",
-              },
-              "status": "success",
+          type: 'step-start',
+        },
+        {
+          payload: {
+            id: 'step1',
+            output: {
+              result: 'success1',
             },
-            "type": "step-result",
+            endedAt: expect.any(Number),
+            status: 'success',
           },
-          {
-            "payload": {
-              "id": "step1",
-              "metadata": {},
-            },
-            "type": "step-finish",
+          type: 'step-result',
+        },
+        {
+          payload: {
+            id: 'step1',
+            metadata: {},
           },
-          {
-            "payload": {
-              "id": "step2",
+          type: 'step-finish',
+        },
+        {
+          payload: {
+            id: expect.any(String),
+            startedAt: expect.any(Number),
+            status: 'waiting',
+            payload: {
+              result: 'success1',
             },
-            "type": "step-start",
           },
-          {
-            "payload": {
-              "id": "step2",
-              "output": {
-                "result": "success2",
-              },
-              "status": "success",
+          type: 'step-waiting',
+        },
+        {
+          payload: {
+            id: expect.any(String),
+            endedAt: expect.any(Number),
+            startedAt: expect.any(Number),
+            status: 'success',
+            output: {
+              result: 'success1',
             },
-            "type": "step-result",
           },
-          {
-            "payload": {
-              "id": "step2",
-              "metadata": {},
+          type: 'step-result',
+        },
+        {
+          type: 'step-finish',
+          payload: {
+            id: expect.any(String),
+            metadata: {},
+          },
+        },
+        {
+          payload: {
+            id: 'step2',
+            payload: {
+              result: 'success1',
             },
-            "type": "step-finish",
+            startedAt: expect.any(Number),
+            status: 'running',
           },
-          {
-            "payload": {
-              "runId": "test-run-id",
+          type: 'step-start',
+        },
+        {
+          payload: {
+            id: 'step2',
+            output: {
+              result: 'success2',
             },
-            "type": "finish",
+            endedAt: expect.any(Number),
+            status: 'success',
+          },
+          type: 'step-result',
+        },
+        {
+          payload: {
+            id: 'step2',
+            metadata: {},
+          },
+          type: 'step-finish',
+        },
+        {
+          payload: {
+            runId: 'test-run-id',
           },
-        ]
-      `);
+          type: 'finish',
+        },
+      ]);
       // Verify execution completed successfully
       expect(executionResult.steps.step1).toMatchObject({
         status: 'success',
@@ -5938,7 +6661,7 @@ describe('MastraInngestWorkflow', () => {
       });
     });
-    it('should handle basic sleep waiting flow', async ctx => {
+    it('should handle basic sleep waiting flow with fn parameter', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -5947,19 +6670,19 @@ describe('MastraInngestWorkflow', () => {
       const { createWorkflow, createStep } = init(inngest);
-      const step1Action = vi.fn<any>().mockResolvedValue({ result: 'success1' });
-      const step2Action = vi.fn<any>().mockResolvedValue({ result: 'success2' });
+      const step1Action = vi.fn<any>().mockResolvedValue({ value: 1000 });
+      const step2Action = vi.fn<any>().mockResolvedValue({ value: 2000 });
       const step1 = createStep({
         id: 'step1',
         execute: step1Action,
         inputSchema: z.object({}),
-        outputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ value: z.number() }),
       });
       const step2 = createStep({
         id: 'step2',
         execute: step2Action,
-        inputSchema: z.object({ value: z.string() }),
+        inputSchema: z.object({ value: z.number() }),
         outputSchema: z.object({}),
       });
@@ -5969,7 +6692,13 @@ describe('MastraInngestWorkflow', () => {
         outputSchema: z.object({}),
         steps: [step1, step2],
       });
-      workflow.then(step1).sleep(1000).then(step2).commit();
+      workflow
+        .then(step1)
+        .sleep(async ({ inputData }) => {
+          return inputData.value;
+        })
+        .then(step2)
+        .commit();
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -5991,18 +6720,19 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
       const runId = 'test-run-id';
       let watchData: StreamEvent[] = [];
-      const run = workflow.createRun({
+      const run = await workflow.createRunAsync({
         runId,
       });
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
       const { stream, getWorkflowState } = run.stream({ inputData: {} });
@@ -6015,11 +6745,11 @@ describe('MastraInngestWorkflow', () => {
       const executionResult = await getWorkflowState();
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
       srv.close();
-      expect(watchData.length).toBe(9);
+      expect(watchData.length).toBe(11);
       expect(watchData).toMatchObject([
         {
           payload: {
@@ -6030,6 +6760,9 @@ describe('MastraInngestWorkflow', () => {
         {
           payload: {
             id: 'step1',
+            startedAt: expect.any(Number),
+            status: 'running',
+            payload: {},
           },
           type: 'step-start',
         },
@@ -6037,8 +6770,9 @@ describe('MastraInngestWorkflow', () => {
           payload: {
             id: 'step1',
             output: {
-              result: 'success1',
+              value: 1000,
             },
+            endedAt: expect.any(Number),
             status: 'success',
           },
           type: 'step-result',
@@ -6051,12 +6785,43 @@ describe('MastraInngestWorkflow', () => {
           type: 'step-finish',
         },
         {
-          payload: {},
+          payload: {
+            id: expect.any(String),
+            startedAt: expect.any(Number),
+            status: 'waiting',
+            payload: {
+              value: 1000,
+            },
+          },
           type: 'step-waiting',
         },
+        {
+          payload: {
+            id: expect.any(String),
+            endedAt: expect.any(Number),
+            startedAt: expect.any(Number),
+            status: 'success',
+            output: {
+              value: 1000,
+            },
+          },
+          type: 'step-result',
+        },
+        {
+          type: 'step-finish',
+          payload: {
+            id: expect.any(String),
+            metadata: {},
+          },
+        },
         {
           payload: {
             id: 'step2',
+            payload: {
+              value: 1000,
+            },
+            startedAt: expect.any(Number),
+            status: 'running',
           },
           type: 'step-start',
         },
@@ -6064,8 +6829,9 @@ describe('MastraInngestWorkflow', () => {
           payload: {
             id: 'step2',
             output: {
-              result: 'success2',
+              value: 2000,
             },
+            endedAt: expect.any(Number),
             status: 'success',
           },
           type: 'step-result',
@@ -6084,19 +6850,20 @@ describe('MastraInngestWorkflow', () => {
           type: 'finish',
         },
       ]);
       // Verify execution completed successfully
       expect(executionResult.steps.step1).toMatchObject({
         status: 'success',
-        output: { result: 'success1' },
+        output: { value: 1000 },
         payload: {},
         startedAt: expect.any(Number),
         endedAt: expect.any(Number),
       });
       expect(executionResult.steps.step2).toMatchObject({
         status: 'success',
-        output: { result: 'success2' },
+        output: { value: 2000 },
         payload: {
-          result: 'success1',
+          value: 1000,
         },
         startedAt: expect.any(Number),
         endedAt: expect.any(Number),
@@ -6156,18 +6923,19 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
+      await resetInngest();
       const runId = 'test-run-id';
       let watchData: StreamEvent[] = [];
-      const run = workflow.createRun({
+      const run = await workflow.createRunAsync({
         runId,
       });
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
       const { stream, getWorkflowState } = run.stream({ inputData: {} });
@@ -6187,7 +6955,7 @@ describe('MastraInngestWorkflow', () => {
       const executionResult = await getWorkflowState();
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
       srv.close();
@@ -6381,14 +7149,14 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
-      const run = promptEvalWorkflow.createRun();
+      const run = await promptEvalWorkflow.createRunAsync();
       const { stream, getWorkflowState } = run.stream({ inputData: { input: 'test' } });
@@ -6570,17 +7338,17 @@ describe('MastraInngestWorkflow', () => {
       const app = await createHonoServer(mastra);
-      const srv = serve({
+      const srv = (globServer = serve({
         fetch: app.fetch,
         port: (ctx as any).handlerPort,
-      });
+      }));
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
-      const run = workflow.createRun({
+      const run = await workflow.createRunAsync({
         runId: 'test-run-id',
       });
-      const { stream } = await run.stream({
+      const { stream } = run.stream({
         inputData: {
           prompt1: 'Capital of France, just the name',
           prompt2: 'Capital of UK, just the name',