@mastra/inngest 0.0.0-declaration-maps-20250730185206 → 0.0.0-feat-tool-input-validation-20250731232758

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @mastra/inngest
 
-## 0.0.0-declaration-maps-20250730185206
+## 0.0.0-feat-tool-input-validation-20250731232758
 
 ### Patch Changes
 
@@ -9,7 +9,8 @@
 - Updated dependencies [33dcb07]
 - Updated dependencies [d30b1a0]
 - Updated dependencies [bff87f7]
-  - @mastra/core@0.0.0-declaration-maps-20250730185206
+- Updated dependencies [ea4a1c2]
+  - @mastra/core@0.0.0-feat-tool-input-validation-20250731232758
 
 ## 0.11.7
 

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

@@ -0,0 +1,316 @@
+import type { Agent } from '@mastra/core';
+import type { BaseContext } from 'inngest';
+import type { ChunkType } from '@mastra/core/workflows';
+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, writableStream, }: {
+        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;
+        writableStream?: WritableStream<ChunkType>;
+    }): Promise<StepResult<any, any, any, any>>;
+    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>;
+    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>;
+    executeWaitForEvent({ event, timeout }: {
+        event: string;
+        timeout?: number;
+    }): Promise<any>;
+    executeStep({ step, stepResults, executionContext, resume, prevOutput, emitter, abortController, runtimeContext, writableStream, }: {
+        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;
+        writableStream?: WritableStream<ChunkType>;
+    }): 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;
+        runtimeContext: RuntimeContext;
+    }): Promise<void>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, stepResults, serializedStepGraph, resume, executionContext, emitter, abortController, runtimeContext, writableStream, }: {
+        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;
+        writableStream?: WritableStream<ChunkType>;
+    }): 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 { }

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

@@ -0,0 +1,316 @@
+import type { Agent } from '@mastra/core';
+import type { BaseContext } from 'inngest';
+import type { ChunkType } from '@mastra/core/workflows';
+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, writableStream, }: {
+        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;
+        writableStream?: WritableStream<ChunkType>;
+    }): Promise<StepResult<any, any, any, any>>;
+    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>;
+    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>;
+    executeWaitForEvent({ event, timeout }: {
+        event: string;
+        timeout?: number;
+    }): Promise<any>;
+    executeStep({ step, stepResults, executionContext, resume, prevOutput, emitter, abortController, runtimeContext, writableStream, }: {
+        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;
+        writableStream?: WritableStream<ChunkType>;
+    }): 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;
+        runtimeContext: RuntimeContext;
+    }): Promise<void>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, stepResults, serializedStepGraph, resume, executionContext, emitter, abortController, runtimeContext, writableStream, }: {
+        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;
+        writableStream?: WritableStream<ChunkType>;
+    }): 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 { }

package/dist/index.cjs

@@ -1297,5 +1297,3 @@ exports.InngestWorkflow = InngestWorkflow;
 exports.createStep = createStep;
 exports.init = init;
 exports.serve = serve;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -0,0 +1,7 @@
+export { serve } from './_tsup-dts-rollup.cjs';
+export { createStep } from './_tsup-dts-rollup.cjs';
+export { init } from './_tsup-dts-rollup.cjs';
+export { InngestEngineType } from './_tsup-dts-rollup.cjs';
+export { InngestRun } from './_tsup-dts-rollup.cjs';
+export { InngestWorkflow } from './_tsup-dts-rollup.cjs';
+export { InngestExecutionEngine } from './_tsup-dts-rollup.cjs';