@mastra/core 0.9.0 → 0.9.1-alpha.0

package/dist/agent/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkATXF6TIO_cjs = require('../chunk-ATXF6TIO.cjs');
+var chunk5RNAWF6S_cjs = require('../chunk-5RNAWF6S.cjs');
 
 
 
 Object.defineProperty(exports, "Agent", {
   enumerable: true,
-  get: function () { return chunkATXF6TIO_cjs.Agent; }
+  get: function () { return chunk5RNAWF6S_cjs.Agent; }
 });

package/dist/agent/index.d.cts

@@ -1,7 +1,7 @@
 export { Message as AiMessageType } from 'ai';
 import 'json-schema';
 import 'zod';
-export { j as Agent, k as AgentConfig, aM as AgentGenerateOptions, aN as AgentStreamOptions, aG as MastraLanguageModel, aH as ToolsInput, aL as ToolsetsInput } from '../base-oP3DoUrm.cjs';
+export { F as Agent, G as AgentConfig, b6 as AgentGenerateOptions, b7 as AgentStreamOptions, b0 as MastraLanguageModel, b1 as ToolsInput, b5 as ToolsetsInput } from '../base-CDhO2lMb.cjs';
 import '../base-BihKcqDY.cjs';
 import '../di/index.cjs';
 import '../types-BtMyV38I.cjs';
@@ -16,6 +16,7 @@ import '../vector/index.cjs';
 import '../vector/filter/index.cjs';
 import '@opentelemetry/sdk-trace-base';
 import '../tts/index.cjs';
+import 'events';
 import '../deployer/index.cjs';
 import '../bundler/index.cjs';
 import 'hono';

package/dist/agent/index.d.ts

@@ -1,7 +1,7 @@
 export { Message as AiMessageType } from 'ai';
 import 'json-schema';
 import 'zod';
-export { j as Agent, k as AgentConfig, aM as AgentGenerateOptions, aN as AgentStreamOptions, aG as MastraLanguageModel, aH as ToolsInput, aL as ToolsetsInput } from '../base-Bk5V1doj.js';
+export { F as Agent, G as AgentConfig, b6 as AgentGenerateOptions, b7 as AgentStreamOptions, b0 as MastraLanguageModel, b1 as ToolsInput, b5 as ToolsetsInput } from '../base-5aS_vKtG.js';
 import '../base-DT2poiVK.js';
 import '../di/index.js';
 import '../types-BtMyV38I.js';
@@ -16,6 +16,7 @@ import '../vector/index.js';
 import '../vector/filter/index.js';
 import '@opentelemetry/sdk-trace-base';
 import '../tts/index.js';
+import 'events';
 import '../deployer/index.js';
 import '../bundler/index.js';
 import 'hono';

package/dist/agent/index.js

@@ -1 +1 @@
-export { Agent } from '../chunk-HARYMLZH.js';
+export { Agent } from '../chunk-XQMX3MB3.js';

package/dist/{base-Bk5V1doj.d.ts → base-5aS_vKtG.d.ts}

@@ -6,13 +6,14 @@ import { Query } from 'sift';
 import { z, ZodSchema } from 'zod';
 import { JSONSchema7 } from 'json-schema';
 import { RuntimeContext } from './di/index.js';
-import { B as BaseLogMessage, R as RegisteredLogger, L as Logger, d as Run } from './index-CquI0inB.js';
+import { B as BaseLogMessage, R as RegisteredLogger, L as Logger, d as Run$1 } from './index-CquI0inB.js';
 import { Span } from '@opentelemetry/api';
 import * as xstate from 'xstate';
 import { Snapshot } from 'xstate';
-import EventEmitter from 'node:events';
+import EventEmitter$1 from 'node:events';
 import { MastraVector } from './vector/index.js';
 import { MastraTTS } from './tts/index.js';
+import EventEmitter from 'events';
 import { MastraDeployer } from './deployer/index.js';
 import { Handler, MiddlewareHandler } from 'hono';
 import { cors } from 'hono/cors';
@@ -51,7 +52,13 @@ declare class Tool<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchem
     mastra?: Mastra;
     constructor(opts: ToolAction<TSchemaIn, TSchemaOut, TContext>);
 }
-declare function createTool<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>>(opts: ToolAction<TSchemaIn, TSchemaOut, TContext>): Tool<TSchemaIn, TSchemaOut, TContext>;
+declare function createTool<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>, TExecute extends ToolAction<TSchemaIn, TSchemaOut, TContext>['execute'] = ToolAction<TSchemaIn, TSchemaOut, TContext>['execute']>(opts: ToolAction<TSchemaIn, TSchemaOut, TContext> & {
+    execute?: TExecute;
+}): [TSchemaIn, TSchemaOut, TExecute] extends [z.ZodSchema, z.ZodSchema, Function] ? Tool<TSchemaIn, TSchemaOut, TContext> & {
+    inputSchema: TSchemaIn;
+    outputSchema: TSchemaOut;
+    execute: (context: TContext) => Promise<any>;
+} : Tool<TSchemaIn, TSchemaOut, TContext>;
 
 type AgentNetworkConfig = {
     name: string;
@@ -169,6 +176,420 @@ declare class AgentNetwork extends MastraBase {
     __registerMastra(p: Mastra): void;
 }
 
+type ExecuteFunction<TStepInput, TStepOutput, TResumeSchema, TSuspendSchema> = (params: {
+    mastra: Mastra;
+    container: RuntimeContext;
+    inputData: TStepInput;
+    resumeData?: TResumeSchema;
+    getInitData<T extends NewWorkflow<any, any, any, any, any>>(): T extends undefined ? unknown : z.infer<NonNullable<T['inputSchema']>>;
+    getStepResult<T extends NewStep<any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
+    suspend(suspendPayload: TSuspendSchema): Promise<void>;
+    resume?: {
+        steps: string[];
+        resumePayload: any;
+    };
+    emitter: EventEmitter;
+}) => Promise<TStepOutput>;
+interface NewStep<TStepId extends string = string, TSchemaIn extends z.ZodType<any> = z.ZodType<any>, TSchemaOut extends z.ZodType<any> = z.ZodType<any>, TResumeSchema extends z.ZodType<any> = z.ZodType<any>, TSuspendSchema extends z.ZodType<any> = z.ZodType<any>> {
+    id: TStepId;
+    description?: string;
+    inputSchema: TSchemaIn;
+    outputSchema: TSchemaOut;
+    resumeSchema?: TResumeSchema;
+    suspendSchema?: TSuspendSchema;
+    execute: ExecuteFunction<z.infer<TSchemaIn>, z.infer<TSchemaOut>, z.infer<TResumeSchema>, z.infer<TSuspendSchema>>;
+    retries?: number;
+}
+
+type StepSuccess$1<T> = {
+    status: 'success';
+    output: T;
+};
+type StepFailure$1 = {
+    status: 'failed';
+    error: string;
+};
+type StepSuspended$1<T> = {
+    status: 'suspended';
+    payload: T;
+};
+type StepResult$1<T> = StepSuccess$1<T> | StepFailure$1 | StepSuspended$1<T>;
+type StepsRecord$1<T extends readonly NewStep<any, any, any>[]> = {
+    [K in T[number]['id']]: Extract<T[number], {
+        id: K;
+    }>;
+};
+type PathsToStringProps$1<T> = T extends object ? {
+    [K in keyof T]: T[K] extends object ? K extends string ? K | `${K}.${PathsToStringProps$1<T[K]>}` : never : K extends string ? K : never;
+}[keyof T] : never;
+type ExtractSchemaType$1<T extends z.ZodType<any>> = T extends z.ZodObject<infer V> ? V : never;
+type ExtractSchemaFromStep$1<TStep extends NewStep<any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
+type VariableReference$1<TStep extends NewStep<string, any, any> = NewStep<string, any, any>, TVarPath extends PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.' = PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.'> = {
+    step: TStep;
+    path: TVarPath;
+} | {
+    value: any;
+    schema: z.ZodTypeAny;
+};
+type WatchEvent = {
+    type: 'watch';
+    payload: {
+        currentStep: {
+            id: string;
+            status: 'running' | 'completed' | 'failed' | 'suspended';
+            output?: Record<string, any>;
+            payload?: Record<string, any>;
+        };
+        workflowState: {
+            status: 'running' | 'completed' | 'failed' | 'suspended';
+            steps: Record<string, {
+                status: 'running' | 'completed' | 'failed' | 'suspended';
+                output?: Record<string, any>;
+                payload?: Record<string, any>;
+            }>;
+            output?: Record<string, any>;
+            payload?: Record<string, any>;
+        };
+    };
+    eventTimestamp: Date;
+};
+type ZodPathType<T extends z.ZodTypeAny, P extends string> = T extends z.ZodObject<infer Shape> ? P extends `${infer Key}.${infer Rest}` ? Key extends keyof Shape ? Shape[Key] extends z.ZodTypeAny ? ZodPathType<Shape[Key], Rest> : never : never : P extends keyof Shape ? Shape[P] : never : never;
+
+/**
+ * Represents an execution graph for a workflow
+ */
+interface ExecutionGraph {
+    id: string;
+    steps: StepFlowEntry[];
+}
+/**
+ * Execution engine abstract class for building and executing workflow graphs
+ * Providers will implement this class to provide their own execution logic
+ */
+declare abstract class ExecutionEngine extends MastraBase {
+    protected mastra?: Mastra;
+    constructor({ mastra }: {
+        mastra?: Mastra;
+    });
+    __registerMastra(mastra: Mastra): void;
+    /**
+     * Executes a workflow run with the provided execution graph and input
+     * @param graph The execution graph to execute
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    abstract execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult$1<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: EventEmitter;
+        container: RuntimeContext;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+    }): Promise<TOutput>;
+}
+
+type StepFlowEntry = {
+    type: 'step';
+    step: NewStep;
+} | {
+    type: 'parallel';
+    steps: StepFlowEntry[];
+} | {
+    type: 'conditional';
+    steps: StepFlowEntry[];
+    conditions: ExecuteFunction<any, any, any, any>[];
+} | {
+    type: 'loop';
+    step: NewStep;
+    condition: ExecuteFunction<any, any, any, any>;
+    loopType: 'dowhile' | 'dountil';
+} | {
+    type: 'foreach';
+    step: NewStep;
+    opts: {
+        concurrency: number;
+    };
+};
+/**
+ * Creates a new workflow step
+ * @param params Configuration parameters for the step
+ * @param params.id Unique identifier for the step
+ * @param params.description Optional description of what the step does
+ * @param params.inputSchema Zod schema defining the input structure
+ * @param params.outputSchema Zod schema defining the output structure
+ * @param params.execute Function that performs the step's operations
+ * @returns A Step object that can be added to the workflow
+ */
+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>>;
+}): NewStep<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema>;
+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>): NewStep<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema>;
+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>;
+}): NewStep<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>>;
+declare function cloneStep<TStepId extends string>(step: NewStep<TStepId, any, any>, opts: {
+    id: TStepId;
+}): NewStep<string, any, any>;
+declare function createWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends NewStep<string, any, any>[] = NewStep<string, any, any>[]>(params: NewWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TInput>;
+type WorkflowStatus<TOutput extends z.ZodType<any>, TSteps extends NewStep<string, any, any>[]> = {
+    status: 'success';
+    result: z.infer<TOutput>;
+    steps: {
+        [K in keyof StepsRecord$1<TSteps>]: StepsRecord$1<TSteps>[K]['outputSchema'] extends undefined ? StepResult$1<unknown> : StepResult$1<z.infer<NonNullable<StepsRecord$1<TSteps>[K]['outputSchema']>>>;
+    };
+} | {
+    status: 'failed';
+    steps: {
+        [K in keyof StepsRecord$1<TSteps>]: StepsRecord$1<TSteps>[K]['outputSchema'] extends undefined ? StepResult$1<unknown> : StepResult$1<z.infer<NonNullable<StepsRecord$1<TSteps>[K]['outputSchema']>>>;
+    };
+    error: string;
+} | {
+    status: 'suspended';
+    steps: {
+        [K in keyof StepsRecord$1<TSteps>]: StepsRecord$1<TSteps>[K]['outputSchema'] extends undefined ? StepResult$1<unknown> : StepResult$1<z.infer<NonNullable<StepsRecord$1<TSteps>[K]['outputSchema']>>>;
+    };
+    suspended: [string[], ...string[][]];
+};
+type NewWorkflowConfig<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends NewStep<string, any, any>[] = NewStep<string, any, any>[]> = {
+    mastra?: Mastra;
+    id: TWorkflowId;
+    description?: string | undefined;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    executionEngine?: ExecutionEngine;
+    steps?: TSteps;
+    retryConfig?: {
+        attempts?: number;
+        delay?: number;
+    };
+};
+declare class NewWorkflow<TSteps extends NewStep<string, any, any>[] = NewStep<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 MastraBase implements NewStep<TWorkflowId, TInput, TOutput> {
+    #private;
+    id: TWorkflowId;
+    description?: string | undefined;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    protected stepFlow: StepFlowEntry[];
+    protected executionEngine: ExecutionEngine;
+    protected executionGraph: ExecutionGraph;
+    protected retryConfig: {
+        attempts?: number;
+        delay?: number;
+    };
+    constructor({ mastra, id, inputSchema, outputSchema, description, executionEngine, retryConfig, }: NewWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>);
+    __registerMastra(mastra: Mastra): void;
+    __registerPrimitives(p: MastraPrimitives): void;
+    /**
+     * Adds a step to the workflow
+     * @param step The step to add to the workflow
+     * @returns The workflow instance for chaining
+     */
+    then<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    map<TSteps extends NewStep<string, any, any>[], TMapping extends {
+        [K in keyof TMapping]: {
+            step: TSteps[number];
+            path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], 'outputSchema'>>> | '.';
+        } | {
+            value: any;
+            schema: z.ZodTypeAny;
+        } | {
+            initData: TSteps[number];
+            path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], 'inputSchema'>>> | '.';
+        } | {
+            containerPath: string;
+            schema: z.ZodTypeAny;
+        };
+    }>(mappingConfig: TMapping): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodObject<{ [K in keyof TMapping]: TMapping[K] extends {
+        step: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "outputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["step"]["outputSchema"] : ZodPathType<TMapping[K]["step"]["outputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        initData: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "inputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["initData"]["inputSchema"] : ZodPathType<TMapping[K]["initData"]["inputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        value: any;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : TMapping[K] extends {
+        containerPath: string;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : never; }, any, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{ [K in keyof TMapping]: TMapping[K] extends {
+        step: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "outputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["step"]["outputSchema"] : ZodPathType<TMapping[K]["step"]["outputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        initData: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "inputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["initData"]["inputSchema"] : ZodPathType<TMapping[K]["initData"]["inputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        value: any;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : TMapping[K] extends {
+        containerPath: string;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : never; }>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{ [K in keyof TMapping]: TMapping[K] extends {
+        step: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "outputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["step"]["outputSchema"] : ZodPathType<TMapping[K]["step"]["outputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        initData: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "inputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["initData"]["inputSchema"] : ZodPathType<TMapping[K]["initData"]["inputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        value: any;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : TMapping[K] extends {
+        containerPath: string;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : never; }>, any>[k]; } : never, z.baseObjectInputType<{ [K in keyof TMapping]: TMapping[K] extends {
+        step: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "outputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["step"]["outputSchema"] : ZodPathType<TMapping[K]["step"]["outputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        initData: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "inputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["initData"]["inputSchema"] : ZodPathType<TMapping[K]["initData"]["inputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        value: any;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : TMapping[K] extends {
+        containerPath: string;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : never; }> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{ [K in keyof TMapping]: TMapping[K] extends {
+        step: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "outputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["step"]["outputSchema"] : ZodPathType<TMapping[K]["step"]["outputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        initData: TSteps[number];
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TSteps[number], "inputSchema">>>;
+    } ? TMapping[K]["path"] extends "." ? TMapping[K]["initData"]["inputSchema"] : ZodPathType<TMapping[K]["initData"]["inputSchema"], TMapping[K]["path"]> : TMapping[K] extends {
+        value: any;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : TMapping[K] extends {
+        containerPath: string;
+        schema: z.ZodTypeAny;
+    } ? TMapping[K]["schema"] : never; }>[k_1]; } : never>>;
+    parallel<TParallelSteps extends NewStep<string, TPrevSchema, any, any, any>[]>(steps: TParallelSteps): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodObject<{ [K in keyof StepsRecord$1<TParallelSteps>]: StepsRecord$1<TParallelSteps>[K]["outputSchema"]["path"]; }, any, z.ZodTypeAny>>;
+    branch<TBranchSteps extends Array<[
+        ExecuteFunction<z.infer<TPrevSchema>, any, any, any>,
+        NewStep<string, TPrevSchema, any, any, any>
+    ]>>(steps: TBranchSteps): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodObject<{ [K in keyof StepsRecord$1<{ [K_1 in keyof TBranchSteps]: TBranchSteps[K_1][1]; }[number][]>]: StepsRecord$1<{ [K_1 in keyof TBranchSteps]: TBranchSteps[K_1][1]; }[number][]>[K]["outputSchema"]; }, any, z.ZodTypeAny>>;
+    dowhile<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    dountil<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    foreach<TPrevIsArray extends TPrevSchema extends z.ZodArray<any> ? true : false, TStepInputSchema extends TPrevSchema extends z.ZodArray<infer TElement> ? TElement : never, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: TPrevIsArray extends true ? NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any> : 'Previous step must return an array type', opts?: {
+        concurrency: number;
+    }): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodArray<TSchemaOut>>;
+    /**
+     * Builds the execution graph for this workflow
+     * @returns The execution graph that can be used to execute the workflow
+     */
+    buildExecutionGraph(): ExecutionGraph;
+    /**
+     * Finalizes the workflow definition and prepares it for execution
+     * This method should be called after all steps have been added to the workflow
+     * @returns A built workflow instance ready for execution
+     */
+    commit(): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TOutput>;
+    /**
+     * Creates a new workflow run instance
+     * @param options Optional configuration for the run
+     * @returns A Run instance that can be used to execute the workflow
+     */
+    createRun(options?: {
+        runId?: string;
+    }): Run<TSteps, TInput, TOutput>;
+    execute({ inputData, resumeData, suspend, resume, emitter, mastra, }: {
+        inputData: z.infer<TInput>;
+        resumeData?: any;
+        getStepResult<T extends NewStep<any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
+        suspend: (suspendPayload: any) => Promise<void>;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+            runId?: string;
+        };
+        emitter: EventEmitter;
+        mastra: Mastra;
+    }): Promise<z.infer<TOutput>>;
+    getWorkflowRuns(): Promise<WorkflowRuns>;
+}
+/**
+ * Represents a workflow run that can be executed
+ */
+declare class Run<TSteps extends NewStep<string, any, any>[] = NewStep<string, any, any>[], TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>> {
+    #private;
+    protected emitter: EventEmitter;
+    /**
+     * Unique identifier for this workflow
+     */
+    readonly workflowId: string;
+    /**
+     * Unique identifier for this run
+     */
+    readonly runId: string;
+    /**
+     * Internal state of the workflow run
+     */
+    protected state: Record<string, any>;
+    /**
+     * The execution engine for this run
+     */
+    executionEngine: ExecutionEngine;
+    /**
+     * The execution graph for this run
+     */
+    executionGraph: ExecutionGraph;
+    protected retryConfig?: {
+        attempts?: number;
+        delay?: number;
+    };
+    constructor(params: {
+        workflowId: string;
+        runId: string;
+        executionEngine: ExecutionEngine;
+        executionGraph: ExecutionGraph;
+        mastra?: Mastra;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+    });
+    /**
+     * Starts the workflow execution with the provided input
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    start({ inputData, container, }: {
+        inputData?: z.infer<TInput>;
+        container?: RuntimeContext;
+    }): Promise<WorkflowStatus<TOutput, TSteps>>;
+    watch(cb: (event: WatchEvent) => void): () => void;
+    resume<TResumeSchema extends z.ZodType<any>>(params: {
+        resumeData?: z.infer<TResumeSchema>;
+        step: NewStep<string, any, any, TResumeSchema, any> | [...NewStep<string, any, any, any, any>[], NewStep<string, any, any, TResumeSchema, any>] | string | string[];
+        container?: RuntimeContext;
+    }): Promise<WorkflowStatus<TOutput, TSteps>>;
+    /**
+     * Returns the current state of the workflow run
+     * @returns The current state of the workflow run
+     */
+    getState(): Record<string, any>;
+    updateState(state: Record<string, any>): void;
+}
+
 interface WorkflowOptions<TWorkflowName extends string = string, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> {
     steps?: TSteps;
     name: TWorkflowName;
@@ -541,6 +962,7 @@ interface WorkflowRunState {
         stepId: string;
         status: string;
     }>;
+    suspendedPaths: Record<string, number[]>;
     runId: string;
     timestamp: number;
     childStates?: Record<string, WorkflowRunState>;
@@ -562,9 +984,8 @@ declare class Step<TStepId extends string = any, TSchemaIn extends z.ZodSchema |
     mastra?: Mastra;
     constructor({ id, description, execute, payload, outputSchema, inputSchema, retryConfig, }: StepAction<TStepId, TSchemaIn, TSchemaOut, TContext>);
 }
-declare function createStep<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>>(opts: StepAction<TId, TSchemaIn, TSchemaOut, TContext>): Step<TId, TSchemaIn, TSchemaOut, TContext>;
 
-declare class Machine<TSteps extends Step<any, any, any, any>[] = Step<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends EventEmitter {
+declare class Machine<TSteps extends Step<any, any, any, any>[] = Step<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends EventEmitter$1 {
     #private;
     logger: Logger;
     name: string;
@@ -1321,7 +1742,7 @@ type MastraCustomLLMOptions<Z extends ZodSchema | JSONSchema7 | undefined = unde
     threadId?: string;
     resourceId?: string;
     runtimeContext: RuntimeContext;
-} & Run;
+} & Run$1;
 type LLMTextOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
     messages: CoreMessage[];
 } & MastraCustomLLMOptions<Z> & DefaultLLMTextOptions;
@@ -1679,13 +2100,14 @@ type ServerConfig = {
     };
 };
 
-interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>> {
+interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TNewWorkflows extends Record<string, NewWorkflow> = Record<string, NewWorkflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>> {
     agents?: TAgents;
     networks?: TNetworks;
     storage?: MastraStorage;
     vectors?: TVectors;
     logger?: TLogger | false;
     workflows?: TWorkflows;
+    vnext_workflows?: TNewWorkflows;
     tts?: TTTS;
     telemetry?: OtelConfig;
     deployer?: MastraDeployer;
@@ -1701,7 +2123,7 @@ interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Age
     }>;
     memory?: MastraMemory;
 }
-declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>> {
+declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TNewWorkflows extends Record<string, NewWorkflow> = Record<string, NewWorkflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>> {
     #private;
     /**
      * @deprecated use getTelemetry() instead
@@ -1715,7 +2137,7 @@ declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string,
      * @deprecated use getMemory() instead
      */
     get memory(): MastraMemory | undefined;
-    constructor(config?: Config<TAgents, TWorkflows, TVectors, TTTS, TLogger>);
+    constructor(config?: Config<TAgents, TWorkflows, TNewWorkflows, TVectors, TTTS, TLogger>);
     getAgent<TAgentName extends keyof TAgents>(name: TAgentName): TAgents[TAgentName];
     getAgents(): TAgents;
     getVector<TVectorName extends keyof TVectors>(name: TVectorName): TVectors[TVectorName];
@@ -1724,6 +2146,9 @@ declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string,
     getWorkflow<TWorkflowId extends keyof TWorkflows>(id: TWorkflowId, { serialized }?: {
         serialized?: boolean;
     }): TWorkflows[TWorkflowId];
+    vnext_getWorkflow<TWorkflowId extends keyof TNewWorkflows>(id: TWorkflowId, { serialized }?: {
+        serialized?: boolean;
+    }): TNewWorkflows[TWorkflowId];
     getWorkflows(props?: {
         serialized?: boolean;
     }): Record<string, Workflow>;
@@ -1804,6 +2229,7 @@ declare class MastraLLMBase extends MastraBase {
 
 declare class Agent<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> extends MastraBase {
     #private;
+    id: TAgentId;
     name: TAgentId;
     readonly llm: MastraLLMBase;
     instructions: string;
@@ -2156,4 +2582,4 @@ declare abstract class MastraStorage extends MastraBase {
     }): Promise<WorkflowRuns>;
 }
 
-export { type MemoryConfig as $, type ApiRoute as A, type BaseStructuredOutputType as B, CompositeVoice as C, type StructuredOutputType as D, type EvalRow as E, type StructuredOutputArrayItem as F, type StructuredOutput as G, type GenerateReturn as H, type StreamReturn as I, type DefaultLLMTextOptions as J, type DefaultLLMTextObjectOptions as K, type LanguageModel as L, type Methods as M, type DefaultLLMStreamOptions as N, type OutputType as O, type DefaultLLMStreamObjectOptions as P, type LLMTextOptions as Q, type LLMTextObjectOptions as R, type StorageColumn as S, type TABLE_NAMES as T, type LLMStreamOptions as U, type VoiceEventType as V, type WorkflowRunState as W, type LLMInnerStreamOptions as X, type LLMStreamObjectOptions as Y, type Config as Z, type MessageResponse as _, Mastra as a, type SharedMemoryConfig as a0, type MemoryProcessorOpts as a1, MemoryProcessor as a2, createTool as a3, type VercelTool as a4, type CoreTool as a5, type StepExecutionContext as a6, type StepAction as a7, type StepVariableType as a8, type StepNode as a9, type ExtractStepResult as aA, type StepInputType as aB, type ExtractSchemaType as aC, type PathsToStringProps as aD, type WorkflowResumeResult as aE, createStep as aF, type MastraLanguageModel as aG, type ToolsInput as aH, type MastraPrimitives as aI, AgentNetwork as aJ, type AgentNetworkConfig as aK, type ToolsetsInput as aL, type AgentGenerateOptions as aM, type AgentStreamOptions as aN, TABLE_WORKFLOW_SNAPSHOT as aO, TABLE_EVALS as aP, TABLE_MESSAGES as aQ, TABLE_THREADS as aR, TABLE_TRACES as aS, TABLE_SCHEMAS as aT, type StepGraph as aa, type RetryConfig as ab, type VariableReference as ac, type BaseCondition as ad, type ActionContext as ae, WhenConditionReturnValue as af, type StepDef as ag, type StepCondition as ah, type StepConfig as ai, type StepResult as aj, type StepsRecord as ak, type WorkflowRunResult as al, type WorkflowContext as am, type WorkflowLogMessage as an, type WorkflowEvent as ao, type ResolverFunctionInput as ap, type ResolverFunctionOutput as aq, type SubscriberFunctionOutput as ar, type DependencyCheckOutput as as, type StepResolverOutput as at, type WorkflowActors as au, type WorkflowActionParams as av, type WorkflowActions as aw, type WorkflowState as ax, type StepId as ay, type ExtractSchemaFromStep as az, MastraVoice as b, type VoiceEventMap as c, type VoiceConfig as d, MastraStorage as e, type StorageThreadType as f, type MessageType as g, type StorageGetMessagesArg as h, type ToolAction as i, Agent as j, type AgentConfig as k, MastraMemory as l, type ToolExecutionContext as m, Tool as n, Step as o, Workflow as p, type WorkflowOptions as q, type WorkflowRow as r, type WorkflowRuns as s, type CoreMessage as t, type CoreSystemMessage as u, type CoreAssistantMessage as v, type CoreUserMessage as w, type CoreToolMessage as x, type EmbedResult as y, type EmbedManyResult as z };
+export { type CoreAssistantMessage as $, type ApiRoute as A, type WatchEvent as B, CompositeVoice as C, type ToolAction as D, type EvalRow as E, Agent as F, type AgentConfig as G, MastraMemory as H, type ToolExecutionContext as I, Tool as J, Step as K, Workflow as L, type Methods as M, type NewStep as N, type WorkflowOptions as O, type PathsToStringProps$1 as P, type WorkflowRow as Q, Run as R, type StorageColumn as S, type TABLE_NAMES as T, type WorkflowRuns as U, type VoiceEventType as V, type WorkflowRunState as W, type LanguageModel as X, type CoreMessage as Y, type ZodPathType as Z, type CoreSystemMessage as _, Mastra as a, type WorkflowResumeResult as a$, type CoreUserMessage as a0, type CoreToolMessage as a1, type EmbedResult as a2, type EmbedManyResult as a3, type BaseStructuredOutputType as a4, type StructuredOutputType as a5, type StructuredOutputArrayItem as a6, type StructuredOutput as a7, type GenerateReturn as a8, type StreamReturn as a9, type BaseCondition as aA, type ActionContext as aB, WhenConditionReturnValue as aC, type StepDef as aD, type StepCondition as aE, type StepConfig as aF, type StepResult as aG, type StepsRecord as aH, type WorkflowRunResult as aI, type WorkflowContext as aJ, type WorkflowLogMessage as aK, type WorkflowEvent as aL, type ResolverFunctionInput as aM, type ResolverFunctionOutput as aN, type SubscriberFunctionOutput as aO, type DependencyCheckOutput as aP, type StepResolverOutput as aQ, type WorkflowActors as aR, type WorkflowActionParams as aS, type WorkflowActions as aT, type WorkflowState as aU, type StepId as aV, type ExtractSchemaFromStep as aW, type ExtractStepResult as aX, type StepInputType as aY, type ExtractSchemaType as aZ, type PathsToStringProps as a_, type OutputType as aa, type DefaultLLMTextOptions as ab, type DefaultLLMTextObjectOptions as ac, type DefaultLLMStreamOptions as ad, type DefaultLLMStreamObjectOptions as ae, type LLMTextOptions as af, type LLMTextObjectOptions as ag, type LLMStreamOptions as ah, type LLMInnerStreamOptions as ai, type LLMStreamObjectOptions as aj, type Config as ak, type MessageResponse as al, type MemoryConfig as am, type SharedMemoryConfig as an, type MemoryProcessorOpts as ao, MemoryProcessor as ap, createTool as aq, type VercelTool as ar, type CoreTool as as, type StepExecutionContext as at, type StepAction as au, type StepVariableType as av, type StepNode as aw, type StepGraph as ax, type RetryConfig as ay, type VariableReference as az, MastraVoice as b, type MastraLanguageModel as b0, type ToolsInput as b1, type MastraPrimitives as b2, AgentNetwork as b3, type AgentNetworkConfig as b4, type ToolsetsInput as b5, type AgentGenerateOptions as b6, type AgentStreamOptions as b7, TABLE_WORKFLOW_SNAPSHOT as b8, TABLE_EVALS as b9, TABLE_MESSAGES as ba, TABLE_THREADS as bb, TABLE_TRACES as bc, TABLE_SCHEMAS as bd, type VoiceEventMap as c, type VoiceConfig as d, MastraStorage as e, type StorageThreadType as f, type MessageType as g, type StorageGetMessagesArg as h, ExecutionEngine as i, type ExecutionGraph as j, type StepResult$1 as k, type StepFlowEntry as l, type ExecuteFunction as m, createStep as n, cloneStep as o, createWorkflow as p, type WorkflowStatus as q, type NewWorkflowConfig as r, NewWorkflow as s, type StepSuccess$1 as t, type StepFailure$1 as u, type StepSuspended$1 as v, type StepsRecord$1 as w, type ExtractSchemaType$1 as x, type ExtractSchemaFromStep$1 as y, type VariableReference$1 as z };