@mastra/core 0.9.0 → 0.9.1-alpha.1

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

@@ -1,22 +1,24 @@
 import * as ai from 'ai';
-import { Tool as Tool$1, ToolExecutionOptions, LanguageModelV1, CoreMessage as CoreMessage$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, EmbeddingModel, Message, UserContent, AssistantContent, TelemetrySettings, generateText, generateObject, streamText, streamObject, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback, LanguageModel as LanguageModel$1, DeepPartial, ToolContent } from 'ai';
+import { Tool as Tool$1, ToolExecutionOptions, LanguageModelV1, CoreMessage as CoreMessage$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, EmbeddingModel, Message, UserContent, AssistantContent, LanguageModel as LanguageModel$1, DeepPartial, TelemetrySettings, generateText, generateObject, streamText, streamObject, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback, ToolContent } from 'ai';
 import { M as MastraBase, T as Telemetry, O as OtelConfig } from './base-DT2poiVK.js';
 import { a as Metric, M as MetricResult, T as TestInfo } from './types-BtMyV38I.js';
 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 { RuntimeContext } from './runtime-context/index.js';
 import { Span } from '@opentelemetry/api';
 import * as xstate from 'xstate';
 import { Snapshot } from 'xstate';
 import EventEmitter from 'node:events';
 import { MastraVector } from './vector/index.js';
 import { MastraTTS } from './tts/index.js';
+import EventEmitter$1 from 'events';
 import { MastraDeployer } from './deployer/index.js';
 import { Handler, MiddlewareHandler } from 'hono';
 import { cors } from 'hono/cors';
 import { DescribeRouteOptions } from 'hono-openapi';
+import { MockLanguageModelV1 } from 'ai/test';
 
 type VercelTool = Tool$1;
 type CoreTool = {
@@ -51,7 +53,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;
@@ -222,12 +230,12 @@ type RetryConfig = {
     attempts?: number;
     delay?: number;
 };
-type VariableReference<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = TStep extends StepAction<any, any, any, any> ? {
+type VariableReference$1<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = TStep extends StepAction<any, any, any, any> ? {
     step: TStep;
-    path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.';
+    path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.';
 } : TStep extends 'trigger' ? {
     step: 'trigger';
-    path: PathsToStringProps<ExtractSchemaType<TTriggerSchema>> | '.' | '';
+    path: PathsToStringProps$1<ExtractSchemaType$1<TTriggerSchema>> | '.' | '';
 } : {
     step: {
         id: string;
@@ -237,10 +245,10 @@ type VariableReference<TStep extends StepVariableType<any, any, any, any>, TTrig
 interface BaseCondition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> {
     ref: TStep extends StepAction<any, any, any, any> ? {
         step: TStep;
-        path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.' | 'status';
+        path: PathsToStringProps$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.' | 'status';
     } : TStep extends 'trigger' ? {
         step: 'trigger';
-        path: PathsToStringProps<ExtractSchemaType<TTriggerSchema>> | '.' | '';
+        path: PathsToStringProps$1<ExtractSchemaType$1<TTriggerSchema>> | '.' | '';
     } : {
         step: {
             id: string;
@@ -287,8 +295,8 @@ interface StepConfig<TStep extends StepAction<any, any, any, any>, CondStep exte
         context: WorkflowContext<TTriggerSchema, TSteps>;
         mastra?: Mastra;
     }) => Promise<boolean | WhenConditionReturnValue>);
-    variables?: StepInputType<TStep, 'inputSchema'> extends never ? Record<string, VariableReference<VarStep, TTriggerSchema>> : {
-        [K in keyof StepInputType<TStep, 'inputSchema'>]?: VariableReference<VarStep, TTriggerSchema>;
+    variables?: StepInputType<TStep, 'inputSchema'> extends never ? Record<string, VariableReference$1<VarStep, TTriggerSchema>> : {
+        [K in keyof StepInputType<TStep, 'inputSchema'>]?: VariableReference$1<VarStep, TTriggerSchema>;
     };
     '#internal'?: {
         when?: Condition<CondStep, TTriggerSchema> | ((args: {
@@ -300,11 +308,11 @@ interface StepConfig<TStep extends StepAction<any, any, any, any>, CondStep exte
     };
     id?: string;
 }
-type StepSuccess<T> = {
+type StepSuccess$1<T> = {
     status: 'success';
     output: T;
 };
-type StepSuspended<T> = {
+type StepSuspended$1<T> = {
     status: 'suspended';
     suspendPayload?: any;
     output?: T;
@@ -312,15 +320,15 @@ type StepSuspended<T> = {
 type StepWaiting = {
     status: 'waiting';
 };
-type StepFailure = {
+type StepFailure$1 = {
     status: 'failed';
     error: string;
 };
 type StepSkipped = {
     status: 'skipped';
 };
-type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended<T> | StepWaiting | StepSkipped;
-type StepsRecord<T extends readonly Step<any, any, z.ZodType<any> | undefined>[]> = {
+type StepResult$1<T> = StepSuccess$1<T> | StepFailure$1 | StepSuspended$1<T> | StepWaiting | StepSkipped;
+type StepsRecord$1<T extends readonly Step<any, any, z.ZodType<any> | undefined>[]> = {
     [K in T[number]['id']]: Extract<T[number], {
         id: K;
     }>;
@@ -329,11 +337,11 @@ interface WorkflowRunResult<T extends z.ZodObject<any>, TSteps extends Step<stri
     triggerData?: z.infer<T>;
     result?: z.infer<TResult>;
     results: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+        [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']>>>;
     };
     runId: string;
     timestamp: number;
-    activePaths: Map<keyof StepsRecord<TSteps>, {
+    activePaths: Map<keyof StepsRecord$1<TSteps>, {
         status: string;
         suspendPayload?: any;
         stepPath: string[];
@@ -346,13 +354,13 @@ interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extend
     };
     mastra?: MastraUnion;
     steps: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+        [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']>>>;
     };
     triggerData: z.infer<TTrigger>;
     inputData: TInputData;
     attempts: Record<string, number>;
     getStepResult(stepId: 'trigger'): z.infer<TTrigger>;
-    getStepResult<T extends keyof StepsRecord<TSteps> | unknown>(stepId: T extends keyof StepsRecord<TSteps> ? T : string): T extends keyof StepsRecord<TSteps> ? StepsRecord<TSteps>[T]['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<StepsRecord<TSteps>[T]['outputSchema']>> : T;
+    getStepResult<T extends keyof StepsRecord$1<TSteps> | unknown>(stepId: T extends keyof StepsRecord$1<TSteps> ? T : string): T extends keyof StepsRecord$1<TSteps> ? StepsRecord$1<TSteps>[T]['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<StepsRecord$1<TSteps>[T]['outputSchema']>> : T;
     getStepResult<T extends Step<any, any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
 }
 interface WorkflowLogMessage extends BaseLogMessage {
@@ -518,12 +526,12 @@ declare const StepIdBrand: unique symbol;
 type StepId = string & {
     readonly [StepIdBrand]: typeof StepIdBrand;
 };
-type ExtractSchemaFromStep<TStep extends StepAction<any, any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
+type ExtractSchemaFromStep$1<TStep extends StepAction<any, any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
 type ExtractStepResult<T> = T extends (data: any) => Promise<infer R> ? R : never;
-type StepInputType<TStep extends StepAction<any, any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = ExtractSchemaFromStep<TStep, TKey> extends infer Schema ? Schema extends z.ZodType<any> ? z.infer<Schema> : never : never;
-type ExtractSchemaType<T extends z.ZodSchema> = T extends z.ZodSchema<infer V> ? V : never;
-type PathsToStringProps<T> = T extends object ? {
-    [K in keyof T]: T[K] extends object ? K extends string ? K | `${K}.${PathsToStringProps<T[K]>}` : never : K extends string ? K : never;
+type StepInputType<TStep extends StepAction<any, any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = ExtractSchemaFromStep$1<TStep, TKey> extends infer Schema ? Schema extends z.ZodType<any> ? z.infer<Schema> : never : never;
+type ExtractSchemaType$1<T extends z.ZodSchema> = T extends z.ZodSchema<infer V> ? V : never;
+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;
 interface WorkflowRunState {
     value: Record<string, string>;
@@ -541,6 +549,7 @@ interface WorkflowRunState {
         stepId: string;
         status: string;
     }>;
+    suspendedPaths: Record<string, number[]>;
     runId: string;
     timestamp: number;
     childStates?: Record<string, WorkflowRunState>;
@@ -548,7 +557,7 @@ interface WorkflowRunState {
 }
 type WorkflowResumeResult<TTriggerSchema extends z.ZodObject<any>> = {
     triggerData?: z.infer<TTriggerSchema>;
-    results: Record<string, StepResult<any>>;
+    results: Record<string, StepResult$1<any>>;
 };
 
 declare class Step<TStepId extends string = any, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends StepExecutionContext<TSchemaIn> = StepExecutionContext<TSchemaIn>> implements StepAction<TStepId, TSchemaIn, TSchemaOut, TContext> {
@@ -562,7 +571,6 @@ 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 {
     #private;
@@ -991,7 +999,7 @@ declare class WorkflowInstance<TSteps extends Step<any, any, any, any>[] = Step<
         timestamp: number;
         result?: z.TypeOf<TResult> | undefined;
         triggerData?: z.TypeOf<TTriggerSchema> | undefined;
-        results: { [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]["outputSchema"] extends undefined ? StepResult<unknown> : StepResult<z.TypeOf<NonNullable<StepsRecord<TSteps>[K]["outputSchema"]>>>; };
+        results: { [K in keyof StepsRecord$1<TSteps>]: StepsRecord$1<TSteps>[K]["outputSchema"] extends undefined ? StepResult$1<unknown> : StepResult$1<z.TypeOf<NonNullable<StepsRecord$1<TSteps>[K]["outputSchema"]>>>; };
         activePaths: Map<TSteps[number]["id"], {
             status: string;
             suspendPayload?: any;
@@ -1111,6 +1119,439 @@ declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, an
     toStep(): Step<TStepId, TTriggerSchema, z.ZodType<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
 }
 
+type ExecuteFunction<TStepInput, TStepOutput, TResumeSchema, TSuspendSchema> = (params: {
+    mastra: Mastra;
+    runtimeContext: 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$1;
+}) => 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<T> = {
+    status: 'success';
+    output: T;
+};
+type StepFailure = {
+    status: 'failed';
+    error: string;
+};
+type StepSuspended<T> = {
+    status: 'suspended';
+    payload: T;
+};
+type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended<T>;
+type StepsRecord<T extends readonly NewStep<any, any, any>[]> = {
+    [K in T[number]['id']]: Extract<T[number], {
+        id: K;
+    }>;
+};
+type PathsToStringProps<T> = T extends object ? {
+    [K in keyof T]: T[K] extends object ? K extends string ? K | `${K}.${PathsToStringProps<T[K]>}` : never : K extends string ? K : never;
+}[keyof T] : never;
+type ExtractSchemaType<T extends z.ZodType<any>> = T extends z.ZodObject<infer V> ? V : never;
+type ExtractSchemaFromStep<TStep extends NewStep<any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
+type VariableReference<TStep extends NewStep<string, any, any> = NewStep<string, any, any>, TVarPath extends PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.' = PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.'> = {
+    step: TStep;
+    path: TVarPath;
+} | {
+    value: any;
+    schema: z.ZodTypeAny;
+};
+type WatchEvent = {
+    type: 'watch';
+    payload: {
+        currentStep: {
+            id: string;
+            status: 'running' | 'success' | 'failed' | 'suspended';
+            output?: Record<string, any>;
+            payload?: Record<string, any>;
+        };
+        workflowState: {
+            status: 'running' | 'success' | 'failed' | 'suspended';
+            steps: Record<string, {
+                status: 'running' | 'success' | '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<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: EventEmitter$1;
+        runtimeContext: 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>[];
+    serializedConditions: {
+        id: string;
+        fn: string;
+    }[];
+} | {
+    type: 'loop';
+    step: NewStep;
+    condition: ExecuteFunction<any, any, any, any>;
+    serializedCondition: {
+        id: string;
+        fn: string;
+    };
+    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 WorkflowResult<TOutput extends z.ZodType<any>, TSteps extends NewStep<string, any, any>[]> = {
+    status: 'success';
+    result: z.infer<TOutput>;
+    steps: {
+        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+    };
+} | {
+    status: 'failed';
+    steps: {
+        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+    };
+    error: Error;
+} | {
+    status: 'suspended';
+    steps: {
+        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<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;
+    steps: Record<string, NewStep<string, any, any>>;
+    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<ExtractSchemaType<ExtractSchemaFromStep<TSteps[number], 'outputSchema'>>> | '.';
+        } | {
+            value: any;
+            schema: z.ZodTypeAny;
+        } | {
+            initData: TSteps[number];
+            path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TSteps[number], 'inputSchema'>>> | '.';
+        } | {
+            runtimeContextPath: 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<ExtractSchemaType<ExtractSchemaFromStep<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<ExtractSchemaType<ExtractSchemaFromStep<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 {
+        runtimeContextPath: 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<ExtractSchemaType<ExtractSchemaFromStep<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<ExtractSchemaType<ExtractSchemaFromStep<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 {
+        runtimeContextPath: 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<ExtractSchemaType<ExtractSchemaFromStep<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<ExtractSchemaType<ExtractSchemaFromStep<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 {
+        runtimeContextPath: 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<ExtractSchemaType<ExtractSchemaFromStep<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<ExtractSchemaType<ExtractSchemaFromStep<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 {
+        runtimeContextPath: 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<ExtractSchemaType<ExtractSchemaFromStep<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<ExtractSchemaType<ExtractSchemaFromStep<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 {
+        runtimeContextPath: 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<TParallelSteps>]: StepsRecord<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<{ [K_1 in keyof TBranchSteps]: TBranchSteps[K_1][1]; }[number][]>]: StepsRecord<{ [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>;
+    get stepGraph(): StepFlowEntry[];
+    /**
+     * 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$1;
+        mastra: Mastra;
+    }): Promise<z.infer<TOutput>>;
+    getWorkflowRuns(): Promise<WorkflowRuns>;
+    getWorkflowRun(runId: string): Promise<{
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState | string;
+        createdAt: Date;
+        updatedAt: Date;
+    } | Run<TSteps, TInput, TOutput> | undefined>;
+}
+/**
+ * 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$1;
+    /**
+     * 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 cleanup?: () => void;
+    protected retryConfig?: {
+        attempts?: number;
+        delay?: number;
+    };
+    constructor(params: {
+        workflowId: string;
+        runId: string;
+        executionEngine: ExecutionEngine;
+        executionGraph: ExecutionGraph;
+        mastra?: Mastra;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        cleanup?: () => void;
+    });
+    /**
+     * 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, runtimeContext, }: {
+        inputData?: z.infer<TInput>;
+        runtimeContext?: RuntimeContext;
+    }): Promise<WorkflowResult<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[];
+        runtimeContext?: RuntimeContext;
+    }): Promise<WorkflowResult<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;
+}
+
 type MemoryProcessorOpts = {
     systemMessage?: string;
     memorySystemMessage?: string;
@@ -1128,6 +1569,19 @@ declare abstract class MemoryProcessor extends MastraBase {
      */
     process(messages: CoreMessage$1[], _opts: MemoryProcessorOpts): CoreMessage$1[];
 }
+declare const memoryDefaultOptions: {
+    lastMessages: number;
+    semanticRecall: {
+        topK: number;
+        messageRange: {
+            before: number;
+            after: number;
+        };
+    };
+    threads: {
+        generateTitle: true;
+    };
+};
 /**
  * Abstract Memory class that defines the interface for storing and retrieving
  * conversation threads and messages.
@@ -1138,10 +1592,12 @@ declare abstract class MastraMemory extends MastraBase {
     vector?: MastraVector;
     embedder?: EmbeddingModel<string>;
     private processors;
+    private deprecationWarnings;
     protected threadConfig: MemoryConfig;
     constructor(config: {
         name: string;
     } & SharedMemoryConfig);
+    private addImplicitDefaultsWarning;
     setStorage(storage: MastraStorage): void;
     setVector(vector: MastraVector): void;
     setEmbedder(embedder: EmbeddingModel<string>): void;
@@ -1273,6 +1729,33 @@ declare abstract class MastraMemory extends MastraBase {
     generateId(): string;
 }
 
+declare class MastraLLMBase extends MastraBase {
+    #private;
+    constructor({ name, model }: {
+        name: string;
+        model: LanguageModel$1;
+    });
+    getProvider(): string;
+    getModelId(): string;
+    getModel(): ai.LanguageModelV1;
+    convertToMessages(messages: string | string[] | CoreMessage$1[]): CoreMessage$1[];
+    __registerPrimitives(p: MastraPrimitives): void;
+    __registerMastra(p: Mastra): void;
+    __text<Z extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextOptions<Z>): Promise<GenerateTextResult<any, any>>;
+    __textObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<GenerateReturn<Z>>;
+    __stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(input: LLMInnerStreamOptions<Z>): Promise<StreamTextResult<any, any>>;
+    __streamObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMStreamObjectOptions<T>): Promise<StreamObjectResult<DeepPartial<T>, T, never>>;
+    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<StreamReturn<Z>>;
+}
+
+declare function createMockModel({ objectGenerationMode, mockText, spyGenerate, spyStream, }: {
+    objectGenerationMode?: 'json';
+    mockText: string | Record<string, any>;
+    spyGenerate?: (props: any) => void;
+    spyStream?: (props: any) => void;
+}): MockLanguageModelV1;
+
 type LanguageModel = MastraLanguageModel;
 type CoreMessage = CoreMessage$1;
 type CoreSystemMessage = CoreSystemMessage$1;
@@ -1321,7 +1804,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 +2162,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 +2185,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 +2199,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,9 +2208,15 @@ 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>;
+    vnext_getWorkflows(props?: {
+        serialized?: boolean;
+    }): Record<string, NewWorkflow>;
     setStorage(storage: MastraStorage): void;
     setLogger({ logger }: {
         logger: TLogger;
@@ -1782,28 +2272,9 @@ interface IAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined,
     execute?: (context: TContext, options?: TOptions) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
 }
 
-declare class MastraLLMBase extends MastraBase {
-    #private;
-    constructor({ name, model }: {
-        name: string;
-        model: LanguageModel$1;
-    });
-    getProvider(): string;
-    getModelId(): string;
-    getModel(): ai.LanguageModelV1;
-    convertToMessages(messages: string | string[] | CoreMessage$1[]): CoreMessage$1[];
-    __registerPrimitives(p: MastraPrimitives): void;
-    __registerMastra(p: Mastra): void;
-    __text<Z extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextOptions<Z>): Promise<GenerateTextResult<any, any>>;
-    __textObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextObjectOptions<T>): Promise<GenerateObjectResult<T>>;
-    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<GenerateReturn<Z>>;
-    __stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(input: LLMInnerStreamOptions<Z>): Promise<StreamTextResult<any, any>>;
-    __streamObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMStreamObjectOptions<T>): Promise<StreamObjectResult<DeepPartial<T>, T, never>>;
-    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<StreamReturn<Z>>;
-}
-
 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 +2627,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 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 ExtractSchemaType$1 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 RetryConfig as aA, type VariableReference$1 as aB, type BaseCondition as aC, type ActionContext as aD, WhenConditionReturnValue as aE, type StepDef as aF, type StepCondition as aG, type StepConfig as aH, type StepResult$1 as aI, type StepsRecord$1 as aJ, type WorkflowRunResult as aK, type WorkflowContext as aL, type WorkflowLogMessage as aM, type WorkflowEvent as aN, type ResolverFunctionInput as aO, type ResolverFunctionOutput as aP, type SubscriberFunctionOutput as aQ, type DependencyCheckOutput as aR, type StepResolverOutput as aS, type WorkflowActors as aT, type WorkflowActionParams as aU, type WorkflowActions as aV, type WorkflowState as aW, type StepId as aX, type ExtractSchemaFromStep$1 as aY, type ExtractStepResult as aZ, type StepInputType 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, createMockModel as ak, type Config as al, type MessageResponse as am, type MemoryConfig as an, type SharedMemoryConfig as ao, type MemoryProcessorOpts as ap, MemoryProcessor as aq, memoryDefaultOptions as ar, createTool as as, type VercelTool as at, type CoreTool as au, type StepExecutionContext as av, type StepAction as aw, type StepVariableType as ax, type StepNode as ay, type StepGraph as az, MastraVoice as b, type PathsToStringProps$1 as b0, type WorkflowResumeResult as b1, type MastraLanguageModel as b2, type ToolsInput as b3, type MastraPrimitives as b4, AgentNetwork as b5, type AgentNetworkConfig as b6, type ToolsetsInput as b7, type AgentGenerateOptions as b8, type AgentStreamOptions as b9, TABLE_WORKFLOW_SNAPSHOT as ba, TABLE_EVALS as bb, TABLE_MESSAGES as bc, TABLE_THREADS as bd, TABLE_TRACES as be, TABLE_SCHEMAS as bf, 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 as k, type StepFlowEntry as l, type ExecuteFunction as m, createStep as n, cloneStep as o, createWorkflow as p, type WorkflowResult as q, type NewWorkflowConfig as r, NewWorkflow as s, type StepSuccess as t, type StepFailure as u, type StepSuspended as v, type StepsRecord as w, type ExtractSchemaType as x, type ExtractSchemaFromStep as y, type VariableReference as z };