@mastra/inngest 0.0.0-support-d1-client-20250701191943 → 0.0.0-taofeeq-fix-tool-call-showing-after-message-20250806184630

package/src/index.ts

@@ -3,7 +3,7 @@ import type { ReadableStream } from 'node:stream/web';
 import { subscribe } from '@inngest/realtime';
 import type { Agent, Mastra, ToolExecutionContext, WorkflowRun, WorkflowRuns } from '@mastra/core';
 import { RuntimeContext } from '@mastra/core/di';
-import { Tool } from '@mastra/core/tools';
+import { Tool, ToolStream } from '@mastra/core/tools';
 import { Workflow, Run, DefaultExecutionEngine } from '@mastra/core/workflows';
 import type {
   ExecuteFunction,
@@ -20,6 +20,7 @@ import type {
   Emitter,
   WatchEvent,
   StreamEvent,
+  ChunkType,
 } from '@mastra/core/workflows';
 import { EMITTER_SYMBOL } from '@mastra/core/workflows/_constants';
 import type { Span } from '@opentelemetry/api';
@@ -99,6 +100,7 @@ export class InngestRun<
       await new Promise(resolve => setTimeout(resolve, 1000));
       runs = await this.getRuns(eventId);
       if (runs?.[0]?.status === 'Failed') {
+        console.log('run', runs?.[0]);
         throw new Error(`Function run ${runs?.[0]?.status}`);
       } else if (runs?.[0]?.status === 'Cancelled') {
         const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
@@ -230,6 +232,7 @@ export class InngestRun<
       data: {
         inputData: params.resumeData,
         runId: this.runId,
+        workflowId: this.workflowId,
         stepResults: snapshot?.context as any,
         resume: {
           steps,
@@ -967,6 +970,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     emitter,
     abortController,
     runtimeContext,
+    writableStream,
   }: {
     workflowId: string;
     runId: string;
@@ -981,6 +985,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     emitter: Emitter;
     abortController: AbortController;
     runtimeContext: RuntimeContext;
+    writableStream?: WritableStream<ChunkType>;
   }): Promise<StepResult<any, any, any, any>> {
     return super.executeStep({
       workflowId,
@@ -993,11 +998,188 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
       emitter,
       abortController,
       runtimeContext,
+      writableStream,
     });
   }
 
-  async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
-    await this.inngestStep.sleep(id, duration);
+  // async executeSleep({ id, duration }: { id: string; duration: number }): Promise<void> {
+  //   await this.inngestStep.sleep(id, duration);
+  // }
+
+  async executeSleep({
+    workflowId,
+    runId,
+    entry,
+    prevOutput,
+    stepResults,
+    emitter,
+    abortController,
+    runtimeContext,
+    writableStream,
+  }: {
+    workflowId: string;
+    runId: string;
+    serializedStepGraph: SerializedStepFlowEntry[];
+    entry: {
+      type: 'sleep';
+      id: string;
+      duration?: number;
+      fn?: ExecuteFunction<any, any, any, any, InngestEngineType>;
+    };
+    prevStep: StepFlowEntry;
+    prevOutput: any;
+    stepResults: Record<string, StepResult<any, any, any, any>>;
+    resume?: {
+      steps: string[];
+      stepResults: Record<string, StepResult<any, any, any, any>>;
+      resumePayload: any;
+      resumePath: number[];
+    };
+    executionContext: ExecutionContext;
+    emitter: Emitter;
+    abortController: AbortController;
+    runtimeContext: RuntimeContext;
+    writableStream?: WritableStream<ChunkType>;
+  }): Promise<void> {
+    let { duration, fn } = entry;
+
+    if (fn) {
+      const stepCallId = randomUUID();
+      duration = await this.inngestStep.run(`workflow.${workflowId}.sleep.${entry.id}`, async () => {
+        return await fn({
+          runId,
+          workflowId,
+          mastra: this.mastra!,
+          runtimeContext,
+          inputData: prevOutput,
+          runCount: -1,
+          getInitData: () => stepResults?.input as any,
+          getStepResult: (step: any) => {
+            if (!step?.id) {
+              return null;
+            }
+
+            const result = stepResults[step.id];
+            if (result?.status === 'success') {
+              return result.output;
+            }
+
+            return null;
+          },
+
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload: any): Promise<any> => {},
+          bail: () => {},
+          abort: () => {
+            abortController?.abort();
+          },
+          [EMITTER_SYMBOL]: emitter,
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new ToolStream(
+            {
+              prefix: 'step',
+              callId: stepCallId,
+              name: 'sleep',
+              runId,
+            },
+            writableStream,
+          ),
+        });
+      });
+    }
+
+    await this.inngestStep.sleep(entry.id, !duration || duration < 0 ? 0 : duration);
+  }
+
+  async executeSleepUntil({
+    workflowId,
+    runId,
+    entry,
+    prevOutput,
+    stepResults,
+    emitter,
+    abortController,
+    runtimeContext,
+    writableStream,
+  }: {
+    workflowId: string;
+    runId: string;
+    serializedStepGraph: SerializedStepFlowEntry[];
+    entry: {
+      type: 'sleepUntil';
+      id: string;
+      date?: Date;
+      fn?: ExecuteFunction<any, any, any, any, InngestEngineType>;
+    };
+    prevStep: StepFlowEntry;
+    prevOutput: any;
+    stepResults: Record<string, StepResult<any, any, any, any>>;
+    resume?: {
+      steps: string[];
+      stepResults: Record<string, StepResult<any, any, any, any>>;
+      resumePayload: any;
+      resumePath: number[];
+    };
+    executionContext: ExecutionContext;
+    emitter: Emitter;
+    abortController: AbortController;
+    runtimeContext: RuntimeContext;
+    writableStream?: WritableStream<ChunkType>;
+  }): Promise<void> {
+    let { date, fn } = entry;
+
+    if (fn) {
+      date = await this.inngestStep.run(`workflow.${workflowId}.sleepUntil.${entry.id}`, async () => {
+        const stepCallId = randomUUID();
+        return await fn({
+          runId,
+          workflowId,
+          mastra: this.mastra!,
+          runtimeContext,
+          inputData: prevOutput,
+          runCount: -1,
+          getInitData: () => stepResults?.input as any,
+          getStepResult: (step: any) => {
+            if (!step?.id) {
+              return null;
+            }
+
+            const result = stepResults[step.id];
+            if (result?.status === 'success') {
+              return result.output;
+            }
+
+            return null;
+          },
+
+          // TODO: this function shouldn't have suspend probably?
+          suspend: async (_suspendPayload: any): Promise<any> => {},
+          bail: () => {},
+          abort: () => {
+            abortController?.abort();
+          },
+          [EMITTER_SYMBOL]: emitter,
+          engine: { step: this.inngestStep },
+          abortSignal: abortController?.signal,
+          writer: new ToolStream(
+            {
+              prefix: 'step',
+              callId: stepCallId,
+              name: 'sleep',
+              runId,
+            },
+            writableStream,
+          ),
+        });
+      });
+    }
+
+    if (!(date instanceof Date)) {
+      return;
+    }
+
+    await this.inngestStep.sleepUntil(entry.id, date);
   }
 
   async executeWaitForEvent({ event, timeout }: { event: string; timeout?: number }): Promise<any> {
@@ -1022,6 +1204,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     emitter,
     abortController,
     runtimeContext,
+    writableStream,
   }: {
     step: Step<string, any, any>;
     stepResults: Record<string, StepResult<any, any, any, any>>;
@@ -1035,6 +1218,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     emitter: Emitter;
     abortController: AbortController;
     runtimeContext: RuntimeContext;
+    writableStream?: WritableStream<ChunkType>;
   }): Promise<StepResult<any, any, any, any>> {
     const startedAt = await this.inngestStep.run(
       `workflow.${executionContext.workflowId}.run.${executionContext.runId}.step.${step.id}.running_ev`,
@@ -1067,6 +1251,8 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           payload: {
             id: step.id,
             status: 'running',
+            payload: prevOutput,
+            startedAt,
           },
         });
 
@@ -1276,6 +1462,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           runId: executionContext.runId,
           mastra: this.mastra!,
           runtimeContext,
+          writableStream,
           inputData: prevOutput,
           resumeData: resume?.steps[0] === step.id ? resume?.resumePayload : undefined,
           getInitData: () => stepResults?.input as any,
@@ -1422,6 +1609,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     workflowStatus: 'success' | 'failed' | 'suspended' | 'running';
     result?: Record<string, any>;
     error?: string | Error;
+    runtimeContext: RuntimeContext;
   }) {
     await this.inngestStep.run(
       `workflow.${workflowId}.run.${runId}.path.${JSON.stringify(executionContext.executionPath)}.stepUpdate`,
@@ -1460,6 +1648,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     emitter,
     abortController,
     runtimeContext,
+    writableStream,
   }: {
     workflowId: string;
     runId: string;
@@ -1482,6 +1671,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
     emitter: Emitter;
     abortController: AbortController;
     runtimeContext: RuntimeContext;
+    writableStream?: WritableStream<ChunkType>;
   }): Promise<StepResult<any, any, any, any>> {
     let execResults: any;
     const truthyIndexes = (
@@ -1491,6 +1681,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
             try {
               const result = await cond({
                 runId,
+                workflowId,
                 mastra: this.mastra!,
                 runtimeContext,
                 runCount: -1,
@@ -1520,6 +1711,15 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
                   step: this.inngestStep,
                 },
                 abortSignal: abortController.signal,
+                writer: new ToolStream(
+                  {
+                    prefix: 'step',
+                    callId: randomUUID(),
+                    name: 'conditional',
+                    runId,
+                  },
+                  writableStream,
+                ),
               });
               return result ? index : null;
               // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1553,6 +1753,7 @@ export class InngestExecutionEngine extends DefaultExecutionEngine {
           emitter,
           abortController,
           runtimeContext,
+          writableStream,
         }),
       ),
     );

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": ["./tsconfig.json", "../../tsconfig.build.json"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts", "src/**/*.mock.ts"]
+}

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
   "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "tsup.config.ts"],
   "exclude": ["node_modules", "**/*.test.ts"]
 }

package/tsup.config.ts

@@ -0,0 +1,17 @@
+import { generateTypes } from '@internal/types-builder';
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  clean: true,
+  dts: false,
+  splitting: true,
+  treeshake: {
+    preset: 'smallest',
+  },
+  sourcemap: true,
+  onSuccess: async () => {
+    await generateTypes(process.cwd());
+  },
+});

package/vitest.config.ts

@@ -4,5 +4,11 @@ export default defineConfig({
   test: {
     globals: true,
     include: ['src/**/*.test.ts'],
+    pool: 'threads',
+    poolOptions: {
+      threads: {
+        singleThread: true,
+      },
+    },
   },
 });

package/dist/_tsup-dts-rollup.d.cts

@@ -1,265 +0,0 @@
-import type { Agent } from '@mastra/core';
-import type { BaseContext } from 'inngest';
-import { ClientOptions } from 'inngest';
-import { DefaultExecutionEngine } from '@mastra/core/workflows';
-import type { Emitter } from '@mastra/core/workflows';
-import type { ExecuteFunction } from '@mastra/core/workflows';
-import type { ExecutionContext } from '@mastra/core/workflows';
-import type { ExecutionEngine } from '@mastra/core/workflows';
-import type { ExecutionGraph } from '@mastra/core/workflows';
-import { Handler } from 'inngest';
-import type { Inngest } from 'inngest';
-import { InngestFunction } from 'inngest';
-import { InngestMiddleware } from 'inngest';
-import type { Mastra } from '@mastra/core';
-import type { ReadableStream as ReadableStream_2 } from 'node:stream/web';
-import { Run } from '@mastra/core/workflows';
-import { RuntimeContext } from '@mastra/core/di';
-import type { SerializedStepFlowEntry } from '@mastra/core/workflows';
-import { serve as serve_2 } from 'inngest/hono';
-import type { Span } from '@opentelemetry/api';
-import type { Step } from '@mastra/core/workflows';
-import type { StepFlowEntry } from '@mastra/core/workflows';
-import type { StepResult } from '@mastra/core/workflows';
-import type { StreamEvent } from '@mastra/core/workflows';
-import { Tool } from '@mastra/core/tools';
-import type { ToolExecutionContext } from '@mastra/core';
-import type { WatchEvent } from '@mastra/core/workflows';
-import { Workflow } from '@mastra/core/workflows';
-import type { WorkflowConfig } from '@mastra/core/workflows';
-import type { WorkflowResult } from '@mastra/core/workflows';
-import type { WorkflowRun } from '@mastra/core';
-import type { WorkflowRuns } from '@mastra/core';
-import { z } from 'zod';
-
-export declare function createStep<TStepId extends string, TStepInput extends z.ZodType<any>, TStepOutput extends z.ZodType<any>, TResumeSchema extends z.ZodType<any>, TSuspendSchema extends z.ZodType<any>>(params: {
-    id: TStepId;
-    description?: string;
-    inputSchema: TStepInput;
-    outputSchema: TStepOutput;
-    resumeSchema?: TResumeSchema;
-    suspendSchema?: TSuspendSchema;
-    execute: ExecuteFunction<z.infer<TStepInput>, z.infer<TStepOutput>, z.infer<TResumeSchema>, z.infer<TSuspendSchema>, InngestEngineType>;
-}): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema, InngestEngineType>;
-
-export declare function createStep<TStepId extends string, TStepInput extends z.ZodObject<{
-    prompt: z.ZodString;
-}>, TStepOutput extends z.ZodObject<{
-    text: z.ZodString;
-}>, TResumeSchema extends z.ZodType<any>, TSuspendSchema extends z.ZodType<any>>(agent: Agent<TStepId, any, any>): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema, InngestEngineType>;
-
-export declare function createStep<TSchemaIn extends z.ZodType<any>, TSchemaOut extends z.ZodType<any>, TContext extends ToolExecutionContext<TSchemaIn>>(tool: Tool<TSchemaIn, TSchemaOut, TContext> & {
-    inputSchema: TSchemaIn;
-    outputSchema: TSchemaOut;
-    execute: (context: TContext) => Promise<any>;
-}): Step<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>, InngestEngineType>;
-
-export declare function init(inngest: Inngest): {
-    createWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any, z.ZodTypeDef, any>, TOutput extends z.ZodType<any> = z.ZodType<any, z.ZodTypeDef, any>, TSteps extends Step<string, any, any, any, any, InngestEngineType>[] = Step<string, any, any, any, any, InngestEngineType>[]>(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>): InngestWorkflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TInput>;
-    createStep: typeof createStep;
-    cloneStep<TStepId extends string>(step: Step<string, any, any, any, any, InngestEngineType>, opts: {
-        id: TStepId;
-    }): Step<TStepId, any, any, any, any, InngestEngineType>;
-    cloneWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any, z.ZodTypeDef, any>, TOutput extends z.ZodType<any> = z.ZodType<any, z.ZodTypeDef, any>, TSteps extends Step<string, any, any, any, any, InngestEngineType>[] = Step<string, any, any, any, any, InngestEngineType>[], TPrevSchema extends z.ZodType<any> = TInput>(workflow: Workflow<InngestEngineType, TSteps, string, TInput, TOutput, TPrevSchema>, opts: {
-        id: TWorkflowId;
-    }): Workflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema>;
-};
-
-export declare type InngestEngineType = {
-    step: any;
-};
-
-export declare class InngestExecutionEngine extends DefaultExecutionEngine {
-    private inngestStep;
-    private inngestAttempts;
-    constructor(mastra: Mastra, inngestStep: BaseContext<Inngest>['step'], inngestAttempts?: number);
-    execute<TInput, TOutput>(params: {
-        workflowId: string;
-        runId: string;
-        graph: ExecutionGraph;
-        serializedStepGraph: SerializedStepFlowEntry[];
-        input?: TInput;
-        resume?: {
-            steps: string[];
-            stepResults: Record<string, StepResult<any, any, any, any>>;
-            resumePayload: any;
-            resumePath: number[];
-        };
-        emitter: Emitter;
-        retryConfig?: {
-            attempts?: number;
-            delay?: number;
-        };
-        runtimeContext: RuntimeContext;
-        abortController: AbortController;
-    }): Promise<TOutput>;
-    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: Emitter, stepResults: Record<string, StepResult<any, any, any, any>>, lastOutput: StepResult<any, any, any, any>, error?: Error | string): Promise<TOutput>;
-    superExecuteStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, abortController, runtimeContext, }: {
-        workflowId: string;
-        runId: string;
-        step: Step<string, any, any>;
-        stepResults: Record<string, StepResult<any, any, any, any>>;
-        executionContext: ExecutionContext;
-        resume?: {
-            steps: string[];
-            resumePayload: any;
-        };
-        prevOutput: any;
-        emitter: Emitter;
-        abortController: AbortController;
-        runtimeContext: RuntimeContext;
-    }): Promise<StepResult<any, any, any, any>>;
-    executeSleep({ id, duration }: {
-        id: string;
-        duration: number;
-    }): Promise<void>;
-    executeWaitForEvent({ event, timeout }: {
-        event: string;
-        timeout?: number;
-    }): Promise<any>;
-    executeStep({ step, stepResults, executionContext, resume, prevOutput, emitter, abortController, runtimeContext, }: {
-        step: Step<string, any, any>;
-        stepResults: Record<string, StepResult<any, any, any, any>>;
-        executionContext: ExecutionContext;
-        resume?: {
-            steps: string[];
-            resumePayload: any;
-            runId?: string;
-        };
-        prevOutput: any;
-        emitter: Emitter;
-        abortController: AbortController;
-        runtimeContext: RuntimeContext;
-    }): Promise<StepResult<any, any, any, any>>;
-    persistStepUpdate({ workflowId, runId, stepResults, executionContext, serializedStepGraph, workflowStatus, result, error, }: {
-        workflowId: string;
-        runId: string;
-        stepResults: Record<string, StepResult<any, any, any, any>>;
-        serializedStepGraph: SerializedStepFlowEntry[];
-        executionContext: ExecutionContext;
-        workflowStatus: 'success' | 'failed' | 'suspended' | 'running';
-        result?: Record<string, any>;
-        error?: string | Error;
-    }): Promise<void>;
-    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, stepResults, serializedStepGraph, resume, executionContext, emitter, abortController, runtimeContext, }: {
-        workflowId: string;
-        runId: string;
-        entry: {
-            type: 'conditional';
-            steps: StepFlowEntry[];
-            conditions: ExecuteFunction<any, any, any, any, InngestEngineType>[];
-        };
-        prevStep: StepFlowEntry;
-        serializedStepGraph: SerializedStepFlowEntry[];
-        prevOutput: any;
-        stepResults: Record<string, StepResult<any, any, any, any>>;
-        resume?: {
-            steps: string[];
-            stepResults: Record<string, StepResult<any, any, any, any>>;
-            resumePayload: any;
-            resumePath: number[];
-        };
-        executionContext: ExecutionContext;
-        emitter: Emitter;
-        abortController: AbortController;
-        runtimeContext: RuntimeContext;
-    }): Promise<StepResult<any, any, any, any>>;
-}
-
-export declare class InngestRun<TEngineType = InngestEngineType, TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>> extends Run<TEngineType, TSteps, TInput, TOutput> {
-    #private;
-    private inngest;
-    serializedStepGraph: SerializedStepFlowEntry[];
-    constructor(params: {
-        workflowId: string;
-        runId: string;
-        executionEngine: ExecutionEngine;
-        executionGraph: ExecutionGraph;
-        serializedStepGraph: SerializedStepFlowEntry[];
-        mastra?: Mastra;
-        retryConfig?: {
-            attempts?: number;
-            delay?: number;
-        };
-        cleanup?: () => void;
-    }, inngest: Inngest);
-    getRuns(eventId: string): Promise<any>;
-    getRunOutput(eventId: string): Promise<any>;
-    sendEvent(event: string, data: any): Promise<void>;
-    cancel(): Promise<void>;
-    start({ inputData, }: {
-        inputData?: z.infer<TInput>;
-        runtimeContext?: RuntimeContext;
-    }): Promise<WorkflowResult<TOutput, TSteps>>;
-    resume<TResumeSchema extends z.ZodType<any>>(params: {
-        resumeData?: z.infer<TResumeSchema>;
-        step: Step<string, any, any, TResumeSchema, any> | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>] | string | string[];
-        runtimeContext?: RuntimeContext;
-    }): Promise<WorkflowResult<TOutput, TSteps>>;
-    _resume<TResumeSchema extends z.ZodType<any>>(params: {
-        resumeData?: z.infer<TResumeSchema>;
-        step: Step<string, any, any, TResumeSchema, any> | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>] | string | string[];
-        runtimeContext?: RuntimeContext;
-    }): Promise<WorkflowResult<TOutput, TSteps>>;
-    watch(cb: (event: WatchEvent) => void, type?: 'watch' | 'watch-v2'): () => void;
-    stream({ inputData, runtimeContext }?: {
-        inputData?: z.infer<TInput>;
-        runtimeContext?: RuntimeContext;
-    }): {
-        stream: ReadableStream_2<StreamEvent>;
-        getWorkflowState: () => Promise<WorkflowResult<TOutput, TSteps>>;
-    };
-}
-
-export declare class InngestWorkflow<TEngineType = InngestEngineType, TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TPrevSchema extends z.ZodType<any> = TInput> extends Workflow<TEngineType, TSteps, TWorkflowId, TInput, TOutput, TPrevSchema> {
-    #private;
-    inngest: Inngest;
-    private function;
-    constructor(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest);
-    getWorkflowRuns(args?: {
-        fromDate?: Date;
-        toDate?: Date;
-        limit?: number;
-        offset?: number;
-        resourceId?: string;
-    }): Promise<WorkflowRuns>;
-    getWorkflowRunById(runId: string): Promise<WorkflowRun | null>;
-    getWorkflowRunExecutionResult(runId: string): Promise<WatchEvent['payload']['workflowState'] | null>;
-    __registerMastra(mastra: Mastra): void;
-    createRun(options?: {
-        runId?: string;
-    }): Run<TEngineType, TSteps, TInput, TOutput>;
-    createRunAsync(options?: {
-        runId?: string;
-    }): Promise<Run<TEngineType, TSteps, TInput, TOutput>>;
-    getFunction(): InngestFunction<Omit<InngestFunction.Options<Inngest<ClientOptions>, InngestMiddleware.Stack, InngestFunction.Trigger<string>[] | [{
-    cron: string;
-    } & Partial<Record<"event" | "if", never>>] | [{
-    event: string;
-    if?: string;
-    } & Partial<Record<"cron", never>>], Handler.Any>, "triggers">, Handler.Any, Handler.Any, Inngest<ClientOptions>, InngestMiddleware.Stack, InngestFunction.Trigger<string>[] | [{
-    cron: string;
-    } & Partial<Record<"event" | "if", never>>] | [{
-    event: string;
-    if?: string;
-    } & Partial<Record<"cron", never>>]>;
-    getNestedFunctions(steps: StepFlowEntry[]): ReturnType<Inngest['createFunction']>[];
-    getFunctions(): InngestFunction<Omit<InngestFunction.Options<Inngest<ClientOptions>, InngestMiddleware.Stack, InngestFunction.Trigger<string>[] | [{
-    cron: string;
-    } & Partial<Record<"event" | "if", never>>] | [{
-    event: string;
-    if?: string;
-    } & Partial<Record<"cron", never>>], Handler.Any>, "triggers">, Handler.Any, Handler.Any, Inngest<ClientOptions>, InngestMiddleware.Stack, InngestFunction.Trigger<string>[] | [{
-    cron: string;
-    } & Partial<Record<"event" | "if", never>>] | [{
-    event: string;
-    if?: string;
-    } & Partial<Record<"cron", never>>]>[];
-}
-
-export declare function serve({ mastra, inngest }: {
-    mastra: Mastra;
-    inngest: Inngest;
-}): ReturnType<typeof serve_2>;
-
-export { }