@mastra/inngest 0.0.0-working-memory-per-user-20250620163010 → 0.0.0-zod-v4-compat-part-2-20250822105954

package/src/index.test.ts

@@ -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,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();
@@ -352,6 +455,100 @@ describe('MastraInngestWorkflow', () => {
       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',
@@ -411,13 +608,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();
@@ -444,6 +641,100 @@ describe('MastraInngestWorkflow', () => {
       srv.close();
     });
 
+    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',
@@ -501,13 +792,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();
       setTimeout(() => {
         run.sendEvent('hello-event', { data: 'hello' });
@@ -595,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();
@@ -629,6 +920,203 @@ describe('MastraInngestWorkflow', () => {
     });
   });
 
+  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 step1 = createStep({
+        id: 'step1',
+        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 }) => {
+          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({}),
+        outputSchema: z.object({
+          result: z.string(),
+        }),
+        steps: [step1, step2],
+      });
+
+      workflow.then(step1).sleep(2000).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 p = run.start({ inputData: { value: 'test' } });
+
+      setTimeout(() => {
+        run.cancel();
+      }, 1000);
+
+      const result = await p;
+
+      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(result.steps['step2']).toBeUndefined();
+    });
+
+    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 step1 = createStep({
+        id: 'step1',
+        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, 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() }),
+      });
+
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        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();
+      const p = run.start({ inputData: { value: 'test' } });
+
+      setTimeout(() => {
+        run.cancel();
+      }, 1000);
+
+      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(result.steps['step2']).toEqual({
+      //   status: 'canceled',
+      //   payload: { result: 'step1: test' },
+      //   output: undefined,
+      //   startedAt: expect.any(Number),
+      //   endedAt: expect.any(Number),
+      // });
+    });
+  });
+
   describe('Variable Resolution', () => {
     it('should resolve trigger data', async ctx => {
       const inngest = new Inngest({
@@ -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,6 +4257,122 @@ describe('MastraInngestWorkflow', () => {
       });
 
       expect(promptAgentAction).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle consecutive nested workflows with suspend/resume', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1 = vi.fn().mockImplementation(async ({ resumeData, suspend }) => {
+        if (!resumeData?.suspect) {
+          return await suspend({ message: 'What is the suspect?' });
+        }
+        return { suspect: resumeData.suspect };
+      });
+      const step1Definition = createStep({
+        id: 'step-1',
+        inputSchema: z.object({ suspect: z.string() }),
+        outputSchema: z.object({ suspect: z.string() }),
+        suspendSchema: z.object({ message: z.string() }),
+        resumeSchema: z.object({ suspect: z.string() }),
+        execute: step1,
+      });
+
+      const step2 = vi.fn().mockImplementation(async ({ resumeData, suspend }) => {
+        if (!resumeData?.suspect) {
+          return await suspend({ message: 'What is the second suspect?' });
+        }
+        return { suspect: resumeData.suspect };
+      });
+      const step2Definition = createStep({
+        id: 'step-2',
+        inputSchema: z.object({ suspect: z.string() }),
+        outputSchema: z.object({ suspect: z.string() }),
+        suspendSchema: z.object({ message: z.string() }),
+        resumeSchema: z.object({ suspect: z.string() }),
+        execute: step2,
+      });
+
+      const subWorkflow1 = createWorkflow({
+        id: 'sub-workflow-1',
+        inputSchema: z.object({ suspect: z.string() }),
+        outputSchema: z.object({ suspect: z.string() }),
+      })
+        .then(step1Definition)
+        .commit();
+
+      const subWorkflow2 = createWorkflow({
+        id: 'sub-workflow-2',
+        inputSchema: z.object({ suspect: z.string() }),
+        outputSchema: z.object({ suspect: z.string() }),
+      })
+        .then(step2Definition)
+        .commit();
+
+      const mainWorkflow = createWorkflow({
+        id: 'main-workflow',
+        inputSchema: z.object({ suspect: z.string() }),
+        outputSchema: z.object({ suspect: z.string() }),
+      })
+        .then(subWorkflow1)
+        .then(subWorkflow2)
+        .commit();
+
+      const mastra = new Mastra({
+        logger: false,
+        storage: new DefaultStorage({
+          url: ':memory:',
+        }),
+        workflows: { mainWorkflow },
+        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 mainWorkflow.createRunAsync();
+
+      const initialResult = await run.start({ inputData: { suspect: 'initial-suspect' } });
+      expect(initialResult.status).toBe('suspended');
+
+      const firstResumeResult = await run.resume({
+        step: ['sub-workflow-1', 'step-1'],
+        resumeData: { suspect: 'first-suspect' },
+      });
+      expect(firstResumeResult.status).toBe('suspended');
+
+      const secondResumeResult = await run.resume({
+        step: ['sub-workflow-2', 'step-2'],
+        resumeData: { suspect: 'second-suspect' },
+      });
+
+      expect(step1).toHaveBeenCalledTimes(2);
+      expect(step2).toHaveBeenCalledTimes(2);
+      expect(secondResumeResult.status).toBe('success');
+      expect(secondResumeResult.steps['sub-workflow-1']).toMatchObject({
+        status: 'success',
+      });
+      expect(secondResumeResult.steps['sub-workflow-2']).toMatchObject({
+        status: 'success',
+      });
 
       srv.close();
     });
@@ -3797,14 +4420,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 +4524,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 +4661,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 +4804,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 +4956,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 +5116,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 +5276,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 +5474,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 +5628,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 +5779,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 +5961,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 +6123,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 +6198,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 +6261,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 +6276,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 +6320,7 @@ describe('MastraInngestWorkflow', () => {
       });
       workflow.then(step).commit();
 
-      const run = workflow.createRun();
+      const run = await workflow.createRunAsync();
       await run.start({ runtimeContext });
 
       const resumeruntimeContext = new RuntimeContext();
@@ -5709,6 +6337,176 @@ describe('MastraInngestWorkflow', () => {
       // @ts-ignore
       expect(result?.steps.step1.output.injectedValue).toBe(testValue + '2');
     });
+
+    it('should have access to runtimeContext from before suspension during workflow resume', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const testValue = 'test-dependency';
+      const resumeStep = createStep({
+        id: 'resume',
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
+        resumeSchema: z.object({ value: z.number() }),
+        suspendSchema: z.object({ message: z.string() }),
+        execute: async ({ inputData, resumeData, suspend }) => {
+          const finalValue = (resumeData?.value ?? 0) + inputData.value;
+
+          if (!resumeData?.value || finalValue < 10) {
+            return await suspend({
+              message: `Please provide additional information. now value is ${inputData.value}`,
+            });
+          }
+
+          return { value: finalValue };
+        },
+      });
+
+      const incrementStep = createStep({
+        id: 'increment',
+        inputSchema: z.object({
+          value: z.number(),
+        }),
+        outputSchema: z.object({
+          value: z.number(),
+        }),
+        execute: async ({ inputData, runtimeContext }) => {
+          runtimeContext.set('testKey', testValue);
+          return {
+            value: inputData.value + 1,
+          };
+        },
+      });
+
+      const incrementWorkflow = createWorkflow({
+        id: 'increment-workflow',
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
+      })
+        .then(incrementStep)
+        .then(resumeStep)
+        .then(
+          createStep({
+            id: 'final',
+            inputSchema: z.object({ value: z.number() }),
+            outputSchema: z.object({ value: z.number() }),
+            execute: async ({ inputData, runtimeContext }) => {
+              const testKey = runtimeContext.get('testKey');
+              expect(testKey).toBe(testValue);
+              return { value: inputData.value };
+            },
+          }),
+        )
+        .commit();
+
+      new Mastra({
+        logger: false,
+        storage: testStorage,
+        workflows: { incrementWorkflow },
+      });
+
+      const run = await incrementWorkflow.createRunAsync();
+      const result = await run.start({ inputData: { value: 0 } });
+      expect(result.status).toBe('suspended');
+
+      const resumeResult = await run.resume({
+        resumeData: { value: 21 },
+        step: ['resume'],
+      });
+
+      expect(resumeResult.status).toBe('success');
+    });
+
+    it('should not show removed runtimeContext values in subsequent steps', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+      const testValue = 'test-dependency';
+      const resumeStep = createStep({
+        id: 'resume',
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
+        resumeSchema: z.object({ value: z.number() }),
+        suspendSchema: z.object({ message: z.string() }),
+        execute: async ({ inputData, resumeData, suspend, runtimeContext }) => {
+          const finalValue = (resumeData?.value ?? 0) + inputData.value;
+
+          if (!resumeData?.value || finalValue < 10) {
+            return await suspend({
+              message: `Please provide additional information. now value is ${inputData.value}`,
+            });
+          }
+
+          const testKey = runtimeContext.get('testKey');
+          expect(testKey).toBe(testValue);
+
+          runtimeContext.delete('testKey');
+
+          return { value: finalValue };
+        },
+      });
+
+      const incrementStep = createStep({
+        id: 'increment',
+        inputSchema: z.object({
+          value: z.number(),
+        }),
+        outputSchema: z.object({
+          value: z.number(),
+        }),
+        execute: async ({ inputData, runtimeContext }) => {
+          runtimeContext.set('testKey', testValue);
+          return {
+            value: inputData.value + 1,
+          };
+        },
+      });
+
+      const incrementWorkflow = createWorkflow({
+        id: 'increment-workflow',
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
+      })
+        .then(incrementStep)
+        .then(resumeStep)
+        .then(
+          createStep({
+            id: 'final',
+            inputSchema: z.object({ value: z.number() }),
+            outputSchema: z.object({ value: z.number() }),
+            execute: async ({ inputData, runtimeContext }) => {
+              const testKey = runtimeContext.get('testKey');
+              expect(testKey).toBeUndefined();
+              return { value: inputData.value };
+            },
+          }),
+        )
+        .commit();
+
+      new Mastra({
+        logger: false,
+        storage: testStorage,
+        workflows: { incrementWorkflow },
+      });
+
+      const run = await incrementWorkflow.createRunAsync();
+      const result = await run.start({ inputData: { value: 0 } });
+      expect(result.status).toBe('suspended');
+
+      const resumeResult = await run.resume({
+        resumeData: { value: 21 },
+        step: ['resume'],
+      });
+
+      expect(resumeResult.status).toBe('success');
+    });
   });
 
   describe('Access to inngest step primitives', () => {
@@ -5733,11 +6531,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 +6627,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 +6777,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 +6799,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 +6824,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 +6949,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 +6958,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 +6980,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 +7008,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 +7033,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 +7048,9 @@ describe('MastraInngestWorkflow', () => {
         {
           payload: {
             id: 'step1',
+            startedAt: expect.any(Number),
+            status: 'running',
+            payload: {},
           },
           type: 'step-start',
         },
@@ -6037,8 +7058,9 @@ describe('MastraInngestWorkflow', () => {
           payload: {
             id: 'step1',
             output: {
-              result: 'success1',
+              value: 1000,
             },
+            endedAt: expect.any(Number),
             status: 'success',
           },
           type: 'step-result',
@@ -6051,12 +7073,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 +7117,9 @@ describe('MastraInngestWorkflow', () => {
           payload: {
             id: 'step2',
             output: {
-              result: 'success2',
+              value: 2000,
             },
+            endedAt: expect.any(Number),
             status: 'success',
           },
           type: 'step-result',
@@ -6084,19 +7138,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 +7211,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 +7243,7 @@ describe('MastraInngestWorkflow', () => {
 
       const executionResult = await getWorkflowState();
 
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
 
       srv.close();
 
@@ -6381,14 +7437,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 +7626,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',