@mastra/inngest 0.0.0-custom-instrumentation-20250626084921 → 0.0.0-custom-instrumentation-20250708222033

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,27 +20,27 @@ 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({
@@ -105,15 +103,17 @@ 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();
+      console.log('running');
       const result = await run.start({ inputData: { value: 'bail' } });
-
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      console.log('result', result);
 
       expect(result.steps['step1']).toEqual({
         status: 'success',
@@ -192,11 +192,11 @@ 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 result = await run.start({ inputData: {} });
@@ -267,11 +267,11 @@ 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 result = await run.start({ inputData: {} });
@@ -348,11 +348,11 @@ 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 result = await run.start({ inputData: {} });
@@ -367,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}`,
@@ -422,11 +422,11 @@ 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 startTime = Date.now();
@@ -455,7 +455,7 @@ describe('MastraInngestWorkflow', () => {
       srv.close();
     });
 
-    it('should execute a a sleep until step', async ctx => {
+    it('should execute a sleep step with fn parameter', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -463,34 +463,36 @@ describe('MastraInngestWorkflow', () => {
 
       const { createWorkflow, createStep } = init(inngest);
 
-      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
+      const execute = vi.fn<any>().mockResolvedValue({ value: 1000 });
       const step1 = createStep({
         id: 'step1',
         execute,
         inputSchema: z.object({}),
-        outputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ value: z.number() }),
       });
       const step2 = createStep({
         id: 'step2',
         execute: async ({ inputData }) => {
-          return { result: 'slept successfully: ' + inputData.result };
+          return { value: inputData.value + 1000 };
         },
-        inputSchema: z.object({ result: z.string() }),
-        outputSchema: z.object({ result: z.string() }),
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
       });
 
       const workflow = createWorkflow({
         id: 'test-workflow',
         inputSchema: z.object({}),
         outputSchema: z.object({
-          result: z.string(),
+          value: z.number(),
         }),
         steps: [step1],
       });
 
       workflow
         .then(step1)
-        .sleepUntil(new Date(Date.now() + 1000))
+        .sleep(async ({ inputData }) => {
+          return inputData.value;
+        })
         .then(step2)
         .commit();
 
@@ -514,11 +516,11 @@ 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 startTime = Date.now();
@@ -528,7 +530,7 @@ describe('MastraInngestWorkflow', () => {
       expect(execute).toHaveBeenCalled();
       expect(result.steps['step1']).toMatchObject({
         status: 'success',
-        output: { result: 'success' },
+        output: { value: 1000 },
         // payload: {},
         // startedAt: expect.any(Number),
         // endedAt: expect.any(Number),
@@ -536,7 +538,7 @@ describe('MastraInngestWorkflow', () => {
 
       expect(result.steps['step2']).toMatchObject({
         status: 'success',
-        output: { result: 'slept successfully: success' },
+        output: { value: 2000 },
         // payload: { result: 'success' },
         // startedAt: expect.any(Number),
         // endedAt: expect.any(Number),
@@ -547,7 +549,7 @@ describe('MastraInngestWorkflow', () => {
       srv.close();
     });
 
-    it('should execute a a waitForEvent step', async ctx => {
+    it('should execute a a sleep until step', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -564,12 +566,11 @@ describe('MastraInngestWorkflow', () => {
       });
       const step2 = createStep({
         id: 'step2',
-        execute: async ({ inputData, resumeData }) => {
-          return { result: inputData.result, resumed: resumeData };
+        execute: async ({ inputData }) => {
+          return { result: 'slept successfully: ' + 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({
@@ -577,12 +578,15 @@ describe('MastraInngestWorkflow', () => {
         inputSchema: z.object({}),
         outputSchema: z.object({
           result: z.string(),
-          resumed: z.any(),
         }),
         steps: [step1],
       });
 
-      workflow.then(step1).waitForEvent('hello-event', step2).commit();
+      workflow
+        .then(step1)
+        .sleepUntil(new Date(Date.now() + 1000))
+        .then(step2)
+        .commit();
 
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -604,17 +608,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 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();
 
@@ -629,11 +630,10 @@ describe('MastraInngestWorkflow', () => {
 
       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),
+        output: { result: 'slept successfully: success' },
+        // payload: { result: 'success' },
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
       });
 
       expect(endTime - startTime).toBeGreaterThan(1000);
@@ -641,7 +641,7 @@ describe('MastraInngestWorkflow', () => {
       srv.close();
     });
 
-    it('should execute a a waitForEvent step after timeout', 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}`,
@@ -649,34 +649,38 @@ describe('MastraInngestWorkflow', () => {
 
       const { createWorkflow, createStep } = init(inngest);
 
-      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
+      const execute = vi.fn<any>().mockResolvedValue({ value: 1000 });
       const step1 = createStep({
         id: 'step1',
         execute,
         inputSchema: z.object({}),
-        outputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ value: z.number() }),
       });
       const step2 = createStep({
         id: 'step2',
-        execute: async ({ inputData, resumeData }) => {
-          return { result: inputData.result, resumed: resumeData };
+        execute: async ({ inputData }) => {
+          return { value: inputData.value + 1000 };
         },
-        inputSchema: z.object({ result: z.string() }),
-        outputSchema: z.object({ result: z.string(), resumed: z.any() }),
-        resumeSchema: z.any(),
+        inputSchema: z.object({ value: z.number() }),
+        outputSchema: z.object({ value: z.number() }),
       });
 
       const workflow = createWorkflow({
         id: 'test-workflow',
         inputSchema: z.object({}),
         outputSchema: z.object({
-          result: z.string(),
-          resumed: z.any(),
+          value: z.number(),
         }),
         steps: [step1],
       });
 
-      workflow.then(step1).waitForEvent('hello-event', step2, { timeout: 1000 }).commit();
+      workflow
+        .then(step1)
+        .sleepUntil(async ({ inputData }) => {
+          return new Date(Date.now() + inputData.value);
+        })
+        .then(step2)
+        .commit();
 
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -698,11 +702,11 @@ 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 startTime = Date.now();
@@ -712,28 +716,26 @@ describe('MastraInngestWorkflow', () => {
       expect(execute).toHaveBeenCalled();
       expect(result.steps['step1']).toMatchObject({
         status: 'success',
-        output: { result: 'success' },
+        output: { value: 1000 },
         // payload: {},
         // startedAt: expect.any(Number),
         // endedAt: expect.any(Number),
       });
 
       expect(result.steps['step2']).toMatchObject({
-        status: 'failed',
-        error: expect.any(String),
-        payload: { result: 'success' },
-        startedAt: expect.any(Number),
-        endedAt: expect.any(Number),
+        status: 'success',
+        output: { value: 2000 },
+        // payload: { result: 'success' },
+        // startedAt: expect.any(Number),
+        // endedAt: expect.any(Number),
       });
 
       expect(endTime - startTime).toBeGreaterThan(1000);
 
       srv.close();
     });
-  });
 
-  describe('Variable Resolution', () => {
-    it('should resolve trigger data', async ctx => {
+    it('should execute a a waitForEvent step', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -742,27 +744,33 @@ describe('MastraInngestWorkflow', () => {
       const { createWorkflow, createStep } = init(inngest);
 
       const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
-
       const step1 = createStep({
         id: 'step1',
         execute,
-        inputSchema: z.object({ inputData: z.string() }),
+        inputSchema: z.object({}),
         outputSchema: z.object({ result: z.string() }),
       });
       const step2 = createStep({
         id: 'step2',
-        execute,
+        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({
         id: 'test-workflow',
-        inputSchema: z.object({ inputData: z.string() }),
-        outputSchema: z.object({}),
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          result: z.string(),
+          resumed: z.any(),
+        }),
+        steps: [step1],
       });
 
-      workflow.then(step1).then(step2).commit();
+      workflow.then(step1).waitForEvent('hello-event', step2).commit();
 
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -784,21 +792,44 @@ 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 result = await run.start({ inputData: { inputData: 'test-input' } });
+      const startTime = Date.now();
+      setTimeout(() => {
+        run.sendEvent('hello-event', { data: 'hello' });
+      }, 1000);
+      const result = await run.start({ inputData: {} });
+      const endTime = Date.now();
 
-      expect(result.steps.step1).toMatchObject({ status: 'success', output: { result: 'success' } });
-      expect(result.steps.step2).toMatchObject({ status: 'success', output: { result: 'success' } });
+      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 provide access to step results and trigger data via getStepResult helper', async ctx => {
+    it('should execute a a waitForEvent step after timeout', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
@@ -806,50 +837,34 @@ describe('MastraInngestWorkflow', () => {
 
       const { createWorkflow, createStep } = init(inngest);
 
-      const step1Action = vi.fn().mockImplementation(async ({ inputData }) => {
-        // Test accessing trigger data with correct type
-        expect(inputData).toMatchObject({ inputValue: 'test-input' });
-        return { value: 'step1-result' };
-      });
-
-      const step2Action = vi.fn().mockImplementation(async ({ getStepResult }) => {
-        // Test accessing previous step result with type
-        const step1Result = getStepResult(step1);
-        expect(step1Result).toMatchObject({ value: 'step1-result' });
-
-        const failedStep = getStepResult(nonExecutedStep);
-        expect(failedStep).toBe(null);
-
-        return { value: 'step2-result' };
-      });
-
+      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
       const step1 = createStep({
         id: 'step1',
-        execute: step1Action,
-        inputSchema: z.object({ inputValue: z.string() }),
-        outputSchema: z.object({ value: z.string() }),
+        execute,
+        inputSchema: z.object({}),
+        outputSchema: z.object({ result: z.string() }),
       });
       const step2 = createStep({
         id: 'step2',
-        execute: step2Action,
-        inputSchema: z.object({ value: z.string() }),
-        outputSchema: z.object({ value: z.string() }),
-      });
-
-      const nonExecutedStep = createStep({
-        id: 'non-executed-step',
-        execute: vi.fn(),
-        inputSchema: z.object({}),
-        outputSchema: z.object({}),
+        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({ inputValue: z.string() }),
-        outputSchema: z.object({ value: z.string() }),
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          result: z.string(),
+          resumed: z.any(),
+        }),
+        steps: [step1],
       });
 
-      workflow.then(step1).then(step2).commit();
+      workflow.then(step1).waitForEvent('hello-event', step2, { timeout: 1000 }).commit();
 
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -871,52 +886,77 @@ 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 result = await run.start({ inputData: { inputValue: 'test-input' } });
+      const startTime = Date.now();
+      const result = await run.start({ inputData: {} });
+      const endTime = Date.now();
 
-      expect(step1Action).toHaveBeenCalled();
-      expect(step2Action).toHaveBeenCalled();
-      expect(result.steps).toMatchObject({
-        input: { inputValue: 'test-input' },
-        step1: { status: 'success', output: { value: 'step1-result' } },
-        step2: { status: 'success', output: { value: 'step2-result' } },
+      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: '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 resolve trigger data from context', 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 triggerSchema = z.object({
-        inputData: z.string(),
-      });
-
       const step1 = createStep({
         id: 'step1',
-        execute,
-        inputSchema: triggerSchema,
+        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: triggerSchema,
-        outputSchema: z.object({ result: z.string() }),
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          result: z.string(),
+        }),
+        steps: [step1, step2],
       });
 
-      workflow.then(step1).commit();
+      workflow.then(step1).sleep(2000).then(step2).commit();
 
       const mastra = new Mastra({
         storage: new DefaultStorage({
@@ -938,19 +978,368 @@ 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();
-      await run.start({ inputData: { inputData: 'test-input' } });
+      const p = run.start({ inputData: { value: 'test' } });
 
-      expect(execute).toHaveBeenCalledWith(
-        expect.objectContaining({
-          inputData: { inputData: 'test-input' },
-        }),
-      );
+      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({
+        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({ inputData: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute,
+        inputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({ inputData: z.string() }),
+        outputSchema: z.object({}),
+      });
+
+      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 result = await run.start({ inputData: { inputData: 'test-input' } });
+
+      expect(result.steps.step1).toMatchObject({ status: 'success', output: { result: 'success' } });
+      expect(result.steps.step2).toMatchObject({ status: 'success', output: { result: 'success' } });
+
+      srv.close();
+    });
+
+    it('should provide access to step results and trigger data via getStepResult helper', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1Action = vi.fn().mockImplementation(async ({ inputData }) => {
+        // Test accessing trigger data with correct type
+        expect(inputData).toMatchObject({ inputValue: 'test-input' });
+        return { value: 'step1-result' };
+      });
+
+      const step2Action = vi.fn().mockImplementation(async ({ getStepResult }) => {
+        // Test accessing previous step result with type
+        const step1Result = getStepResult(step1);
+        expect(step1Result).toMatchObject({ value: 'step1-result' });
+
+        const failedStep = getStepResult(nonExecutedStep);
+        expect(failedStep).toBe(null);
+
+        return { value: 'step2-result' };
+      });
+
+      const step1 = createStep({
+        id: 'step1',
+        execute: step1Action,
+        inputSchema: z.object({ inputValue: z.string() }),
+        outputSchema: z.object({ value: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: step2Action,
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ value: z.string() }),
+      });
+
+      const nonExecutedStep = createStep({
+        id: 'non-executed-step',
+        execute: vi.fn(),
+        inputSchema: z.object({}),
+        outputSchema: z.object({}),
+      });
+
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({ inputValue: z.string() }),
+        outputSchema: z.object({ value: z.string() }),
+      });
+
+      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 result = await run.start({ inputData: { inputValue: 'test-input' } });
+
+      expect(step1Action).toHaveBeenCalled();
+      expect(step2Action).toHaveBeenCalled();
+      expect(result.steps).toMatchObject({
+        input: { inputValue: 'test-input' },
+        step1: { status: 'success', output: { value: 'step1-result' } },
+        step2: { status: 'success', output: { value: 'step2-result' } },
+      });
+
+      srv.close();
+    });
+
+    it('should resolve trigger data from context', 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 triggerSchema = z.object({
+        inputData: z.string(),
+      });
+
+      const step1 = createStep({
+        id: 'step1',
+        execute,
+        inputSchema: triggerSchema,
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: triggerSchema,
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      workflow.then(step1).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();
+      await run.start({ inputData: { inputData: 'test-input' } });
+
+      expect(execute).toHaveBeenCalledWith(
+        expect.objectContaining({
+          inputData: { inputData: 'test-input' },
+        }),
+      );
 
       srv.close();
     });
@@ -1013,10 +1402,11 @@ 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 result = await run.start({ inputData: { cool: 'test-input' } });
@@ -1095,10 +1485,11 @@ 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();
       await run.start({ inputData: {} });
@@ -1198,10 +1589,11 @@ 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 result = await run.start({ inputData: { status: 'success' } });
@@ -1274,10 +1666,11 @@ 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();
       let result: Awaited<ReturnType<typeof run.start>> | undefined = undefined;
@@ -1379,10 +1772,11 @@ 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 result = await run.start({ inputData: { status: 'success' } });
@@ -1462,10 +1856,11 @@ 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 result = await run.start({ inputData: { count: 5 } });
@@ -1529,11 +1924,11 @@ 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();
 
@@ -1613,11 +2008,11 @@ 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 result = await run.start({ inputData: {} });
@@ -1707,11 +2102,11 @@ 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 mainWorkflow.createRunAsync();
       const result = await run.start({ inputData: {} });
@@ -1835,11 +2230,11 @@ 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 result = await run.start({ inputData: {} });
@@ -1937,11 +2332,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { target: 10, value: 0 } });
@@ -2040,11 +2435,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { target: 10, value: 0 } });
@@ -2129,11 +2524,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: [{ value: 1 }, { value: 22 }, { value: 333 }] });
@@ -2282,11 +2677,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 1 } });
@@ -2431,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 = 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);
@@ -2447,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();
     });
   });
 
@@ -2603,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 = 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();
     });
   });
 
@@ -2669,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 = 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
@@ -2801,11 +3196,11 @@ 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 result = await run.start({ inputData: {} });
@@ -2873,11 +3268,11 @@ 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();
 
@@ -2890,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);
@@ -3002,8 +3399,6 @@ describe('MastraInngestWorkflow', () => {
         status: 'success',
         output: { result: 'success2' },
       });
-
-      srv.close();
     });
 
     it('should unsubscribe from transitions when unwatch is called', async ctx => {
@@ -3059,11 +3454,11 @@ 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();
@@ -3231,11 +3626,11 @@ 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 promptEvalWorkflow.createRunAsync();
 
@@ -3381,11 +3776,11 @@ 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();
 
@@ -3419,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');
       }
@@ -3583,11 +3978,11 @@ 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 started = run.start({ inputData: { input: 'test' } });
@@ -3640,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');
       }
@@ -3777,11 +4173,11 @@ 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 promptEvalWorkflow.createRunAsync();
 
@@ -3836,6 +4232,9 @@ describe('MastraInngestWorkflow', () => {
           completenessScore: { score: 0.7 },
         },
       });
+
+      srv.close();
+
       if (!secondResumeResult) {
         throw new Error('Resume failed to return a result');
       }
@@ -3858,8 +4257,6 @@ describe('MastraInngestWorkflow', () => {
       });
 
       expect(promptAgentAction).toHaveBeenCalledTimes(2);
-
-      srv.close();
     });
   });
 
@@ -3905,11 +4302,11 @@ 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 = await workflow.createRunAsync();
@@ -4009,11 +4406,11 @@ 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 result = await run.start({
@@ -4146,11 +4543,11 @@ 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 result = await run.start({
@@ -4289,11 +4686,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
@@ -4441,11 +4838,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
@@ -4601,10 +4998,11 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
 
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
 
         const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
@@ -4760,10 +5158,11 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
 
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
 
         const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
@@ -4957,10 +5356,11 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
 
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
 
         const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 1 } });
@@ -5110,11 +5510,11 @@ 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 counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
@@ -5261,10 +5661,11 @@ describe('MastraInngestWorkflow', () => {
           await next();
         });
 
-        const srv = serve({
+        const srv = (globServer = serve({
           fetch: app.fetch,
           port: (ctx as any).handlerPort,
-        });
+        }));
+        await resetInngest();
 
         const run = await counterWorkflow.createRunAsync();
         const result = await run.start({ inputData: { startValue: 0 } });
@@ -5442,11 +5843,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
@@ -5604,11 +6005,11 @@ 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 counterWorkflow.createRunAsync();
       const result = await run.start({ inputData: { startValue: 0 } });
@@ -5679,11 +6080,11 @@ 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 = await workflow.createRunAsync();
@@ -5742,10 +6143,11 @@ 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 result = await run.start({ runtimeContext });
@@ -5756,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}`,
@@ -5841,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({
@@ -5867,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 = await workflow.createRunAsync();
-      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}`,
@@ -5914,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({
@@ -5936,10 +6511,11 @@ 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[] = [];
@@ -5947,7 +6523,7 @@ describe('MastraInngestWorkflow', () => {
         runId,
       });
 
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
 
       const { stream, getWorkflowState } = run.stream({ inputData: {} });
 
@@ -5960,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',
@@ -6046,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}`,
@@ -6055,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({}),
       });
 
@@ -6077,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({
@@ -6099,10 +6720,11 @@ 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[] = [];
@@ -6110,7 +6732,7 @@ describe('MastraInngestWorkflow', () => {
         runId,
       });
 
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
 
       const { stream, getWorkflowState } = run.stream({ inputData: {} });
 
@@ -6123,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: {
@@ -6138,6 +6760,9 @@ describe('MastraInngestWorkflow', () => {
         {
           payload: {
             id: 'step1',
+            startedAt: expect.any(Number),
+            status: 'running',
+            payload: {},
           },
           type: 'step-start',
         },
@@ -6145,8 +6770,9 @@ describe('MastraInngestWorkflow', () => {
           payload: {
             id: 'step1',
             output: {
-              result: 'success1',
+              value: 1000,
             },
+            endedAt: expect.any(Number),
             status: 'success',
           },
           type: 'step-result',
@@ -6159,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',
         },
@@ -6172,8 +6829,9 @@ describe('MastraInngestWorkflow', () => {
           payload: {
             id: 'step2',
             output: {
-              result: 'success2',
+              value: 2000,
             },
+            endedAt: expect.any(Number),
             status: 'success',
           },
           type: 'step-result',
@@ -6192,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),
@@ -6264,10 +6923,11 @@ 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[] = [];
@@ -6275,7 +6935,7 @@ describe('MastraInngestWorkflow', () => {
         runId,
       });
 
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
 
       const { stream, getWorkflowState } = run.stream({ inputData: {} });
 
@@ -6295,7 +6955,7 @@ describe('MastraInngestWorkflow', () => {
 
       const executionResult = await getWorkflowState();
 
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      await resetInngest();
 
       srv.close();
 
@@ -6489,12 +7149,12 @@ 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 = await promptEvalWorkflow.createRunAsync();
 
@@ -6678,12 +7338,12 @@ 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 = await workflow.createRunAsync({
         runId: 'test-run-id',