@mastra/inngest 0.0.0-custom-instrumentation-20250626084921 → 0.0.0-fix-generate-title-20250616171351

package/src/index.test.ts

@@ -5,12 +5,10 @@ import { openai } from '@ai-sdk/openai';
 import { serve } from '@hono/node-server';
 import { realtimeMiddleware } from '@inngest/realtime';
 import { createTool, Mastra, Telemetry } from '@mastra/core';
-import type { StreamEvent } from '@mastra/core';
 import { Agent } from '@mastra/core/agent';
 import { RuntimeContext } from '@mastra/core/runtime-context';
 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';
@@ -35,118 +33,13 @@ describe('MastraInngestWorkflow', () => {
     ctx.inngestPort = inngestPort;
     ctx.handlerPort = handlerPort;
     ctx.containerName = containerName;
-
-    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 = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-
-      const run = await workflow.createRunAsync();
-      const result = await run.start({ inputData: { value: 'bail' } });
-
-      await new Promise(resolve => setTimeout(resolve, 2000));
-
-      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),
-      });
-    });
-
+  describe('Basic Workflow Execution', () => {
     it('should execute a single step workflow successfully', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
@@ -198,11 +91,11 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
       expect(execute).toHaveBeenCalled();
-      expect(result.steps['step1']).toMatchObject({
+      expect(result.steps['step1']).toEqual({
         status: 'success',
         output: { result: 'success' },
       });
@@ -273,12 +166,12 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
       expect(step1Action).toHaveBeenCalled();
       expect(step2Action).toHaveBeenCalled();
-      expect(result.steps).toMatchObject({
+      expect(result.steps).toEqual({
         input: {},
         step1: { status: 'success', output: { value: 'step1' } },
         step2: { status: 'success', output: { value: 'step2' } },
@@ -354,11 +247,11 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
-      expect(executionOrder).toMatchObject(['step1', 'step2']);
-      expect(result.steps).toMatchObject({
+      expect(executionOrder).toEqual(['step1', 'step2']);
+      expect(result.steps).toEqual({
         input: {},
         step1: { status: 'success', output: { value: 'step1' } },
         step2: { status: 'success', output: { value: 'step2' } },
@@ -428,13 +321,13 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const startTime = Date.now();
       const result = await run.start({ inputData: {} });
       const endTime = Date.now();
 
       expect(execute).toHaveBeenCalled();
-      expect(result.steps['step1']).toMatchObject({
+      expect(result.steps['step1']).toEqual({
         status: 'success',
         output: { result: 'success' },
         // payload: {},
@@ -442,7 +335,7 @@ describe('MastraInngestWorkflow', () => {
         // endedAt: expect.any(Number),
       });
 
-      expect(result.steps['step2']).toMatchObject({
+      expect(result.steps['step2']).toEqual({
         status: 'success',
         output: { result: 'slept successfully: success' },
         // payload: { result: 'success' },
@@ -520,13 +413,13 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const startTime = Date.now();
       const result = await run.start({ inputData: {} });
       const endTime = Date.now();
 
       expect(execute).toHaveBeenCalled();
-      expect(result.steps['step1']).toMatchObject({
+      expect(result.steps['step1']).toEqual({
         status: 'success',
         output: { result: 'success' },
         // payload: {},
@@ -534,7 +427,7 @@ describe('MastraInngestWorkflow', () => {
         // endedAt: expect.any(Number),
       });
 
-      expect(result.steps['step2']).toMatchObject({
+      expect(result.steps['step2']).toEqual({
         status: 'success',
         output: { result: 'slept successfully: success' },
         // payload: { result: 'success' },
@@ -546,190 +439,6 @@ describe('MastraInngestWorkflow', () => {
 
       srv.close();
     });
-
-    it('should execute a a waitForEvent step', async ctx => {
-      const inngest = new Inngest({
-        id: 'mastra',
-        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
-      });
-
-      const { createWorkflow, createStep } = init(inngest);
-
-      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
-      const step1 = createStep({
-        id: 'step1',
-        execute,
-        inputSchema: z.object({}),
-        outputSchema: z.object({ result: z.string() }),
-      });
-      const step2 = createStep({
-        id: 'step2',
-        execute: async ({ inputData, resumeData }) => {
-          return { result: inputData.result, resumed: resumeData };
-        },
-        inputSchema: z.object({ result: z.string() }),
-        outputSchema: z.object({ result: z.string(), resumed: z.any() }),
-        resumeSchema: z.any(),
-      });
-
-      const workflow = createWorkflow({
-        id: 'test-workflow',
-        inputSchema: z.object({}),
-        outputSchema: z.object({
-          result: z.string(),
-          resumed: z.any(),
-        }),
-        steps: [step1],
-      });
-
-      workflow.then(step1).waitForEvent('hello-event', step2).commit();
-
-      const mastra = new Mastra({
-        storage: new DefaultStorage({
-          url: ':memory:',
-        }),
-        workflows: {
-          'test-workflow': workflow,
-        },
-        server: {
-          apiRoutes: [
-            {
-              path: '/inngest/api',
-              method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
-            },
-          ],
-        },
-      });
-
-      const app = await createHonoServer(mastra);
-
-      const srv = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
-
-      const run = await workflow.createRunAsync();
-      const startTime = Date.now();
-      setTimeout(() => {
-        run.sendEvent('hello-event', { data: 'hello' });
-      }, 1000);
-      const result = await run.start({ inputData: {} });
-      const endTime = Date.now();
-
-      expect(execute).toHaveBeenCalled();
-      expect(result.steps['step1']).toMatchObject({
-        status: 'success',
-        output: { result: 'success' },
-        // payload: {},
-        // startedAt: expect.any(Number),
-        // endedAt: expect.any(Number),
-      });
-
-      expect(result.steps['step2']).toMatchObject({
-        status: 'success',
-        output: { result: 'success', resumed: { data: 'hello' } },
-        payload: { result: 'success' },
-        // resumePayload: { data: 'hello' },
-        startedAt: expect.any(Number),
-        endedAt: expect.any(Number),
-      });
-
-      expect(endTime - startTime).toBeGreaterThan(1000);
-
-      srv.close();
-    });
-
-    it('should execute a a waitForEvent step after timeout', async ctx => {
-      const inngest = new Inngest({
-        id: 'mastra',
-        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
-      });
-
-      const { createWorkflow, createStep } = init(inngest);
-
-      const execute = vi.fn<any>().mockResolvedValue({ result: 'success' });
-      const step1 = createStep({
-        id: 'step1',
-        execute,
-        inputSchema: z.object({}),
-        outputSchema: z.object({ result: z.string() }),
-      });
-      const step2 = createStep({
-        id: 'step2',
-        execute: async ({ inputData, resumeData }) => {
-          return { result: inputData.result, resumed: resumeData };
-        },
-        inputSchema: z.object({ result: z.string() }),
-        outputSchema: z.object({ result: z.string(), resumed: z.any() }),
-        resumeSchema: z.any(),
-      });
-
-      const workflow = createWorkflow({
-        id: 'test-workflow',
-        inputSchema: z.object({}),
-        outputSchema: z.object({
-          result: z.string(),
-          resumed: z.any(),
-        }),
-        steps: [step1],
-      });
-
-      workflow.then(step1).waitForEvent('hello-event', step2, { timeout: 1000 }).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 = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-      await new Promise(resolve => setTimeout(resolve, 2000));
-
-      const run = await workflow.createRunAsync();
-      const startTime = Date.now();
-      const result = await run.start({ inputData: {} });
-      const endTime = Date.now();
-
-      expect(execute).toHaveBeenCalled();
-      expect(result.steps['step1']).toMatchObject({
-        status: 'success',
-        output: { result: 'success' },
-        // payload: {},
-        // startedAt: expect.any(Number),
-        // endedAt: expect.any(Number),
-      });
-
-      expect(result.steps['step2']).toMatchObject({
-        status: 'failed',
-        error: expect.any(String),
-        payload: { result: 'success' },
-        startedAt: expect.any(Number),
-        endedAt: expect.any(Number),
-      });
-
-      expect(endTime - startTime).toBeGreaterThan(1000);
-
-      srv.close();
-    });
   });
 
   describe('Variable Resolution', () => {
@@ -789,11 +498,11 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       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' } });
+      expect(result.steps.step1).toEqual({ status: 'success', output: { result: 'success' } });
+      expect(result.steps.step2).toEqual({ status: 'success', output: { result: 'success' } });
 
       srv.close();
     });
@@ -808,14 +517,14 @@ describe('MastraInngestWorkflow', () => {
 
       const step1Action = vi.fn().mockImplementation(async ({ inputData }) => {
         // Test accessing trigger data with correct type
-        expect(inputData).toMatchObject({ inputValue: 'test-input' });
+        expect(inputData).toEqual({ 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' });
+        expect(step1Result).toEqual({ value: 'step1-result' });
 
         const failedStep = getStepResult(nonExecutedStep);
         expect(failedStep).toBe(null);
@@ -876,12 +585,12 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: { inputValue: 'test-input' } });
 
       expect(step1Action).toHaveBeenCalled();
       expect(step2Action).toHaveBeenCalled();
-      expect(result.steps).toMatchObject({
+      expect(result.steps).toEqual({
         input: { inputValue: 'test-input' },
         step1: { status: 'success', output: { value: 'step1-result' } },
         step2: { status: 'success', output: { value: 'step2-result' } },
@@ -943,7 +652,7 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       await run.start({ inputData: { inputData: 'test-input' } });
 
       expect(execute).toHaveBeenCalledWith(
@@ -1018,7 +727,7 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: { cool: 'test-input' } });
 
       expect(execute).toHaveBeenCalledWith(
@@ -1027,7 +736,7 @@ describe('MastraInngestWorkflow', () => {
         }),
       );
 
-      expect(result.steps.step2).toMatchObject({ status: 'success', output: { result: { cool: 'test-input' } } });
+      expect(result.steps.step2).toEqual({ status: 'success', output: { result: { cool: 'test-input' } } });
 
       srv.close();
     });
@@ -1100,7 +809,7 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       await run.start({ inputData: {} });
 
       expect(step2Action).toHaveBeenCalledWith(
@@ -1203,14 +912,14 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: { status: 'success' } });
       srv.close();
 
       expect(step1Action).toHaveBeenCalled();
       expect(step2Action).toHaveBeenCalled();
       expect(step3Action).not.toHaveBeenCalled();
-      expect(result.steps).toMatchObject({
+      expect(result.steps).toEqual({
         input: { status: 'success' },
         step1: { status: 'success', output: { status: 'success' } },
         step2: { status: 'success', output: { result: 'step2' } },
@@ -1279,7 +988,7 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       let result: Awaited<ReturnType<typeof run.start>> | undefined = undefined;
       try {
         result = await run.start({ inputData: {} });
@@ -1291,7 +1000,7 @@ describe('MastraInngestWorkflow', () => {
 
       expect(step1Action).toHaveBeenCalled();
       expect(step2Action).not.toHaveBeenCalled();
-      expect(result?.steps).toMatchObject({
+      expect(result?.steps).toEqual({
         input: {},
         step1: { status: 'failed', error: 'Failed' },
       });
@@ -1384,7 +1093,7 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: { status: 'success' } });
       srv.close();
 
@@ -1467,17 +1176,18 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: { count: 5 } });
       srv.close();
 
       expect(step2Action).toHaveBeenCalled();
-      expect(result.steps.step1).toMatchObject({
+      expect(result.steps.step1).toEqual({
         status: 'success',
         output: { count: 5 },
       });
-      expect(result.steps.step2).toMatchObject({
+      expect(result.steps.step2).toEqual({
         status: 'success',
+        output: undefined,
       });
     });
   });
@@ -1535,7 +1245,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
 
       await expect(run.start({ inputData: {} })).resolves.toMatchObject({
         steps: {
@@ -1619,7 +1329,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
       expect(result.steps).toMatchObject({
@@ -1713,7 +1423,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await mainWorkflow.createRunAsync();
+      const run = mainWorkflow.createRun();
       const result = await run.start({ inputData: {} });
 
       expect(result.steps).toMatchObject({
@@ -1841,12 +1551,12 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
       expect(step2Action).toHaveBeenCalled();
       expect(step3Action).not.toHaveBeenCalled();
-      expect(result.steps.step2).toMatchObject({ status: 'success', output: { result: 'step2' } });
+      expect(result.steps.step2).toEqual({ status: 'success', output: { result: 'step2' } });
 
       srv.close();
     });
@@ -1943,15 +1653,15 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { target: 10, value: 0 } });
 
       expect(increment).toHaveBeenCalledTimes(12);
       expect(final).toHaveBeenCalledTimes(1);
       // @ts-ignore
-      expect(result.result).toMatchObject({ finalValue: 12 });
+      expect(result.result).toEqual({ finalValue: 12 });
       // @ts-ignore
-      expect(result.steps.increment.output).toMatchObject({ value: 12 });
+      expect(result.steps.increment.output).toEqual({ value: 12 });
 
       srv.close();
     });
@@ -2046,15 +1756,15 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { target: 10, value: 0 } });
 
       expect(increment).toHaveBeenCalledTimes(12);
       expect(final).toHaveBeenCalledTimes(1);
       // @ts-ignore
-      expect(result.result).toMatchObject({ finalValue: 12 });
+      expect(result.result).toEqual({ finalValue: 12 });
       // @ts-ignore
-      expect(result.steps.increment.output).toMatchObject({ value: 12 });
+      expect(result.steps.increment.output).toEqual({ value: 12 });
 
       srv.close();
     });
@@ -2135,7 +1845,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: [{ value: 1 }, { value: 22 }, { value: 333 }] });
 
       const endTime = Date.now();
@@ -2143,7 +1853,7 @@ describe('MastraInngestWorkflow', () => {
       expect(duration).toBeGreaterThan(1e3 * 3);
 
       expect(map).toHaveBeenCalledTimes(3);
-      expect(result.steps).toMatchObject({
+      expect(result.steps).toEqual({
         input: [{ value: 1 }, { value: 22 }, { value: 333 }],
         map: { status: 'success', output: [{ value: 12 }, { value: 33 }, { value: 344 }] },
         final: { status: 'success', output: { finalValue: 1 + 11 + (22 + 11) + (333 + 11) } },
@@ -2288,16 +1998,16 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { startValue: 1 } });
 
       expect(start).toHaveBeenCalledTimes(1);
       expect(other).toHaveBeenCalledTimes(0);
       expect(final).toHaveBeenCalledTimes(1);
       // @ts-ignore
-      expect(result.steps.finalIf.output).toMatchObject({ finalValue: 2 });
+      expect(result.steps.finalIf.output).toEqual({ finalValue: 2 });
       // @ts-ignore
-      expect(result.steps.start.output).toMatchObject({ newValue: 2 });
+      expect(result.steps.start.output).toEqual({ newValue: 2 });
 
       srv.close();
     });
@@ -2437,16 +2147,16 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { startValue: 6 } });
 
       expect(start).toHaveBeenCalledTimes(1);
       expect(other).toHaveBeenCalledTimes(1);
       expect(final).toHaveBeenCalledTimes(1);
       // @ts-ignore
-      expect(result.steps['else-branch'].output).toMatchObject({ finalValue: 26 + 6 + 1 });
+      expect(result.steps['else-branch'].output).toEqual({ finalValue: 26 + 6 + 1 });
       // @ts-ignore
-      expect(result.steps.start.output).toMatchObject({ newValue: 7 });
+      expect(result.steps.start.output).toEqual({ newValue: 7 });
 
       srv.close();
     });
@@ -2503,7 +2213,7 @@ describe('MastraInngestWorkflow', () => {
       ).rejects.toThrow();
 
       // Should pass validation
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       await run.start({
         inputData: {
           required: 'test',
@@ -2609,11 +2319,11 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
-      expect(result.steps['nested-a']).toMatchObject({ status: 'success', output: { result: 'success3' } });
-      expect(result.steps['nested-b']).toMatchObject({ status: 'success', output: { result: 'success5' } });
+      expect(result.steps['nested-a']).toEqual({ status: 'success', output: { result: 'success3' } });
+      expect(result.steps['nested-b']).toEqual({ status: 'success', output: { result: 'success5' } });
 
       srv.close();
     });
@@ -2675,11 +2385,11 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
-      expect(result.steps.step1).toMatchObject({ status: 'success', output: { result: 'success' } });
-      expect(result.steps.step2).toMatchObject({ status: 'failed', error: 'Step failed' });
+      expect(result.steps.step1).toEqual({ status: 'success', output: { result: 'success' } });
+      expect(result.steps.step2).toEqual({ status: 'failed', error: 'Step failed' });
       expect(step1.execute).toHaveBeenCalledTimes(1);
       expect(step2.execute).toHaveBeenCalledTimes(1); // 0 retries + 1 initial call
 
@@ -2732,11 +2442,11 @@ describe('MastraInngestWorkflow', () => {
 
       workflow.then(step1).then(step2).commit();
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ inputData: {} });
 
-      expect(result.steps.step1).toMatchObject({ status: 'success', output: { result: 'success' } });
-      expect(result.steps.step2).toMatchObject({ status: 'failed', error: 'Step failed' });
+      expect(result.steps.step1).toEqual({ status: 'success', output: { result: 'success' } });
+      expect(result.steps.step2).toEqual({ status: 'failed', error: 'Step failed' });
       expect(step1.execute).toHaveBeenCalledTimes(1);
       expect(step2.execute).toHaveBeenCalledTimes(6); // 5 retries + 1 initial call
     });
@@ -2807,15 +2517,14 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
-      const result = await run.start({ inputData: {} });
+      const result = await workflow.createRun().start({ inputData: {} });
 
       srv.close();
 
       expect(step1Action).toHaveBeenCalled();
       expect(toolAction).toHaveBeenCalled();
-      expect(result.steps.step1).toMatchObject({ status: 'success', output: { name: 'step1' } });
-      expect(result.steps['random-tool']).toMatchObject({ status: 'success', output: { name: 'step1' } });
+      expect(result.steps.step1).toEqual({ status: 'success', output: { name: 'step1' } });
+      expect(result.steps['random-tool']).toEqual({ status: 'success', output: { name: 'step1' } });
     }, 10000);
   });
 
@@ -2879,7 +2588,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
 
       // Start watching the workflow
       let cnt = 0;
@@ -2994,11 +2703,11 @@ describe('MastraInngestWorkflow', () => {
       });
 
       // Verify execution completed successfully
-      expect(executionResult.steps.step1).toMatchObject({
+      expect(executionResult.steps.step1).toEqual({
         status: 'success',
         output: { result: 'success1' },
       });
-      expect(executionResult.steps.step2).toMatchObject({
+      expect(executionResult.steps.step2).toEqual({
         status: 'success',
         output: { result: 'success2' },
       });
@@ -3068,7 +2777,7 @@ describe('MastraInngestWorkflow', () => {
       const onTransition = vi.fn();
       const onTransition2 = vi.fn();
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
 
       run.watch(onTransition);
       run.watch(onTransition2);
@@ -3078,7 +2787,7 @@ describe('MastraInngestWorkflow', () => {
       expect(onTransition).toHaveBeenCalledTimes(5);
       expect(onTransition2).toHaveBeenCalledTimes(5);
 
-      const run2 = await workflow.createRunAsync();
+      const run2 = workflow.createRun();
 
       run2.watch(onTransition2);
 
@@ -3087,7 +2796,7 @@ describe('MastraInngestWorkflow', () => {
       expect(onTransition).toHaveBeenCalledTimes(5);
       expect(onTransition2).toHaveBeenCalledTimes(10);
 
-      const run3 = await workflow.createRunAsync();
+      const run3 = workflow.createRun();
 
       run3.watch(onTransition);
 
@@ -3122,8 +2831,8 @@ describe('MastraInngestWorkflow', () => {
         outputSchema: z.object({}),
         steps: [],
       });
-      const run = await workflow.createRunAsync();
-      const run2 = await workflow.createRunAsync({ runId: run.runId });
+      const run = workflow.createRun();
+      const run2 = workflow.createRun({ runId: run.runId });
 
       expect(run.runId).toBeDefined();
       expect(run2.runId).toBeDefined();
@@ -3237,7 +2946,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await promptEvalWorkflow.createRunAsync();
+      const run = promptEvalWorkflow.createRun();
 
       // Create a promise to track when the workflow is ready to resume
       let resolveWorkflowSuspended: (value: unknown) => void;
@@ -3267,7 +2976,7 @@ describe('MastraInngestWorkflow', () => {
         throw new Error('Resume failed to return a result');
       }
 
-      expect(resumeResult.steps).toMatchObject({
+      expect(resumeResult.steps).toEqual({
         input: { input: 'test' },
         getUserInput: { status: 'success', output: { userInput: 'test input' } },
         promptAgent: { status: 'success', output: { modelOutput: 'test output' } },
@@ -3387,7 +3096,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
 
       const started = run.start({ inputData: { input: 'test' } });
 
@@ -3430,7 +3139,7 @@ describe('MastraInngestWorkflow', () => {
         throw new Error('Resume failed to return a result');
       }
 
-      expect(result.steps).toMatchObject({
+      expect(result.steps).toEqual({
         input: { input: 'test' },
         getUserInput: { status: 'success', output: { userInput: 'test input' } },
         promptAgent: { status: 'success', output: { modelOutput: 'test output' } },
@@ -3589,7 +3298,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const started = run.start({ inputData: { input: 'test' } });
       let improvedResponseResultPromise: Promise<any | undefined>;
 
@@ -3783,22 +3492,18 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await promptEvalWorkflow.createRunAsync();
+      const run = promptEvalWorkflow.createRun();
 
       const initialResult = await run.start({ inputData: { input: 'test' } });
       expect(initialResult.steps.promptAgent.status).toBe('suspended');
       expect(promptAgentAction).toHaveBeenCalledTimes(1);
       // expect(initialResult.activePaths.size).toBe(1);
       // expect(initialResult.activePaths.get('promptAgent')?.status).toBe('suspended');
-      // expect(initialResult.activePaths.get('promptAgent')?.suspendPayload).toMatchObject({ testPayload: 'hello' });
-      expect(initialResult.steps).toMatchObject({
+      // expect(initialResult.activePaths.get('promptAgent')?.suspendPayload).toEqual({ testPayload: 'hello' });
+      expect(initialResult.steps).toEqual({
         input: { input: 'test' },
         getUserInput: { status: 'success', output: { userInput: 'test input' } },
-        promptAgent: {
-          status: 'suspended',
-          suspendedPayload: { testPayload: 'hello' },
-          payload: { userInput: 'test input' },
-        },
+        promptAgent: { status: 'suspended', payload: { testPayload: 'hello' } },
       });
 
       const newCtx = {
@@ -3815,7 +3520,7 @@ describe('MastraInngestWorkflow', () => {
 
       // expect(firstResumeResult.activePaths.size).toBe(1);
       // expect(firstResumeResult.activePaths.get('improveResponse')?.status).toBe('suspended');
-      expect(firstResumeResult.steps).toMatchObject({
+      expect(firstResumeResult.steps).toEqual({
         input: { input: 'test' },
         getUserInput: { status: 'success', output: { userInput: 'test input' } },
         promptAgent: { status: 'success', output: { modelOutput: 'test output' } },
@@ -3842,7 +3547,7 @@ describe('MastraInngestWorkflow', () => {
 
       expect(promptAgentAction).toHaveBeenCalledTimes(2);
 
-      expect(secondResumeResult.steps).toMatchObject({
+      expect(secondResumeResult.steps).toEqual({
         input: { input: 'test' },
         getUserInput: { status: 'success', output: { userInput: 'test input' } },
         promptAgent: { status: 'success', output: { modelOutput: 'test output' } },
@@ -3912,7 +3617,7 @@ describe('MastraInngestWorkflow', () => {
       await new Promise(resolve => setTimeout(resolve, 2000));
 
       // Access new instance properties directly - should work without warning
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       await run.start({ inputData: {} });
 
       expect(telemetry).toBeDefined();
@@ -3927,7 +3632,6 @@ describe('MastraInngestWorkflow', () => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
-        middleware: [realtimeMiddleware()],
       });
 
       const { createWorkflow, createStep } = init(inngest);
@@ -4015,29 +3719,28 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({
         inputData: { prompt1: 'Capital of France, just the name', prompt2: 'Capital of UK, just the name' },
       });
 
-      srv.close();
-
-      expect(result.steps['test-agent-1']).toMatchObject({
+      expect(result.steps['test-agent-1']).toEqual({
         status: 'success',
         output: { text: 'Paris' },
       });
 
-      expect(result.steps['test-agent-2']).toMatchObject({
+      expect(result.steps['test-agent-2']).toEqual({
         status: 'success',
         output: { text: 'London' },
       });
+
+      srv.close();
     });
 
     it('should be able to use an agent in parallel', async ctx => {
       const inngest = new Inngest({
         id: 'mastra',
         baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
-        middleware: [realtimeMiddleware()],
       });
 
       const { createWorkflow, createStep } = init(inngest);
@@ -4152,23 +3855,23 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({
         inputData: { prompt1: 'Capital of France, just the name', prompt2: 'Capital of UK, just the name' },
       });
 
       expect(execute).toHaveBeenCalledTimes(1);
-      expect(result.steps['finalStep']).toMatchObject({
+      expect(result.steps['finalStep']).toEqual({
         status: 'success',
         output: { result: 'success' },
       });
 
-      expect(result.steps['nested-workflow']).toMatchObject({
+      expect(result.steps['nested-workflow']).toEqual({
         status: 'success',
         output: { text: 'Paris' },
       });
 
-      expect(result.steps['nested-workflow-2']).toMatchObject({
+      expect(result.steps['nested-workflow-2']).toEqual({
         status: 'success',
         output: { text: 'London' },
       });
@@ -4295,7 +3998,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { startValue: 0 } });
 
       srv.close();
@@ -4305,16 +4008,16 @@ describe('MastraInngestWorkflow', () => {
       expect(final).toHaveBeenCalledTimes(2);
       expect(last).toHaveBeenCalledTimes(1);
       // @ts-ignore
-      expect(result.steps['nested-workflow-a'].output).toMatchObject({
+      expect(result.steps['nested-workflow-a'].output).toEqual({
         finalValue: 26 + 1,
       });
 
       // @ts-ignore
-      expect(result.steps['nested-workflow-b'].output).toMatchObject({
+      expect(result.steps['nested-workflow-b'].output).toEqual({
         finalValue: 1,
       });
 
-      expect(result.steps['last-step']).toMatchObject({
+      expect(result.steps['last-step']).toEqual({
         output: { success: true },
         status: 'success',
       });
@@ -4447,7 +4150,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { startValue: 0 } });
 
       srv.close();
@@ -4457,16 +4160,16 @@ describe('MastraInngestWorkflow', () => {
       expect(final).toHaveBeenCalledTimes(2);
       expect(last).toHaveBeenCalledTimes(1);
       // @ts-ignore
-      expect(result.steps['nested-workflow-a'].output).toMatchObject({
+      expect(result.steps['nested-workflow-a'].output).toEqual({
         finalValue: 26 + 1,
       });
 
       // @ts-ignore
-      expect(result.steps['nested-workflow-b'].output).toMatchObject({
+      expect(result.steps['nested-workflow-b'].output).toEqual({
         finalValue: 1,
       });
 
-      expect(result.steps['last-step']).toMatchObject({
+      expect(result.steps['last-step']).toEqual({
         output: { success: true },
         status: 'success',
       });
@@ -4606,7 +4309,7 @@ describe('MastraInngestWorkflow', () => {
           port: (ctx as any).handlerPort,
         });
 
-        const run = await counterWorkflow.createRunAsync();
+        const run = counterWorkflow.createRun();
         const result = await run.start({ inputData: { startValue: 0 } });
 
         srv.close();
@@ -4617,16 +4320,16 @@ describe('MastraInngestWorkflow', () => {
         expect(first).toHaveBeenCalledTimes(1);
         expect(last).toHaveBeenCalledTimes(1);
         // @ts-ignore
-        expect(result.steps['nested-workflow-a'].output).toMatchObject({
+        expect(result.steps['nested-workflow-a'].output).toEqual({
           finalValue: 26 + 1,
         });
 
-        expect(result.steps['first-step']).toMatchObject({
+        expect(result.steps['first-step']).toEqual({
           output: { success: true },
           status: 'success',
         });
 
-        expect(result.steps['last-step']).toMatchObject({
+        expect(result.steps['last-step']).toEqual({
           output: { success: true },
           status: 'success',
         });
@@ -4765,7 +4468,7 @@ describe('MastraInngestWorkflow', () => {
           port: (ctx as any).handlerPort,
         });
 
-        const run = await counterWorkflow.createRunAsync();
+        const run = counterWorkflow.createRun();
         const result = await run.start({ inputData: { startValue: 0 } });
 
         srv.close();
@@ -4777,16 +4480,16 @@ describe('MastraInngestWorkflow', () => {
         expect(last).toHaveBeenCalledTimes(1);
 
         // @ts-ignore
-        expect(result.steps['nested-workflow-b'].output).toMatchObject({
+        expect(result.steps['nested-workflow-b'].output).toEqual({
           finalValue: 1,
         });
 
-        expect(result.steps['first-step']).toMatchObject({
+        expect(result.steps['first-step']).toEqual({
           output: { success: true },
           status: 'success',
         });
 
-        expect(result.steps['last-step']).toMatchObject({
+        expect(result.steps['last-step']).toEqual({
           output: { success: true },
           status: 'success',
         });
@@ -4962,7 +4665,7 @@ describe('MastraInngestWorkflow', () => {
           port: (ctx as any).handlerPort,
         });
 
-        const run = await counterWorkflow.createRunAsync();
+        const run = counterWorkflow.createRun();
         const result = await run.start({ inputData: { startValue: 1 } });
 
         srv.close();
@@ -4974,16 +4677,16 @@ describe('MastraInngestWorkflow', () => {
         // expect(last).toHaveBeenCalledTimes(1);
 
         // @ts-ignore
-        expect(result.steps['nested-workflow-b'].output).toMatchObject({
+        expect(result.steps['nested-workflow-b'].output).toEqual({
           finalValue: 1,
         });
 
-        expect(result.steps['first-step']).toMatchObject({
+        expect(result.steps['first-step']).toEqual({
           output: { success: true },
           status: 'success',
         });
 
-        expect(result.steps['last-step']).toMatchObject({
+        expect(result.steps['last-step']).toEqual({
           output: { success: true },
           status: 'success',
         });
@@ -5116,7 +4819,7 @@ describe('MastraInngestWorkflow', () => {
         });
         await new Promise(resolve => setTimeout(resolve, 2000));
 
-        const run = await counterWorkflow.createRunAsync();
+        const run = counterWorkflow.createRun();
         const result = await run.start({ inputData: { startValue: 0 } });
 
         expect(begin).toHaveBeenCalledTimes(1);
@@ -5129,12 +4832,12 @@ describe('MastraInngestWorkflow', () => {
         });
 
         // @ts-ignore
-        expect(result.steps['last-step']).toMatchObject(undefined);
+        expect(result.steps['last-step']).toEqual(undefined);
 
         const resumedResults = await run.resume({ step: [wfA, otherStep], resumeData: { newValue: 0 } });
 
         // @ts-ignore
-        expect(resumedResults.steps['nested-workflow-a'].output).toMatchObject({
+        expect(resumedResults.steps['nested-workflow-a'].output).toEqual({
           finalValue: 26 + 1,
         });
 
@@ -5266,7 +4969,7 @@ describe('MastraInngestWorkflow', () => {
           port: (ctx as any).handlerPort,
         });
 
-        const run = await counterWorkflow.createRunAsync();
+        const run = counterWorkflow.createRun();
         const result = await run.start({ inputData: { startValue: 0 } });
         const results = result.steps;
 
@@ -5285,7 +4988,7 @@ describe('MastraInngestWorkflow', () => {
           },
         });
 
-        expect(result.steps['last-step']).toMatchObject({
+        expect(result.steps['last-step']).toEqual({
           status: 'success',
           output: { success: true },
         });
@@ -5448,7 +5151,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { startValue: 0 } });
 
       expect(passthroughStep.execute).toHaveBeenCalledTimes(2);
@@ -5462,23 +5165,18 @@ describe('MastraInngestWorkflow', () => {
       });
 
       // @ts-ignore
-      expect(result.steps['last-step']).toMatchObject(undefined);
+      expect(result.steps['last-step']).toEqual(undefined);
 
       if (result.status !== 'suspended') {
         expect.fail('Workflow should be suspended');
       }
-      expect(result.suspended[0]).toMatchObject([
-        'nested-workflow-c',
-        'nested-workflow-b',
-        'nested-workflow-a',
-        'other',
-      ]);
+      expect(result.suspended[0]).toEqual(['nested-workflow-c', 'nested-workflow-b', 'nested-workflow-a', 'other']);
       const resumedResults = await run.resume({ step: result.suspended[0], resumeData: { newValue: 0 } });
 
       srv.close();
 
       // @ts-ignore
-      expect(resumedResults.steps['nested-workflow-c'].output).toMatchObject({
+      expect(resumedResults.steps['nested-workflow-c'].output).toEqual({
         finalValue: 26 + 1,
       });
 
@@ -5610,7 +5308,7 @@ describe('MastraInngestWorkflow', () => {
       });
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const run = await counterWorkflow.createRunAsync();
+      const run = counterWorkflow.createRun();
       const result = await run.start({ inputData: { startValue: 0 } });
 
       srv.close();
@@ -5620,16 +5318,16 @@ describe('MastraInngestWorkflow', () => {
       expect(final).toHaveBeenCalledTimes(2);
       expect(last).toHaveBeenCalledTimes(1);
       // @ts-ignore
-      expect(result.steps['nested-workflow-a-clone'].output).toMatchObject({
+      expect(result.steps['nested-workflow-a-clone'].output).toEqual({
         finalValue: 26 + 1,
       });
 
       // @ts-ignore
-      expect(result.steps['nested-workflow-b'].output).toMatchObject({
+      expect(result.steps['nested-workflow-b'].output).toEqual({
         finalValue: 1,
       });
 
-      expect(result.steps['last-step']).toMatchObject({
+      expect(result.steps['last-step']).toEqual({
         output: { success: true },
         status: 'success',
       });
@@ -5686,7 +5384,7 @@ describe('MastraInngestWorkflow', () => {
       await new Promise(resolve => setTimeout(resolve, 2000));
 
       // Access new instance properties directly - should work without warning
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       await run.start({ inputData: {} });
 
       srv.close();
@@ -5747,7 +5445,7 @@ describe('MastraInngestWorkflow', () => {
         port: (ctx as any).handlerPort,
       });
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       const result = await run.start({ runtimeContext });
 
       srv.close();
@@ -5800,7 +5498,7 @@ describe('MastraInngestWorkflow', () => {
       });
       workflow.then(step).commit();
 
-      const run = await workflow.createRunAsync();
+      const run = workflow.createRun();
       await run.start({ runtimeContext });
 
       const resumeruntimeContext = new RuntimeContext();
@@ -5819,1049 +5517,5 @@ describe('MastraInngestWorkflow', () => {
     });
   });
 
-  describe('Access to inngest step primitives', () => {
-    it('should inject inngest step primitives into steps during run', async ctx => {
-      const inngest = new Inngest({
-        id: 'mastra',
-        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
-      });
-
-      const { createWorkflow, createStep } = init(inngest);
-
-      const step = createStep({
-        id: 'step1',
-        execute: async ({ engine }) => {
-          return {
-            hasEngine: !!engine.step,
-          };
-        },
-        inputSchema: z.object({}),
-        outputSchema: z.object({}),
-      });
-      const workflow = createWorkflow({
-        id: 'test-workflow',
-        inputSchema: z.object({}),
-        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 = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-
-      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(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 = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-
-      const runId = 'test-run-id';
-      let watchData: StreamEvent[] = [];
-      const run = await workflow.createRunAsync({
-        runId,
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      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 new Promise(resolve => setTimeout(resolve, 1000));
-
-      srv.close();
-
-      expect(watchData.length).toBe(8);
-      expect(watchData).toMatchInlineSnapshot(`
-        [
-          {
-            "payload": {
-              "runId": "test-run-id",
-            },
-            "type": "start",
-          },
-          {
-            "payload": {
-              "id": "step1",
-            },
-            "type": "step-start",
-          },
-          {
-            "payload": {
-              "id": "step1",
-              "output": {
-                "result": "success1",
-              },
-              "status": "success",
-            },
-            "type": "step-result",
-          },
-          {
-            "payload": {
-              "id": "step1",
-              "metadata": {},
-            },
-            "type": "step-finish",
-          },
-          {
-            "payload": {
-              "id": "step2",
-            },
-            "type": "step-start",
-          },
-          {
-            "payload": {
-              "id": "step2",
-              "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),
-      });
-    });
-
-    it('should handle basic sleep waiting flow', 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(step1).sleep(1000).then(step2).commit();
-
-      const mastra = new Mastra({
-        storage: new DefaultStorage({
-          url: ':memory:',
-        }),
-        workflows: {
-          'test-workflow': workflow,
-        },
-        server: {
-          apiRoutes: [
-            {
-              path: '/inngest/api',
-              method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
-            },
-          ],
-        },
-      });
-
-      const app = await createHonoServer(mastra);
-
-      const srv = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-
-      const runId = 'test-run-id';
-      let watchData: StreamEvent[] = [];
-      const run = await workflow.createRunAsync({
-        runId,
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      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 new Promise(resolve => setTimeout(resolve, 1000));
-
-      srv.close();
-
-      expect(watchData.length).toBe(9);
-      expect(watchData).toMatchObject([
-        {
-          payload: {
-            runId: 'test-run-id',
-          },
-          type: 'start',
-        },
-        {
-          payload: {
-            id: 'step1',
-          },
-          type: 'step-start',
-        },
-        {
-          payload: {
-            id: 'step1',
-            output: {
-              result: 'success1',
-            },
-            status: 'success',
-          },
-          type: 'step-result',
-        },
-        {
-          payload: {
-            id: 'step1',
-            metadata: {},
-          },
-          type: 'step-finish',
-        },
-        {
-          payload: {},
-          type: 'step-waiting',
-        },
-        {
-          payload: {
-            id: 'step2',
-          },
-          type: 'step-start',
-        },
-        {
-          payload: {
-            id: 'step2',
-            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),
-      });
-    });
-
-    it('should handle waitForEvent waiting flow', 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(step1).waitForEvent('user-event-test', 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 = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-
-      const runId = 'test-run-id';
-      let watchData: StreamEvent[] = [];
-      const run = await workflow.createRunAsync({
-        runId,
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      const { stream, getWorkflowState } = run.stream({ inputData: {} });
-
-      setTimeout(() => {
-        run.sendEvent('user-event-test', {
-          value: 'eventdata',
-        });
-      }, 3000);
-
-      // Start watching the workflow
-      const collectedStreamData: StreamEvent[] = [];
-      for await (const data of stream) {
-        collectedStreamData.push(JSON.parse(JSON.stringify(data)));
-      }
-      watchData = collectedStreamData;
-      console.dir({ watchData }, { depth: null });
-
-      const executionResult = await getWorkflowState();
-
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      srv.close();
-
-      expect(watchData.length).toBe(9);
-      expect(watchData).toMatchObject([
-        {
-          payload: {
-            runId: 'test-run-id',
-          },
-          type: 'start',
-        },
-        {
-          payload: {
-            id: 'step1',
-          },
-          type: 'step-start',
-        },
-        {
-          payload: {
-            id: 'step1',
-            output: {
-              result: 'success1',
-            },
-            status: 'success',
-          },
-          type: 'step-result',
-        },
-        {
-          payload: {
-            id: 'step1',
-            metadata: {},
-          },
-          type: 'step-finish',
-        },
-        {
-          payload: {
-            id: 'step2',
-          },
-          type: 'step-waiting',
-        },
-        {
-          payload: {
-            id: 'step2',
-          },
-          type: 'step-start',
-        },
-        {
-          payload: {
-            id: 'step2',
-            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',
-        },
-        resumePayload: {
-          value: 'eventdata',
-        },
-        startedAt: expect.any(Number),
-        resumedAt: expect.any(Number),
-        endedAt: expect.any(Number),
-      });
-    });
-
-    it('should handle basic suspend and resume flow', async ctx => {
-      const inngest = new Inngest({
-        id: 'mastra',
-        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
-        middleware: [realtimeMiddleware()],
-      });
-
-      const { createWorkflow, createStep } = init(inngest);
-
-      const getUserInputAction = vi.fn().mockResolvedValue({ userInput: 'test input' });
-      const promptAgentAction = vi
-        .fn()
-        .mockImplementationOnce(async ({ suspend }) => {
-          console.log('suspend');
-          await suspend();
-          return undefined;
-        })
-        .mockImplementationOnce(() => ({ modelOutput: 'test output' }));
-      const evaluateToneAction = vi.fn().mockResolvedValue({
-        toneScore: { score: 0.8 },
-        completenessScore: { score: 0.7 },
-      });
-      const improveResponseAction = vi.fn().mockResolvedValue({ improvedOutput: 'improved output' });
-      const evaluateImprovedAction = vi.fn().mockResolvedValue({
-        toneScore: { score: 0.9 },
-        completenessScore: { score: 0.8 },
-      });
-
-      const getUserInput = createStep({
-        id: 'getUserInput',
-        execute: getUserInputAction,
-        inputSchema: z.object({ input: z.string() }),
-        outputSchema: z.object({ userInput: z.string() }),
-      });
-      const promptAgent = createStep({
-        id: 'promptAgent',
-        execute: promptAgentAction,
-        inputSchema: z.object({ userInput: z.string() }),
-        outputSchema: z.object({ modelOutput: z.string() }),
-      });
-      const evaluateTone = createStep({
-        id: 'evaluateToneConsistency',
-        execute: evaluateToneAction,
-        inputSchema: z.object({ modelOutput: z.string() }),
-        outputSchema: z.object({
-          toneScore: z.any(),
-          completenessScore: z.any(),
-        }),
-      });
-      const improveResponse = createStep({
-        id: 'improveResponse',
-        execute: improveResponseAction,
-        inputSchema: z.object({ toneScore: z.any(), completenessScore: z.any() }),
-        outputSchema: z.object({ improvedOutput: z.string() }),
-      });
-      const evaluateImproved = createStep({
-        id: 'evaluateImprovedResponse',
-        execute: evaluateImprovedAction,
-        inputSchema: z.object({ improvedOutput: z.string() }),
-        outputSchema: z.object({
-          toneScore: z.any(),
-          completenessScore: z.any(),
-        }),
-      });
-
-      const promptEvalWorkflow = createWorkflow({
-        id: 'test-workflow',
-        inputSchema: z.object({ input: z.string() }),
-        outputSchema: z.object({}),
-        steps: [getUserInput, promptAgent, evaluateTone, improveResponse, evaluateImproved],
-      });
-
-      promptEvalWorkflow
-        .then(getUserInput)
-        .then(promptAgent)
-        .then(evaluateTone)
-        .then(improveResponse)
-        .then(evaluateImproved)
-        .commit();
-
-      const mastra = new Mastra({
-        storage: new DefaultStorage({
-          url: ':memory:',
-        }),
-        workflows: {
-          'test-workflow': promptEvalWorkflow,
-        },
-        server: {
-          apiRoutes: [
-            {
-              path: '/inngest/api',
-              method: 'ALL',
-              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
-            },
-          ],
-        },
-      });
-
-      const app = await createHonoServer(mastra);
-
-      const srv = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      const run = await promptEvalWorkflow.createRunAsync();
-
-      const { stream, getWorkflowState } = run.stream({ inputData: { input: 'test' } });
-
-      for await (const data of stream) {
-        if (data.type === 'step-suspended') {
-          expect(promptAgentAction).toHaveBeenCalledTimes(1);
-
-          // make it async to show that execution is not blocked
-          setImmediate(() => {
-            const resumeData = { stepId: 'promptAgent', context: { userInput: 'test input for resumption' } };
-            run.resume({ resumeData: resumeData as any, step: promptAgent });
-          });
-          expect(evaluateToneAction).not.toHaveBeenCalledTimes(1);
-        }
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 5000));
-      const resumeResult = await getWorkflowState();
-
-      srv.close();
-
-      expect(evaluateToneAction).toHaveBeenCalledTimes(1);
-      expect(resumeResult.steps).toMatchObject({
-        input: { input: 'test' },
-        getUserInput: {
-          status: 'success',
-          output: { userInput: 'test input' },
-          payload: { input: 'test' },
-          startedAt: expect.any(Number),
-          endedAt: expect.any(Number),
-        },
-        promptAgent: {
-          status: 'success',
-          output: { modelOutput: 'test output' },
-          payload: { userInput: 'test input' },
-          startedAt: expect.any(Number),
-          endedAt: expect.any(Number),
-          resumePayload: { stepId: 'promptAgent', context: { userInput: 'test input for resumption' } },
-          resumedAt: expect.any(Number),
-          // suspendedAt: expect.any(Number),
-        },
-        evaluateToneConsistency: {
-          status: 'success',
-          output: { toneScore: { score: 0.8 }, completenessScore: { score: 0.7 } },
-          payload: { modelOutput: 'test output' },
-          startedAt: expect.any(Number),
-          endedAt: expect.any(Number),
-        },
-        improveResponse: {
-          status: 'success',
-          output: { improvedOutput: 'improved output' },
-          payload: { toneScore: { score: 0.8 }, completenessScore: { score: 0.7 } },
-          startedAt: expect.any(Number),
-          endedAt: expect.any(Number),
-        },
-        evaluateImprovedResponse: {
-          status: 'success',
-          output: { toneScore: { score: 0.9 }, completenessScore: { score: 0.8 } },
-          payload: { improvedOutput: 'improved output' },
-          startedAt: expect.any(Number),
-          endedAt: expect.any(Number),
-        },
-      });
-    });
-
-    it('should be able to use an agent as 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 workflow = createWorkflow({
-        id: 'test-workflow',
-        inputSchema: z.object({
-          prompt1: z.string(),
-          prompt2: z.string(),
-        }),
-        outputSchema: z.object({}),
-      });
-
-      const agent = new Agent({
-        name: 'test-agent-1',
-        instructions: 'test agent instructions"',
-        model: new MockLanguageModelV1({
-          doStream: async () => ({
-            stream: simulateReadableStream({
-              chunks: [
-                { type: 'text-delta', textDelta: 'Paris' },
-                {
-                  type: 'finish',
-                  finishReason: 'stop',
-                  logprobs: undefined,
-                  usage: { completionTokens: 10, promptTokens: 3 },
-                },
-              ],
-            }),
-            rawCall: { rawPrompt: null, rawSettings: {} },
-          }),
-        }),
-      });
-
-      const agent2 = new Agent({
-        name: 'test-agent-2',
-        instructions: 'test agent instructions',
-        model: new MockLanguageModelV1({
-          doStream: async () => ({
-            stream: simulateReadableStream({
-              chunks: [
-                { type: 'text-delta', textDelta: 'London' },
-                {
-                  type: 'finish',
-                  finishReason: 'stop',
-                  logprobs: undefined,
-                  usage: { completionTokens: 10, promptTokens: 3 },
-                },
-              ],
-            }),
-            rawCall: { rawPrompt: null, rawSettings: {} },
-          }),
-        }),
-      });
-
-      const startStep = createStep({
-        id: 'start',
-        inputSchema: z.object({
-          prompt1: z.string(),
-          prompt2: z.string(),
-        }),
-        outputSchema: z.object({ prompt1: z.string(), prompt2: z.string() }),
-        execute: async ({ inputData }) => {
-          return {
-            prompt1: inputData.prompt1,
-            prompt2: inputData.prompt2,
-          };
-        },
-      });
-
-      const agentStep1 = createStep(agent);
-      const agentStep2 = createStep(agent2);
-
-      workflow
-        .then(startStep)
-        .map({
-          prompt: {
-            step: startStep,
-            path: 'prompt1',
-          },
-        })
-        .then(agentStep1)
-        .map({
-          prompt: {
-            step: startStep,
-            path: 'prompt2',
-          },
-        })
-        .then(agentStep2)
-        .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 = serve({
-        fetch: app.fetch,
-        port: (ctx as any).handlerPort,
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      const run = await workflow.createRunAsync({
-        runId: 'test-run-id',
-      });
-      const { stream } = run.stream({
-        inputData: {
-          prompt1: 'Capital of France, just the name',
-          prompt2: 'Capital of UK, just the name',
-        },
-      });
-
-      const values: StreamEvent[] = [];
-      for await (const value of stream.values()) {
-        values.push(value);
-      }
-
-      srv.close();
-
-      expect(values).toMatchObject([
-        {
-          payload: {
-            runId: 'test-run-id',
-          },
-          type: 'start',
-        },
-        {
-          payload: {
-            id: 'start',
-          },
-          type: 'step-start',
-        },
-        {
-          payload: {
-            id: 'start',
-            output: {
-              prompt1: 'Capital of France, just the name',
-              prompt2: 'Capital of UK, just the name',
-            },
-            status: 'success',
-          },
-          type: 'step-result',
-        },
-        {
-          payload: {
-            id: 'start',
-            metadata: {},
-          },
-          type: 'step-finish',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-          },
-          type: 'step-start',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-            output: {
-              prompt: 'Capital of France, just the name',
-            },
-            status: 'success',
-          },
-          type: 'step-result',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-            metadata: {},
-          },
-          type: 'step-finish',
-        },
-        {
-          payload: {
-            id: 'test-agent-1',
-          },
-          type: 'step-start',
-        },
-        {
-          args: {
-            prompt: 'Capital of France, just the name',
-          },
-          name: 'test-agent-1',
-          type: 'tool-call-streaming-start',
-        },
-        {
-          args: {
-            prompt: 'Capital of France, just the name',
-          },
-          argsTextDelta: 'Paris',
-          name: 'test-agent-1',
-          type: 'tool-call-delta',
-        },
-        {
-          payload: {
-            id: 'test-agent-1',
-            output: {
-              text: 'Paris',
-            },
-            status: 'success',
-          },
-          type: 'step-result',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-            metadata: {},
-          },
-          type: 'step-finish',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-          },
-          type: 'step-start',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-            output: {
-              prompt: 'Capital of UK, just the name',
-            },
-            status: 'success',
-          },
-          type: 'step-result',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-            metadata: {},
-          },
-          type: 'step-finish',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-          },
-          type: 'step-start',
-        },
-        {
-          args: {
-            prompt: 'Capital of UK, just the name',
-          },
-          name: 'test-agent-2',
-          type: 'tool-call-streaming-start',
-        },
-        {
-          args: {
-            prompt: 'Capital of UK, just the name',
-          },
-          argsTextDelta: 'London',
-          name: 'test-agent-2',
-          type: 'tool-call-delta',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-            output: {
-              text: 'London',
-            },
-            status: 'success',
-          },
-          type: 'step-result',
-        },
-        {
-          payload: {
-            id: expect.any(String),
-            metadata: {},
-          },
-          type: 'step-finish',
-        },
-        {
-          payload: {
-            runId: 'test-run-id',
-          },
-          type: 'finish',
-        },
-      ]);
-    });
-  });
+  describe('Access to inngest step primitives', () => {});
 }, 40e3);