@mastra/core 0.10.1 → 0.10.2-alpha.0

package/dist/{base-QP4OC4dB.d.ts → base-CAqn5W09.d.ts}

@@ -1,26 +1,26 @@
 import * as ai from 'ai';
-import { Tool as Tool$1, Schema, ToolExecutionOptions, EmbeddingModel, CoreMessage as CoreMessage$1, Message, UserContent, AssistantContent, LanguageModel as LanguageModel$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, DeepPartial, generateText, generateObject, streamText, streamObject, TelemetrySettings, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, LanguageModelV1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback, ToolContent } from 'ai';
+import { Tool as Tool$1, Schema, ToolExecutionOptions, UserContent, AssistantContent, ToolContent, EmbeddingModel, CoreMessage as CoreMessage$1, UIMessage, IDGenerator as IDGenerator$1, Message, CoreSystemMessage as CoreSystemMessage$1, LanguageModel as LanguageModel$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, DeepPartial, generateText, generateObject, streamText, streamObject, TelemetrySettings, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, LanguageModelV1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback } from 'ai';
 import { M as MastraBase, T as Telemetry, O as OtelConfig } from './base-tc5kgDTD.js';
-import { M as Metric, a as MetricResult, T as TestInfo } from './types-Bo1uigWx.js';
-import { Query } from 'sift';
 import { z, ZodSchema } from 'zod';
 import { JSONSchema7Type, JSONSchema7 } from 'json-schema';
-import { MastraDeployer } from './deployer/index.js';
 import { B as BaseLogMessage, R as RegisteredLogger, I as IMastraLogger } from './logger-EhZkzZOr.js';
-import * as http from 'node:http';
-import { Context, Handler, MiddlewareHandler, HonoRequest } from 'hono';
-import { RuntimeContext } from './runtime-context/index.js';
 import { MastraTTS } from './tts/index.js';
 import { MastraVector } from './vector/index.js';
+import { M as Metric, a as MetricResult, T as TestInfo } from './types-Bo1uigWx.js';
+import { Query } from 'sift';
+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 * as http from 'node:http';
+import { Context, Handler, MiddlewareHandler, HonoRequest } from 'hono';
 import EventEmitter$1 from 'events';
 import { EMITTER_SYMBOL } from './workflows/constants.js';
+import { MockLanguageModelV1 } from 'ai/test';
+import { MastraDeployer } from './deployer/index.js';
 import { cors } from 'hono/cors';
 import { DescribeRouteOptions } from 'hono-openapi';
-import { MockLanguageModelV1 } from 'ai/test';
 
 type BundlerConfig = {
     externals?: string[];
@@ -86,645 +86,174 @@ type Run$1 = {
     runStatus?: RunStatus;
 };
 
-type MemoryProcessorOpts = {
-    systemMessage?: string;
-    memorySystemMessage?: string;
-    newMessages?: CoreMessage$1[];
+interface WorkflowOptions<TWorkflowName extends string = string, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> {
+    steps?: TSteps;
+    name: TWorkflowName;
+    triggerSchema?: TTriggerSchema;
+    result?: {
+        schema: TResultSchema;
+        mapping?: {
+            [K in keyof z.infer<TResultSchema>]?: any;
+        };
+    };
+    events?: Record<string, {
+        schema: z.ZodObject<any>;
+    }>;
+    retryConfig?: RetryConfig;
+    mastra?: Mastra;
+}
+interface StepExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined, TContext extends WorkflowContext = WorkflowContext> extends IExecutionContext<TSchemaIn> {
+    context: TSchemaIn extends z.ZodSchema ? {
+        inputData: z.infer<TSchemaIn>;
+    } & TContext : TContext;
+    suspend: (payload?: unknown, softSuspend?: any) => Promise<void>;
+    runId: string;
+    emit: (event: string, data: any) => void;
+    mastra?: MastraUnion;
+    runtimeContext: RuntimeContext;
+}
+interface StepAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>> extends IAction<TId, TSchemaIn, TSchemaOut, TContext> {
+    mastra?: Mastra;
+    payload?: TSchemaIn extends z.ZodSchema ? Partial<z.infer<TSchemaIn>> : unknown;
+    execute: (context: TContext) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
+    retryConfig?: RetryConfig;
+    workflow?: LegacyWorkflow;
+    workflowId?: string;
+}
+interface SimpleConditionalType {
+    [key: `${string}.${string}`]: string | Query<any>;
+}
+type StepVariableType<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>> = StepAction<TId, TSchemaIn, TSchemaOut, TContext> | 'trigger' | {
+    id: string;
 };
-/**
- * Interface for message processors that can filter or transform messages
- * before they're sent to the LLM.
- */
-declare abstract class MemoryProcessor extends MastraBase {
-    /**
-     * Process a list of messages and return a filtered or transformed list.
-     * @param messages The messages to process
-     * @returns The processed messages
-     */
-    process(messages: CoreMessage$1[], _opts: MemoryProcessorOpts): CoreMessage$1[];
+type StepNode = {
+    id: string;
+    step: StepAction<any, any, any, any>;
+    config: StepDef<any, any, any, any>[any];
+};
+type StepGraph = {
+    initial: StepNode[];
+    [key: string]: StepNode[];
+};
+type RetryConfig = {
+    attempts?: number;
+    delay?: number;
+};
+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$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.';
+} : TStep extends 'trigger' ? {
+    step: 'trigger';
+    path: PathsToStringProps$1<ExtractSchemaType$1<TTriggerSchema>> | '.' | '';
+} : {
+    step: {
+        id: string;
+    };
+    path: string;
+};
+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$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.' | 'status';
+    } : TStep extends 'trigger' ? {
+        step: 'trigger';
+        path: PathsToStringProps$1<ExtractSchemaType$1<TTriggerSchema>> | '.' | '';
+    } : {
+        step: {
+            id: string;
+        };
+        path: string;
+    };
+    query: Query<any>;
 }
-declare const memoryDefaultOptions: {
-    lastMessages: number;
-    semanticRecall: false;
-    threads: {
-        generateTitle: false;
+type ActionContext<TSchemaIn extends z.ZodType<any>> = StepExecutionContext<z.infer<TSchemaIn>, WorkflowContext>;
+declare enum WhenConditionReturnValue {
+    CONTINUE = "continue",
+    CONTINUE_FAILED = "continue_failed",
+    ABORT = "abort",
+    LIMBO = "limbo"
+}
+type StepDef<TStepId extends TSteps[number]['id'], TSteps extends StepAction<any, any, any, any>[], TSchemaIn extends z.ZodType<any>, TSchemaOut extends z.ZodType<any>> = Record<TStepId, {
+    id?: string;
+    when?: Condition<any, any> | ((args: {
+        context: WorkflowContext;
+        mastra?: Mastra;
+    }) => Promise<boolean | WhenConditionReturnValue>);
+    serializedWhen?: Condition<any, any> | string;
+    loopLabel?: string;
+    loopType?: 'while' | 'until';
+    data: TSchemaIn;
+    handler: (args: ActionContext<TSchemaIn>) => Promise<z.infer<TSchemaOut>>;
+}>;
+type StepCondition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = BaseCondition<TStep, TTriggerSchema> | SimpleConditionalType | {
+    and: StepCondition<TStep, TTriggerSchema>[];
+} | {
+    or: StepCondition<TStep, TTriggerSchema>[];
+} | {
+    not: StepCondition<TStep, TTriggerSchema>;
+};
+type Condition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = BaseCondition<TStep, TTriggerSchema> | SimpleConditionalType | {
+    and: Condition<TStep, TTriggerSchema>[];
+} | {
+    or: Condition<TStep, TTriggerSchema>[];
+} | {
+    not: Condition<TStep, TTriggerSchema>;
+};
+interface StepConfig<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[]> {
+    when?: Condition<CondStep, TTriggerSchema> | ((args: {
+        context: WorkflowContext<TTriggerSchema, TSteps>;
+        mastra?: Mastra;
+    }) => Promise<boolean | WhenConditionReturnValue>);
+    variables?: StepInputType<TStep, 'inputSchema'> extends never ? Record<string, VariableReference$1<VarStep, TTriggerSchema>> : {
+        [K in keyof StepInputType<TStep, 'inputSchema'>]?: VariableReference$1<VarStep, TTriggerSchema>;
     };
-    workingMemory: {
-        enabled: false;
-        template: string;
+    '#internal'?: {
+        when?: Condition<CondStep, TTriggerSchema> | ((args: {
+            context: WorkflowContext<TTriggerSchema, TSteps>;
+            mastra?: Mastra;
+        }) => Promise<boolean | WhenConditionReturnValue>);
+        loopLabel?: string;
+        loopType?: 'while' | 'until' | undefined;
     };
+    id?: string;
+}
+type StepSuccess$1<T> = {
+    status: 'success';
+    output: T;
 };
-/**
- * Abstract Memory class that defines the interface for storing and retrieving
- * conversation threads and messages.
- */
-declare abstract class MastraMemory extends MastraBase {
-    MAX_CONTEXT_TOKENS?: number;
-    protected _storage?: MastraStorage;
-    vector?: MastraVector;
-    embedder?: EmbeddingModel<string>;
-    private processors;
-    protected threadConfig: MemoryConfig;
-    constructor(config: {
-        name: string;
-    } & SharedMemoryConfig);
-    protected _hasOwnStorage: boolean;
-    get hasOwnStorage(): boolean;
-    get storage(): MastraStorage;
-    setStorage(storage: MastraStorage): void;
-    setVector(vector: MastraVector): void;
-    setEmbedder(embedder: EmbeddingModel<string>): void;
-    /**
-     * Get a system message to inject into the conversation.
-     * This will be called before each conversation turn.
-     * Implementations can override this to inject custom system messages.
-     */
-    getSystemMessage(_input: {
-        threadId: string;
-        memoryConfig?: MemoryConfig;
-    }): Promise<string | null>;
-    /**
-     * Get tools that should be available to the agent.
-     * This will be called when converting tools for the agent.
-     * Implementations can override this to provide additional tools.
-     */
-    getTools(_config?: MemoryConfig): Record<string, CoreTool>;
-    protected createEmbeddingIndex(dimensions?: number): Promise<{
-        indexName: string;
+type StepSuspended$1<T> = {
+    status: 'suspended';
+    suspendPayload?: any;
+    output?: T;
+};
+type StepWaiting = {
+    status: 'waiting';
+};
+type StepFailure$1 = {
+    status: 'failed';
+    error: string;
+};
+type StepSkipped = {
+    status: 'skipped';
+};
+type StepResult$1<T> = StepSuccess$1<T> | StepFailure$1 | StepSuspended$1<T> | StepWaiting | StepSkipped;
+type StepsRecord$1<T extends readonly LegacyStep<any, any, z.ZodType<any> | undefined>[]> = {
+    [K in T[number]['id']]: Extract<T[number], {
+        id: K;
     }>;
-    getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
-    /**
-     * Apply all configured message processors to a list of messages.
-     * @param messages The messages to process
-     * @returns The processed messages
-     */
-    private applyProcessors;
-    processMessages({ messages, processors, ...opts }: {
-        messages: CoreMessage$1[];
-        processors?: MemoryProcessor[];
-    } & MemoryProcessorOpts): CoreMessage$1[];
-    abstract rememberMessages({ threadId, resourceId, vectorMessageSearch, systemMessage, config, }: {
-        threadId: string;
-        resourceId?: string;
-        vectorMessageSearch?: string;
-        systemMessage?: CoreMessage$1;
-        config?: MemoryConfig;
-    }): Promise<{
-        threadId: string;
-        messages: CoreMessage$1[];
-        uiMessages: Message[];
-    }>;
-    estimateTokens(text: string): number;
-    protected parseMessages(messages: MessageType[]): CoreMessage$1[];
-    protected convertToUIMessages(messages: MessageType[]): Message[];
-    /**
-     * Retrieves a specific thread by its ID
-     * @param threadId - The unique identifier of the thread
-     * @returns Promise resolving to the thread or null if not found
-     */
-    abstract getThreadById({ threadId }: {
-        threadId: string;
-    }): Promise<StorageThreadType | null>;
-    abstract getThreadsByResourceId({ resourceId }: {
-        resourceId: string;
-    }): Promise<StorageThreadType[]>;
-    /**
-     * Saves or updates a thread
-     * @param thread - The thread data to save
-     * @returns Promise resolving to the saved thread
-     */
-    abstract saveThread({ thread, memoryConfig, }: {
-        thread: StorageThreadType;
-        memoryConfig?: MemoryConfig;
-    }): Promise<StorageThreadType>;
-    /**
-     * Saves messages to a thread
-     * @param messages - Array of messages to save
-     * @returns Promise resolving to the saved messages
-     */
-    abstract saveMessages({ messages, memoryConfig, }: {
-        messages: MessageType[];
-        memoryConfig: MemoryConfig | undefined;
-    }): Promise<MessageType[]>;
-    /**
-     * Retrieves all messages for a specific thread
-     * @param threadId - The unique identifier of the thread
-     * @returns Promise resolving to array of messages and uiMessages
-     */
-    abstract query({ threadId, resourceId, selectBy, }: StorageGetMessagesArg): Promise<{
-        messages: CoreMessage$1[];
-        uiMessages: Message[];
-    }>;
-    /**
-     * Helper method to create a new thread
-     * @param title - Optional title for the thread
-     * @param metadata - Optional metadata for the thread
-     * @returns Promise resolving to the created thread
-     */
-    createThread({ threadId, resourceId, title, metadata, memoryConfig, }: {
-        resourceId: string;
-        threadId?: string;
-        title?: string;
-        metadata?: Record<string, unknown>;
-        memoryConfig?: MemoryConfig;
-    }): Promise<StorageThreadType>;
-    /**
-     * Helper method to delete a thread
-     * @param threadId - the id of the thread to delete
-     */
-    abstract deleteThread(threadId: string): Promise<void>;
-    /**
-     * Helper method to add a single message to a thread
-     * @param threadId - The thread to add the message to
-     * @param content - The message content
-     * @param role - The role of the message sender
-     * @param type - The type of the message
-     * @param toolNames - Optional array of tool names that were called
-     * @param toolCallArgs - Optional array of tool call arguments
-     * @param toolCallIds - Optional array of tool call ids
-     * @returns Promise resolving to the saved message
-     */
-    addMessage({ threadId, resourceId, config, content, role, type, toolNames, toolCallArgs, toolCallIds, }: {
-        threadId: string;
-        resourceId: string;
-        config?: MemoryConfig;
-        content: UserContent | AssistantContent;
-        role: 'user' | 'assistant';
-        type: 'text' | 'tool-call' | 'tool-result';
-        toolNames?: string[];
-        toolCallArgs?: Record<string, unknown>[];
-        toolCallIds?: string[];
-    }): Promise<MessageType>;
-    /**
-     * Generates a unique identifier
-     * @returns A unique string ID
-     */
-    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;
-type CoreAssistantMessage = CoreAssistantMessage$1;
-type CoreUserMessage = CoreUserMessage$1;
-type CoreToolMessage = CoreToolMessage$1;
-type EmbedResult<T> = EmbedResult$1<T>;
-type EmbedManyResult<T> = EmbedManyResult$1<T>;
-type BaseStructuredOutputType = 'string' | 'number' | 'boolean' | 'date';
-type StructuredOutputType = 'array' | 'string' | 'number' | 'object' | 'boolean' | 'date';
-type StructuredOutputArrayItem = {
-    type: BaseStructuredOutputType;
-} | {
-    type: 'object';
-    items: StructuredOutput;
-};
-type StructuredOutput = {
-    [key: string]: {
-        type: BaseStructuredOutputType;
-    } | {
-        type: 'object';
-        items: StructuredOutput;
-    } | {
-        type: 'array';
-        items: StructuredOutputArrayItem;
-    };
-};
-type GenerateReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>;
-type StreamReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>;
-type OutputType = StructuredOutput | ZodSchema | JSONSchema7 | undefined;
-type GenerateTextOptions = Parameters<typeof generateText>[0];
-type StreamTextOptions = Parameters<typeof streamText>[0];
-type GenerateObjectOptions = Parameters<typeof generateObject>[0];
-type StreamObjectOptions = Parameters<typeof streamObject>[0];
-type MastraCustomLLMOptionsKeys = 'messages' | 'tools' | 'model' | 'onStepFinish' | 'experimental_output' | 'experimental_telemetry' | 'messages' | 'onFinish' | 'output';
-type DefaultLLMTextOptions = Omit<GenerateTextOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMTextObjectOptions = Omit<GenerateObjectOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMStreamOptions = Omit<StreamTextOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMStreamObjectOptions = Omit<StreamObjectOptions, MastraCustomLLMOptionsKeys>;
-type MastraCustomLLMOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    tools?: Record<string, CoreTool>;
-    onStepFinish?: (step: unknown) => Promise<void> | void;
-    experimental_output?: Z;
-    telemetry?: TelemetrySettings;
-    threadId?: string;
-    resourceId?: string;
-    runtimeContext: RuntimeContext;
-} & Run$1;
-type LLMTextOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    messages: CoreMessage[];
-} & MastraCustomLLMOptions<Z> & DefaultLLMTextOptions;
-type LLMTextObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = LLMTextOptions<T> & DefaultLLMTextObjectOptions & {
-    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
-};
-type LLMStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    output?: OutputType | Z;
-    onFinish?: (result: string) => Promise<void> | void;
-} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
-type LLMInnerStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    messages: CoreMessage[];
-    onFinish?: (result: string) => Promise<void> | void;
-} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
-type LLMStreamObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
-} & LLMInnerStreamOptions<T> & DefaultLLMStreamObjectOptions;
-
-type VoiceEventType = 'speaking' | 'writing' | 'error' | string;
-interface VoiceEventMap {
-    speaker: NodeJS.ReadableStream;
-    speaking: {
-        audio?: string;
-    };
-    writing: {
-        text: string;
-        role: 'assistant' | 'user';
-    };
-    error: {
-        message: string;
-        code?: string;
-        details?: unknown;
-    };
-    [key: string]: unknown;
-}
-interface BuiltInModelConfig {
-    name: string;
-    apiKey?: string;
-}
-interface VoiceConfig<T = unknown> {
-    listeningModel?: BuiltInModelConfig;
-    speechModel?: BuiltInModelConfig;
-    speaker?: string;
-    name?: string;
-    realtimeConfig?: {
-        model?: string;
-        apiKey?: string;
-        options?: T;
-    };
-}
-declare abstract class MastraVoice<TOptions = unknown, TSpeakOptions = unknown, TListenOptions = unknown, TTools extends ToolsInput = ToolsInput, TEventArgs extends VoiceEventMap = VoiceEventMap, TSpeakerMetadata = unknown> extends MastraBase {
-    protected listeningModel?: BuiltInModelConfig;
-    protected speechModel?: BuiltInModelConfig;
-    protected speaker?: string;
-    protected realtimeConfig?: {
-        model?: string;
-        apiKey?: string;
-        options?: TOptions;
-    };
-    constructor({ listeningModel, speechModel, speaker, realtimeConfig, name }?: VoiceConfig<TOptions>);
-    traced<T extends Function>(method: T, methodName: string): T;
-    /**
-     * Convert text to speech
-     * @param input Text or text stream to convert to speech
-     * @param options Speech options including speaker and provider-specific options
-     * @returns Audio stream
-     */
-    /**
-     * Convert text to speech
-     * @param input Text or text stream to convert to speech
-     * @param options Speech options including speaker and provider-specific options
-     * @returns Audio stream or void if in chat mode
-     */
-    abstract speak(input: string | NodeJS.ReadableStream, options?: {
-        speaker?: string;
-    } & TSpeakOptions): Promise<NodeJS.ReadableStream | void>;
-    /**
-     * Convert speech to text
-     * @param audioStream Audio stream to transcribe
-     * @param options Provider-specific transcription options
-     * @returns Text or text stream
-     */
-    /**
-     * Convert speech to text
-     * @param audioStream Audio stream to transcribe
-     * @param options Provider-specific transcription options
-     * @returns Text, text stream, or void if in chat mode
-     */
-    abstract listen(audioStream: NodeJS.ReadableStream | unknown, // Allow other audio input types for OpenAI realtime API
-    options?: TListenOptions): Promise<string | NodeJS.ReadableStream | void>;
-    updateConfig(_options: Record<string, unknown>): void;
-    /**
-     * Initializes a WebSocket or WebRTC connection for real-time communication
-     * @returns Promise that resolves when the connection is established
-     */
-    connect(_options?: Record<string, unknown>): Promise<void>;
-    /**
-     * Relay audio data to the voice provider for real-time processing
-     * @param audioData Audio data to relay
-     */
-    send(_audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
-    /**
-     * Trigger voice providers to respond
-     */
-    answer(_options?: Record<string, unknown>): Promise<void>;
-    /**
-     * Equip the voice provider with instructions
-     * @param instructions Instructions to add
-     */
-    addInstructions(_instructions?: string): void;
-    /**
-     * Equip the voice provider with tools
-     * @param tools Array of tools to add
-     */
-    addTools(_tools: TTools): void;
-    /**
-     * Disconnect from the WebSocket or WebRTC connection
-     */
-    close(): void;
-    /**
-     * Register an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function that receives event data
-     */
-    on<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
-    /**
-     * Remove an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function to remove
-     */
-    off<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
-    /**
-     * Get available speakers/voices
-     * @returns Array of available voice IDs and their metadata
-     */
-    getSpeakers(): Promise<Array<{
-        voiceId: string;
-    } & TSpeakerMetadata>>;
-}
-
-declare class CompositeVoice extends MastraVoice<unknown, unknown, unknown, ToolsInput, VoiceEventMap> {
-    protected speakProvider?: MastraVoice;
-    protected listenProvider?: MastraVoice;
-    protected realtimeProvider?: MastraVoice;
-    constructor({ input, output, realtime, speakProvider, listenProvider, realtimeProvider, }: {
-        /** @deprecated use output instead */
-        speakProvider?: MastraVoice;
-        /** @deprecated use input instead */
-        listenProvider?: MastraVoice;
-        /** @deprecated use realtime instead */
-        realtimeProvider?: MastraVoice;
-        input?: MastraVoice;
-        output?: MastraVoice;
-        realtime?: MastraVoice;
-    });
-    /**
-     * Convert text to speech using the configured provider
-     * @param input Text or text stream to convert to speech
-     * @param options Speech options including speaker and provider-specific options
-     * @returns Audio stream or void if in realtime mode
-     */
-    speak(input: string | NodeJS.ReadableStream, options?: {
-        speaker?: string;
-    } & any): Promise<NodeJS.ReadableStream | void>;
-    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<string | void | NodeJS.ReadableStream>;
-    getSpeakers(): Promise<{
-        voiceId: string;
-    }[]>;
-    updateConfig(options: Record<string, unknown>): void;
-    /**
-     * Initializes a WebSocket or WebRTC connection for real-time communication
-     * @returns Promise that resolves when the connection is established
-     */
-    connect(options?: Record<string, unknown>): Promise<void>;
-    /**
-     * Relay audio data to the voice provider for real-time processing
-     * @param audioData Audio data to send
-     */
-    send(audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
-    /**
-     * Trigger voice providers to respond
-     */
-    answer(options?: Record<string, unknown>): Promise<void>;
-    /**
-     * Equip the voice provider with instructions
-     * @param instructions Instructions to add
-     */
-    addInstructions(instructions: string): void;
-    /**
-     * Equip the voice provider with tools
-     * @param tools Array of tools to add
-     */
-    addTools(tools: ToolsInput): void;
-    /**
-     * Disconnect from the WebSocket or WebRTC connection
-     */
-    close(): void;
-    /**
-     * Register an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function that receives event data
-     */
-    on<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
-    /**
-     * Remove an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function to remove
-     */
-    off<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
-}
-
-declare class DefaultVoice extends MastraVoice {
-    constructor();
-    speak(_input: string | NodeJS.ReadableStream): Promise<NodeJS.ReadableStream>;
-    listen(_input: string | NodeJS.ReadableStream): Promise<string>;
-    getSpeakers(): Promise<{
-        voiceId: string;
-    }[]>;
-}
-
-interface WorkflowOptions<TWorkflowName extends string = string, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> {
-    steps?: TSteps;
-    name: TWorkflowName;
-    triggerSchema?: TTriggerSchema;
-    result?: {
-        schema: TResultSchema;
-        mapping?: {
-            [K in keyof z.infer<TResultSchema>]?: any;
-        };
-    };
-    events?: Record<string, {
-        schema: z.ZodObject<any>;
-    }>;
-    retryConfig?: RetryConfig;
-    mastra?: Mastra;
-}
-interface StepExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined, TContext extends WorkflowContext = WorkflowContext> extends IExecutionContext<TSchemaIn> {
-    context: TSchemaIn extends z.ZodSchema ? {
-        inputData: z.infer<TSchemaIn>;
-    } & TContext : TContext;
-    suspend: (payload?: unknown, softSuspend?: any) => Promise<void>;
-    runId: string;
-    emit: (event: string, data: any) => void;
-    mastra?: MastraUnion;
-    runtimeContext: RuntimeContext;
-}
-interface StepAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>> extends IAction<TId, TSchemaIn, TSchemaOut, TContext> {
-    mastra?: Mastra;
-    payload?: TSchemaIn extends z.ZodSchema ? Partial<z.infer<TSchemaIn>> : unknown;
-    execute: (context: TContext) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
-    retryConfig?: RetryConfig;
-    workflow?: LegacyWorkflow;
-    workflowId?: string;
-}
-interface SimpleConditionalType {
-    [key: `${string}.${string}`]: string | Query<any>;
-}
-type StepVariableType<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>> = StepAction<TId, TSchemaIn, TSchemaOut, TContext> | 'trigger' | {
-    id: string;
-};
-type StepNode = {
-    id: string;
-    step: StepAction<any, any, any, any>;
-    config: StepDef<any, any, any, any>[any];
-};
-type StepGraph = {
-    initial: StepNode[];
-    [key: string]: StepNode[];
-};
-type RetryConfig = {
-    attempts?: number;
-    delay?: number;
-};
-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$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.';
-} : TStep extends 'trigger' ? {
-    step: 'trigger';
-    path: PathsToStringProps$1<ExtractSchemaType$1<TTriggerSchema>> | '.' | '';
-} : {
-    step: {
-        id: string;
-    };
-    path: string;
-};
-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$1<ExtractSchemaType$1<ExtractSchemaFromStep$1<TStep, 'outputSchema'>>> | '' | '.' | 'status';
-    } : TStep extends 'trigger' ? {
-        step: 'trigger';
-        path: PathsToStringProps$1<ExtractSchemaType$1<TTriggerSchema>> | '.' | '';
-    } : {
-        step: {
-            id: string;
-        };
-        path: string;
-    };
-    query: Query<any>;
-}
-type ActionContext<TSchemaIn extends z.ZodType<any>> = StepExecutionContext<z.infer<TSchemaIn>, WorkflowContext>;
-declare enum WhenConditionReturnValue {
-    CONTINUE = "continue",
-    CONTINUE_FAILED = "continue_failed",
-    ABORT = "abort",
-    LIMBO = "limbo"
-}
-type StepDef<TStepId extends TSteps[number]['id'], TSteps extends StepAction<any, any, any, any>[], TSchemaIn extends z.ZodType<any>, TSchemaOut extends z.ZodType<any>> = Record<TStepId, {
-    id?: string;
-    when?: Condition<any, any> | ((args: {
-        context: WorkflowContext;
-        mastra?: Mastra;
-    }) => Promise<boolean | WhenConditionReturnValue>);
-    serializedWhen?: Condition<any, any> | string;
-    loopLabel?: string;
-    loopType?: 'while' | 'until';
-    data: TSchemaIn;
-    handler: (args: ActionContext<TSchemaIn>) => Promise<z.infer<TSchemaOut>>;
-}>;
-type StepCondition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = BaseCondition<TStep, TTriggerSchema> | SimpleConditionalType | {
-    and: StepCondition<TStep, TTriggerSchema>[];
-} | {
-    or: StepCondition<TStep, TTriggerSchema>[];
-} | {
-    not: StepCondition<TStep, TTriggerSchema>;
-};
-type Condition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = BaseCondition<TStep, TTriggerSchema> | SimpleConditionalType | {
-    and: Condition<TStep, TTriggerSchema>[];
-} | {
-    or: Condition<TStep, TTriggerSchema>[];
-} | {
-    not: Condition<TStep, TTriggerSchema>;
-};
-interface StepConfig<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[]> {
-    when?: Condition<CondStep, TTriggerSchema> | ((args: {
-        context: WorkflowContext<TTriggerSchema, TSteps>;
-        mastra?: Mastra;
-    }) => Promise<boolean | WhenConditionReturnValue>);
-    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: {
-            context: WorkflowContext<TTriggerSchema, TSteps>;
-            mastra?: Mastra;
-        }) => Promise<boolean | WhenConditionReturnValue>);
-        loopLabel?: string;
-        loopType?: 'while' | 'until' | undefined;
-    };
-    id?: string;
-}
-type StepSuccess$1<T> = {
-    status: 'success';
-    output: T;
-};
-type StepSuspended$1<T> = {
-    status: 'suspended';
-    suspendPayload?: any;
-    output?: T;
-};
-type StepWaiting = {
-    status: 'waiting';
-};
-type StepFailure$1 = {
-    status: 'failed';
-    error: string;
-};
-type StepSkipped = {
-    status: 'skipped';
-};
-type StepResult$1<T> = StepSuccess$1<T> | StepFailure$1 | StepSuspended$1<T> | StepWaiting | StepSkipped;
-type StepsRecord$1<T extends readonly LegacyStep<any, any, z.ZodType<any> | undefined>[]> = {
-    [K in T[number]['id']]: Extract<T[number], {
-        id: K;
-    }>;
-};
-interface LegacyWorkflowRunResult<T extends z.ZodObject<any>, TSteps extends LegacyStep<string, any, z.ZodType<any> | undefined>[], TResult extends z.ZodObject<any>> {
-    triggerData?: z.infer<T>;
-    result?: z.infer<TResult>;
-    results: {
-        [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$1<TSteps>, {
-        status: string;
-        suspendPayload?: any;
-        stepPath: string[];
+};
+interface LegacyWorkflowRunResult<T extends z.ZodObject<any>, TSteps extends LegacyStep<string, any, z.ZodType<any> | undefined>[], TResult extends z.ZodObject<any>> {
+    triggerData?: z.infer<T>;
+    result?: z.infer<TResult>;
+    results: {
+        [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$1<TSteps>, {
+        status: string;
+        suspendPayload?: any;
+        stepPath: string[];
     }>;
 }
 interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[], TInputData extends Record<string, any> = Record<string, any>> {
@@ -1341,658 +870,1343 @@ interface WorkflowResultReturn<TResult extends z.ZodObject<any>, T extends z.Zod
     }) => Promise<Omit<LegacyWorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
     resumeWithEvent: (eventName: string, data: any, runtimeContext?: RuntimeContext) => Promise<Omit<LegacyWorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
 }
-declare class WorkflowInstance<TSteps extends LegacyStep<any, any, any, any>[] = LegacyStep<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResult extends z.ZodObject<any> = any> implements WorkflowResultReturn<TResult, TTriggerSchema, TSteps> {
+declare class WorkflowInstance<TSteps extends LegacyStep<any, any, any, any>[] = LegacyStep<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResult extends z.ZodObject<any> = any> implements WorkflowResultReturn<TResult, TTriggerSchema, TSteps> {
+    #private;
+    name: string;
+    logger: IMastraLogger;
+    events?: Record<string, {
+        schema: z.ZodObject<any>;
+    }>;
+    constructor({ name, logger, steps, runId, retryConfig, mastra, stepGraph, stepSubscriberGraph, onFinish, onStepTransition, resultMapping, events, }: {
+        name: string;
+        logger: IMastraLogger;
+        steps: Record<string, StepNode>;
+        mastra?: Mastra;
+        retryConfig?: RetryConfig;
+        runId?: string;
+        stepGraph: StepGraph;
+        stepSubscriberGraph: Record<string, StepGraph>;
+        onFinish?: () => void;
+        onStepTransition?: Set<(state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void | Promise<void>>;
+        resultMapping?: Record<string, {
+            step: StepAction<any, any, any, any>;
+            path: string;
+        }>;
+        events?: Record<string, {
+            schema: z.ZodObject<any>;
+        }>;
+    });
+    setState(state: any): void;
+    get runId(): string;
+    get executionSpan(): Span | undefined;
+    watch(onTransition: (state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
+    start({ triggerData, runtimeContext, }?: {
+        triggerData?: z.infer<TTriggerSchema>;
+        runtimeContext?: RuntimeContext;
+    }): Promise<{
+        runId: string;
+        result?: z.TypeOf<TResult> | undefined;
+        triggerData?: z.TypeOf<TTriggerSchema> | undefined;
+        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"]>>>; };
+        timestamp: number;
+        activePaths: Map<TSteps[number]["id"], {
+            status: string;
+            suspendPayload?: any;
+            stepPath: string[];
+        }>;
+    }>;
+    private isCompoundDependencyMet;
+    execute({ triggerData, snapshot, stepId, resumeData, runtimeContext, }?: {
+        stepId?: string;
+        triggerData?: z.infer<TTriggerSchema>;
+        snapshot?: Snapshot<any>;
+        resumeData?: any;
+        runtimeContext: RuntimeContext;
+    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'runId'>>;
+    hasSubscribers(stepId: string): boolean;
+    runMachine(parentStepId: string, input: any, runtimeContext?: RuntimeContext): Promise<(Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId" | "results" | "timestamp" | "activePaths"> | undefined)[]>;
+    suspend(stepId: string, machine: Machine<TSteps, TTriggerSchema>): Promise<void>;
+    /**
+     * Persists the workflow state to the database
+     */
+    persistWorkflowSnapshot(): Promise<void>;
+    getState(): Promise<LegacyWorkflowRunState | null>;
+    resumeWithEvent(eventName: string, data: any, runtimeContext?: RuntimeContext): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    resume({ stepId, context: resumeContext, runtimeContext, }: {
+        stepId: string;
+        context?: Record<string, any>;
+        runtimeContext?: RuntimeContext;
+    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    _resume({ stepId, context: resumeContext, runtimeContext, }: {
+        stepId: string;
+        context?: Record<string, any>;
+        runtimeContext: RuntimeContext;
+    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+}
+
+type WorkflowBuilder<T extends LegacyWorkflow<any, any>> = Pick<T, 'step' | 'then' | 'after' | 'while' | 'until' | 'if' | 'else' | 'afterEvent' | 'commit'>;
+declare class LegacyWorkflow<TSteps extends LegacyStep<string, any, any>[] = LegacyStep<string, any, any>[], TStepId extends string = string, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends MastraBase {
     #private;
-    name: string;
-    logger: IMastraLogger;
+    name: TStepId;
+    triggerSchema?: TTriggerSchema;
+    resultSchema?: TResultSchema;
+    resultMapping?: Record<string, {
+        step: StepAction<string, any, any, any>;
+        path: string;
+    }>;
     events?: Record<string, {
         schema: z.ZodObject<any>;
     }>;
-    constructor({ name, logger, steps, runId, retryConfig, mastra, stepGraph, stepSubscriberGraph, onFinish, onStepTransition, resultMapping, events, }: {
-        name: string;
-        logger: IMastraLogger;
-        steps: Record<string, StepNode>;
-        mastra?: Mastra;
-        retryConfig?: RetryConfig;
+    isNested: boolean;
+    /**
+     * Creates a new LegacyWorkflow instance
+     * @param name - Identifier for the workflow (not necessarily unique)
+     * @param logger - Optional logger instance
+     */
+    constructor({ name, triggerSchema, result, retryConfig, mastra, events, }: WorkflowOptions<TStepId, TSteps, TTriggerSchema, TResultSchema>);
+    step<TWorkflow extends LegacyWorkflow<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(next: TWorkflow, config?: StepConfig<ReturnType<TWorkflow['toStep']>, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
+    step<TAgent extends Agent<any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(next: TAgent, config?: StepConfig<ReturnType<TAgent['toStep']>, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
+    step<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(step: TStep, config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
+    then<TStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TStep | TStep[], config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema>): this;
+    then<TWorkflow extends LegacyWorkflow<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TWorkflow | TWorkflow[], config?: StepConfig<StepAction<string, any, any, any>, CondStep, VarStep, TTriggerSchema>): this;
+    then<TAgent extends Agent<any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TAgent | TAgent[], config?: StepConfig<StepAction<string, any, any, any>, CondStep, VarStep, TTriggerSchema>): this;
+    private loop;
+    while<FallbackStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['when'], fallbackStep: FallbackStep, variables?: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['variables']): Pick<WorkflowBuilder<this>, "then" | "commit">;
+    until<FallbackStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['when'], fallbackStep: FallbackStep, variables?: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['variables']): Pick<WorkflowBuilder<this>, "then" | "commit">;
+    if<TStep extends StepAction<string, any, any, any>>(condition: StepConfig<TStep, any, any, TTriggerSchema>['when'], ifStep?: TStep | LegacyWorkflow, elseStep?: TStep | LegacyWorkflow): this | WorkflowBuilder<this>;
+    else(): WorkflowBuilder<this>;
+    after<TStep extends StepAction<string, any, any, any>>(steps: string | TStep | TStep[] | (TStep | string)[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
+    after<TWorkflow extends LegacyWorkflow<any, any, any, any>>(steps: TWorkflow | TWorkflow[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
+    after<TAgent extends Agent<any, any, any>>(steps: TAgent | TAgent[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
+    afterEvent(eventName: string): WorkflowBuilder<this>;
+    /**
+     * Executes the workflow with the given trigger data
+     * @param triggerData - Initial data to start the workflow with
+     * @returns Promise resolving to workflow results or rejecting with error
+     * @throws Error if trigger schema validation fails
+     */
+    createRun({ runId, events, }?: {
         runId?: string;
-        stepGraph: StepGraph;
-        stepSubscriberGraph: Record<string, StepGraph>;
-        onFinish?: () => void;
-        onStepTransition?: Set<(state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void | Promise<void>>;
-        resultMapping?: Record<string, {
-            step: StepAction<any, any, any, any>;
-            path: string;
-        }>;
         events?: Record<string, {
             schema: z.ZodObject<any>;
         }>;
+    }): WorkflowResultReturn<TResultSchema, TTriggerSchema, TSteps>;
+    /**
+     * Gets a workflow run instance by ID
+     * @param runId - ID of the run to retrieve
+     * @returns The workflow run instance if found, undefined otherwise
+     */
+    getRun(runId: string): Promise<WorkflowRun | WorkflowInstance<TSteps, TTriggerSchema, any> | null>;
+    /**
+     * Gets a workflow run instance by ID, from memory
+     * @param runId - ID of the run to retrieve
+     * @returns The workflow run instance if found, undefined otherwise
+     */
+    getMemoryRun(runId: string): WorkflowInstance<TSteps, TTriggerSchema, any> | undefined;
+    /**
+     * Rebuilds the machine with the current steps configuration and validates the workflow
+     *
+     * This is the last step of a workflow builder method chain
+     * @throws Error if validation fails
+     *
+     * @returns this instance for method chaining
+     */
+    commit(): this;
+    getWorkflowRuns(args?: {
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<LegacyWorkflowRuns>;
+    getExecutionSpan(runId: string): Span | undefined;
+    getState(runId: string): Promise<LegacyWorkflowRunState | null>;
+    resume({ runId, stepId, context: resumeContext, runtimeContext, }: {
+        runId: string;
+        stepId: string;
+        context?: Record<string, any>;
+        runtimeContext: RuntimeContext;
+    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
+    watch(onTransition: (state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
+    resumeWithEvent(runId: string, eventName: string, data: any): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
+    __registerMastra(mastra: Mastra): void;
+    __registerPrimitives(p: MastraPrimitives): void;
+    get stepGraph(): StepGraph;
+    get stepSubscriberGraph(): Record<string, StepGraph>;
+    get serializedStepGraph(): StepGraph;
+    get serializedStepSubscriberGraph(): Record<string, StepGraph>;
+    get steps(): Record<string, StepAction<string, any, any, any>>;
+    setNested(isNested: boolean): void;
+    toStep(): LegacyStep<TStepId, TTriggerSchema, z.ZodType<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
+}
+
+type ExecuteFunction<TStepInput, TStepOutput, TResumeSchema, TSuspendSchema> = (params: {
+    mastra: Mastra;
+    runtimeContext: RuntimeContext;
+    inputData: TStepInput;
+    resumeData?: TResumeSchema;
+    getInitData<T extends z.ZodType<any>>(): z.infer<T>;
+    getInitData<T extends Workflow<any, any, any, any, any>>(): T extends undefined ? unknown : z.infer<NonNullable<T['inputSchema']>>;
+    getStepResult<T extends Step<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_SYMBOL]: {
+        emit: (event: string, data: any) => Promise<void>;
+    };
+}) => Promise<TStepOutput>;
+interface Step<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<P, R, S, T> = {
+    status: 'success';
+    output: T;
+    payload: P;
+    resumePayload?: R;
+    suspendPayload?: S;
+    startedAt: number;
+    endedAt: number;
+    suspendedAt?: number;
+    resumedAt?: number;
+};
+type StepFailure<P, R, S> = {
+    status: 'failed';
+    error: string | Error;
+    payload: P;
+    resumePayload?: R;
+    suspendPayload?: S;
+    startedAt: number;
+    endedAt: number;
+    suspendedAt?: number;
+    resumedAt?: number;
+};
+type StepSuspended<P, S> = {
+    status: 'suspended';
+    payload: P;
+    suspendPayload?: S;
+    startedAt: number;
+    suspendedAt: number;
+};
+type StepRunning<P, R, S> = {
+    status: 'running';
+    payload: P;
+    resumePayload?: R;
+    suspendPayload?: S;
+    startedAt: number;
+    suspendedAt?: number;
+    resumedAt?: number;
+};
+type StepResult<P, R, S, T> = StepSuccess<P, R, S, T> | StepFailure<P, R, S> | StepSuspended<P, S> | StepRunning<P, R, S>;
+type StepsRecord<T extends readonly Step<any, any, any>[]> = {
+    [K in T[number]['id']]: Extract<T[number], {
+        id: K;
+    }>;
+};
+type DynamicMapping<TPrevSchema extends z.ZodTypeAny, TSchemaOut extends z.ZodTypeAny> = {
+    fn: ExecuteFunction<z.infer<TPrevSchema>, z.infer<TSchemaOut>, any, any>;
+    schema: TSchemaOut;
+};
+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 Step<any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
+type VariableReference<TStep extends Step<string, any, any> = Step<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>;
+            resumePayload?: Record<string, any>;
+            payload?: Record<string, any>;
+            error?: string | Error;
+        };
+        workflowState: {
+            status: 'running' | 'success' | 'failed' | 'suspended';
+            steps: Record<string, {
+                status: 'running' | 'success' | 'failed' | 'suspended';
+                output?: Record<string, any>;
+                payload?: Record<string, any>;
+                resumePayload?: Record<string, any>;
+                error?: string | Error;
+                startedAt: number;
+                endedAt: number;
+                suspendedAt?: number;
+                resumedAt?: number;
+            }>;
+            output?: Record<string, any>;
+            payload?: Record<string, any>;
+            error?: string | Error;
+        };
+    };
+    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;
+interface WorkflowRunState {
+    runId: string;
+    value: Record<string, string>;
+    context: {
+        input?: Record<string, any>;
+    } & Record<string, StepResult<any, any, any, any>>;
+    activePaths: Array<unknown>;
+    suspendedPaths: Record<string, number[]>;
+    timestamp: number;
+}
+
+/**
+ * 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;
     });
-    setState(state: any): void;
-    get runId(): string;
-    get executionSpan(): Span | undefined;
-    watch(onTransition: (state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
-    start({ triggerData, runtimeContext, }?: {
-        triggerData?: z.infer<TTriggerSchema>;
-        runtimeContext?: RuntimeContext;
-    }): Promise<{
-        runId: string;
-        result?: z.TypeOf<TResult> | undefined;
-        triggerData?: z.TypeOf<TTriggerSchema> | undefined;
-        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"]>>>; };
-        timestamp: number;
-        activePaths: Map<TSteps[number]["id"], {
-            status: string;
-            suspendPayload?: any;
-            stepPath: string[];
-        }>;
-    }>;
-    private isCompoundDependencyMet;
-    execute({ triggerData, snapshot, stepId, resumeData, runtimeContext, }?: {
-        stepId?: string;
-        triggerData?: z.infer<TTriggerSchema>;
-        snapshot?: Snapshot<any>;
-        resumeData?: any;
-        runtimeContext: RuntimeContext;
-    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'runId'>>;
-    hasSubscribers(stepId: string): boolean;
-    runMachine(parentStepId: string, input: any, runtimeContext?: RuntimeContext): Promise<(Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId" | "results" | "timestamp" | "activePaths"> | undefined)[]>;
-    suspend(stepId: string, machine: Machine<TSteps, TTriggerSchema>): Promise<void>;
+    __registerMastra(mastra: Mastra): void;
     /**
-     * Persists the workflow state to the database
+     * 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
      */
-    persistWorkflowSnapshot(): Promise<void>;
-    getState(): Promise<LegacyWorkflowRunState | null>;
-    resumeWithEvent(eventName: string, data: any, runtimeContext?: RuntimeContext): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
-    resume({ stepId, context: resumeContext, runtimeContext, }: {
-        stepId: string;
-        context?: Record<string, any>;
-        runtimeContext?: RuntimeContext;
-    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
-    _resume({ stepId, context: resumeContext, runtimeContext, }: {
-        stepId: string;
-        context?: Record<string, any>;
+    abstract execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
         runtimeContext: RuntimeContext;
-    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+    }): Promise<TOutput>;
 }
 
-type WorkflowBuilder<T extends LegacyWorkflow<any, any>> = Pick<T, 'step' | 'then' | 'after' | 'while' | 'until' | 'if' | 'else' | 'afterEvent' | 'commit'>;
-declare class LegacyWorkflow<TSteps extends LegacyStep<string, any, any>[] = LegacyStep<string, any, any>[], TStepId extends string = string, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends MastraBase {
+type StepFlowEntry = {
+    type: 'step';
+    step: Step;
+} | {
+    type: 'parallel';
+    steps: StepFlowEntry[];
+} | {
+    type: 'conditional';
+    steps: StepFlowEntry[];
+    conditions: ExecuteFunction<any, any, any, any>[];
+    serializedConditions: {
+        id: string;
+        fn: string;
+    }[];
+} | {
+    type: 'loop';
+    step: Step;
+    condition: ExecuteFunction<any, any, any, any>;
+    serializedCondition: {
+        id: string;
+        fn: string;
+    };
+    loopType: 'dowhile' | 'dountil';
+} | {
+    type: 'foreach';
+    step: Step;
+    opts: {
+        concurrency: number;
+    };
+};
+type SerializedStep = Pick<Step, 'id' | 'description'> & {
+    component?: string;
+    serializedStepFlow?: SerializedStepFlowEntry[];
+    mapConfig?: string;
+};
+type SerializedStepFlowEntry = {
+    type: 'step';
+    step: SerializedStep;
+} | {
+    type: 'parallel';
+    steps: SerializedStepFlowEntry[];
+} | {
+    type: 'conditional';
+    steps: SerializedStepFlowEntry[];
+    serializedConditions: {
+        id: string;
+        fn: string;
+    }[];
+} | {
+    type: 'loop';
+    step: SerializedStep;
+    serializedCondition: {
+        id: string;
+        fn: string;
+    };
+    loopType: 'dowhile' | 'dountil';
+} | {
+    type: 'foreach';
+    step: SerializedStep;
+    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>>;
+}): Step<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>): Step<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>;
+}): Step<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>>;
+declare function cloneStep<TStepId extends string>(step: Step<string, any, any>, opts: {
+    id: TStepId;
+}): Step<TStepId, 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 Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]>(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TInput>;
+declare function cloneWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]>(workflow: Workflow<TSteps, string, TInput, TOutput>, opts: {
+    id: TWorkflowId;
+}): Workflow<TSteps, TWorkflowId, TInput, TOutput>;
+type WorkflowResult<TOutput extends z.ZodType<any>, TSteps extends Step<string, any, any>[]> = {
+    status: 'success';
+    result: z.infer<TOutput>;
+    steps: {
+        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown, unknown, unknown, unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['inputSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['resumeSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['suspendSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+    };
+} | {
+    status: 'failed';
+    steps: {
+        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown, unknown, unknown, unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['inputSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['resumeSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['suspendSchema']>>, 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, unknown, unknown, unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['inputSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['resumeSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['suspendSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+    };
+    suspended: [string[], ...string[][]];
+};
+type WorkflowConfig<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]> = {
+    mastra?: Mastra;
+    id: TWorkflowId;
+    description?: string | undefined;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    executionEngine?: ExecutionEngine;
+    steps?: TSteps;
+    retryConfig?: {
+        attempts?: number;
+        delay?: number;
+    };
+};
+declare class Workflow<TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, 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 Step<TWorkflowId, TInput, TOutput> {
     #private;
-    name: TStepId;
-    triggerSchema?: TTriggerSchema;
-    resultSchema?: TResultSchema;
-    resultMapping?: Record<string, {
-        step: StepAction<string, any, any, any>;
-        path: string;
-    }>;
-    events?: Record<string, {
-        schema: z.ZodObject<any>;
-    }>;
-    isNested: boolean;
-    /**
-     * Creates a new LegacyWorkflow instance
-     * @param name - Identifier for the workflow (not necessarily unique)
-     * @param logger - Optional logger instance
-     */
-    constructor({ name, triggerSchema, result, retryConfig, mastra, events, }: WorkflowOptions<TStepId, TSteps, TTriggerSchema, TResultSchema>);
-    step<TWorkflow extends LegacyWorkflow<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(next: TWorkflow, config?: StepConfig<ReturnType<TWorkflow['toStep']>, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
-    step<TAgent extends Agent<any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(next: TAgent, config?: StepConfig<ReturnType<TAgent['toStep']>, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
-    step<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(step: TStep, config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
-    then<TStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TStep | TStep[], config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema>): this;
-    then<TWorkflow extends LegacyWorkflow<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TWorkflow | TWorkflow[], config?: StepConfig<StepAction<string, any, any, any>, CondStep, VarStep, TTriggerSchema>): this;
-    then<TAgent extends Agent<any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TAgent | TAgent[], config?: StepConfig<StepAction<string, any, any, any>, CondStep, VarStep, TTriggerSchema>): this;
-    private loop;
-    while<FallbackStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['when'], fallbackStep: FallbackStep, variables?: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['variables']): Pick<WorkflowBuilder<this>, "then" | "commit">;
-    until<FallbackStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['when'], fallbackStep: FallbackStep, variables?: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['variables']): Pick<WorkflowBuilder<this>, "then" | "commit">;
-    if<TStep extends StepAction<string, any, any, any>>(condition: StepConfig<TStep, any, any, TTriggerSchema>['when'], ifStep?: TStep | LegacyWorkflow, elseStep?: TStep | LegacyWorkflow): this | WorkflowBuilder<this>;
-    else(): WorkflowBuilder<this>;
-    after<TStep extends StepAction<string, any, any, any>>(steps: string | TStep | TStep[] | (TStep | string)[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
-    after<TWorkflow extends LegacyWorkflow<any, any, any, any>>(steps: TWorkflow | TWorkflow[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
-    after<TAgent extends Agent<any, any, any>>(steps: TAgent | TAgent[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
-    afterEvent(eventName: string): WorkflowBuilder<this>;
-    /**
-     * Executes the workflow with the given trigger data
-     * @param triggerData - Initial data to start the workflow with
-     * @returns Promise resolving to workflow results or rejecting with error
-     * @throws Error if trigger schema validation fails
+    id: TWorkflowId;
+    description?: string | undefined;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    steps: Record<string, Step<string, any, any, any, any>>;
+    stepDefs?: TSteps;
+    protected stepFlow: StepFlowEntry[];
+    protected serializedStepFlow: SerializedStepFlowEntry[];
+    protected executionEngine: ExecutionEngine;
+    protected executionGraph: ExecutionGraph;
+    protected retryConfig: {
+        attempts?: number;
+        delay?: number;
+    };
+    constructor({ mastra, id, inputSchema, outputSchema, description, executionEngine, retryConfig, steps, }: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>);
+    get runs(): Map<string, Run<TSteps, TInput, TOutput>>;
+    get mastra(): Mastra<Record<string, Agent<any, ToolsInput, Record<string, Metric>>>, Record<string, LegacyWorkflow<LegacyStep<string, any, any, StepExecutionContext<any, WorkflowContext<any, LegacyStep<string, any, any, any>[], Record<string, any>>>>[], string, any, any>>, Record<string, Workflow<Step<string, any, any, any, any>[], string, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>>>, Record<string, MastraVector>, Record<string, MastraTTS>, IMastraLogger, Record<string, AgentNetwork>, Record<string, MCPServerBase>> | undefined;
+    __registerMastra(mastra: Mastra): void;
+    __registerPrimitives(p: MastraPrimitives): void;
+    setStepFlow(stepFlow: StepFlowEntry[]): void;
+    /**
+     * Adds a step to the workflow
+     * @param step The step to add to the workflow
+     * @returns The workflow instance for chaining
      */
-    createRun({ runId, events, }?: {
-        runId?: string;
-        events?: Record<string, {
-            schema: z.ZodObject<any>;
-        }>;
-    }): WorkflowResultReturn<TResultSchema, TTriggerSchema, TSteps>;
+    then<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    map<TSteps extends Step<string, any, any>[], TMapping extends {
+        [K in keyof TMapping]: {
+            step: TSteps[number] | 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;
+        } | DynamicMapping<TPrevSchema, z.ZodTypeAny>;
+    }>(mappingConfig: TMapping | ExecuteFunction<z.infer<TPrevSchema>, any, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, any>;
+    parallel<TParallelSteps extends Step<string, TPrevSchema, any, any, any>[]>(steps: TParallelSteps): Workflow<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>,
+        Step<string, TPrevSchema, any, any, any>
+    ]>>(steps: TBranchSteps): Workflow<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: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    dountil<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): Workflow<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 ? Step<TStepId, TStepInputSchema, TSchemaOut, any, any> : 'Previous step must return an array type', opts?: {
+        concurrency: number;
+    }): Workflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodArray<TSchemaOut>>;
     /**
-     * Gets a workflow run instance by ID
-     * @param runId - ID of the run to retrieve
-     * @returns The workflow run instance if found, undefined otherwise
+     * Builds the execution graph for this workflow
+     * @returns The execution graph that can be used to execute the workflow
      */
-    getRun(runId: string): Promise<WorkflowRun | WorkflowInstance<TSteps, TTriggerSchema, any> | null>;
+    buildExecutionGraph(): ExecutionGraph;
     /**
-     * Gets a workflow run instance by ID, from memory
-     * @param runId - ID of the run to retrieve
-     * @returns The workflow run instance if found, undefined otherwise
+     * 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
      */
-    getMemoryRun(runId: string): WorkflowInstance<TSteps, TTriggerSchema, any> | undefined;
+    commit(): Workflow<TSteps, TWorkflowId, TInput, TOutput, TOutput>;
+    get stepGraph(): StepFlowEntry[];
+    get serializedStepGraph(): SerializedStepFlowEntry[];
     /**
-     * Rebuilds the machine with the current steps configuration and validates the workflow
-     *
-     * This is the last step of a workflow builder method chain
-     * @throws Error if validation fails
-     *
-     * @returns this instance for method chaining
+     * 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
      */
-    commit(): this;
+    createRun(options?: {
+        runId?: string;
+    }): Run<TSteps, TInput, TOutput>;
+    execute({ inputData, resumeData, suspend, resume, [EMITTER_SYMBOL]: emitter, mastra, runtimeContext, }: {
+        inputData: z.infer<TInput>;
+        resumeData?: any;
+        getStepResult<T extends Step<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_SYMBOL]: {
+            emit: (event: string, data: any) => void;
+        };
+        mastra: Mastra;
+        runtimeContext?: RuntimeContext;
+    }): Promise<z.infer<TOutput>>;
     getWorkflowRuns(args?: {
         fromDate?: Date;
         toDate?: Date;
         limit?: number;
         offset?: number;
         resourceId?: string;
-    }): Promise<LegacyWorkflowRuns>;
-    getExecutionSpan(runId: string): Span | undefined;
-    getState(runId: string): Promise<LegacyWorkflowRunState | null>;
-    resume({ runId, stepId, context: resumeContext, runtimeContext, }: {
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById(runId: string): Promise<WorkflowRun | null>;
+}
+/**
+ * Represents a workflow run that can be executed
+ */
+declare class Run<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>> {
+    #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;
-        stepId: string;
-        context?: Record<string, any>;
-        runtimeContext: RuntimeContext;
-    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
-    watch(onTransition: (state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
-    resumeWithEvent(runId: string, eventName: string, data: any): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
-    __registerMastra(mastra: Mastra): void;
-    __registerPrimitives(p: MastraPrimitives): void;
-    get stepGraph(): StepGraph;
-    get stepSubscriberGraph(): Record<string, StepGraph>;
-    get serializedStepGraph(): StepGraph;
-    get serializedStepSubscriberGraph(): Record<string, StepGraph>;
-    get steps(): Record<string, StepAction<string, any, any, any>>;
-    setNested(isNested: boolean): void;
-    toStep(): LegacyStep<TStepId, TTriggerSchema, z.ZodType<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
+        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>>;
+    /**
+     * Starts the workflow execution with the provided input as a stream
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    stream({ inputData, runtimeContext }?: {
+        inputData?: z.infer<TInput>;
+        runtimeContext?: RuntimeContext;
+    }): {
+        stream: ReadableStream<WatchEvent>;
+        getWorkflowState: () => Promise<WorkflowResult<TOutput, TSteps>>;
+    };
+    watch(cb: (event: WatchEvent) => void, type?: 'watch' | 'watch-v2'): () => void;
+    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>>;
+    /**
+     * 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 ExecuteFunction<TStepInput, TStepOutput, TResumeSchema, TSuspendSchema> = (params: {
-    mastra: Mastra;
-    runtimeContext: RuntimeContext;
-    inputData: TStepInput;
-    resumeData?: TResumeSchema;
-    getInitData<T extends z.ZodType<any>>(): z.infer<T>;
-    getInitData<T extends Workflow<any, any, any, any, any>>(): T extends undefined ? unknown : z.infer<NonNullable<T['inputSchema']>>;
-    getStepResult<T extends Step<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_SYMBOL]: {
-        emit: (event: string, data: any) => Promise<void>;
+interface StorageColumn {
+    type: 'text' | 'timestamp' | 'uuid' | 'jsonb' | 'integer' | 'bigint';
+    primaryKey?: boolean;
+    nullable?: boolean;
+    references?: {
+        table: string;
+        column: string;
     };
-}) => Promise<TStepOutput>;
-interface Step<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;
 }
+interface LegacyWorkflowRuns {
+    runs: LegacyWorkflowRun[];
+    total: number;
+}
+interface LegacyWorkflowRun {
+    workflowName: string;
+    runId: string;
+    snapshot: LegacyWorkflowRunState | string;
+    createdAt: Date;
+    updatedAt: Date;
+    resourceId?: string;
+}
+interface WorkflowRuns {
+    runs: WorkflowRun[];
+    total: number;
+}
+interface WorkflowRun {
+    workflowName: string;
+    runId: string;
+    snapshot: WorkflowRunState | string;
+    createdAt: Date;
+    updatedAt: Date;
+    resourceId?: string;
+}
+type StorageGetMessagesArg = {
+    threadId: string;
+    resourceId?: string;
+    selectBy?: {
+        vectorSearchString?: string;
+        last?: number | false;
+        include?: {
+            id: string;
+            withPreviousMessages?: number;
+            withNextMessages?: number;
+        }[];
+    };
+    threadConfig?: MemoryConfig;
+};
+type EvalRow = {
+    input: string;
+    output: string;
+    result: MetricResult;
+    agentName: string;
+    createdAt: string;
+    metricName: string;
+    instructions: string;
+    runId: string;
+    globalRunId: string;
+    testInfo?: TestInfo;
+};
 
-type StepSuccess<P, R, S, T> = {
-    status: 'success';
-    output: T;
-    payload: P;
-    resumePayload?: R;
-    suspendPayload?: S;
-    startedAt: number;
-    endedAt: number;
-    suspendedAt?: number;
-    resumedAt?: number;
+declare const TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
+declare const TABLE_EVALS = "mastra_evals";
+declare const TABLE_MESSAGES = "mastra_messages";
+declare const TABLE_THREADS = "mastra_threads";
+declare const TABLE_TRACES = "mastra_traces";
+type TABLE_NAMES = typeof TABLE_WORKFLOW_SNAPSHOT | typeof TABLE_EVALS | typeof TABLE_MESSAGES | typeof TABLE_THREADS | typeof TABLE_TRACES;
+declare const TABLE_SCHEMAS: Record<TABLE_NAMES, Record<string, StorageColumn>>;
+
+type MastraMessageV1 = {
+    id: string;
+    content: string | UserContent | AssistantContent | ToolContent;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    createdAt: Date;
+    threadId: string;
+    resourceId: string;
+    toolCallIds?: string[];
+    toolCallArgs?: Record<string, unknown>[];
+    toolNames?: string[];
+    type: 'text' | 'tool-call' | 'tool-result';
 };
-type StepFailure<P, R, S> = {
-    status: 'failed';
-    error: string | Error;
-    payload: P;
-    resumePayload?: R;
-    suspendPayload?: S;
-    startedAt: number;
-    endedAt: number;
-    suspendedAt?: number;
-    resumedAt?: number;
+type MessageType = MastraMessageV2 & {
+    threadId: string;
 };
-type StepSuspended<P, S> = {
-    status: 'suspended';
-    payload: P;
-    suspendPayload?: S;
-    startedAt: number;
-    suspendedAt: number;
+type StorageThreadType = {
+    id: string;
+    title?: string;
+    resourceId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, unknown>;
 };
-type StepRunning<P, R, S> = {
-    status: 'running';
-    payload: P;
-    resumePayload?: R;
-    suspendPayload?: S;
-    startedAt: number;
-    suspendedAt?: number;
-    resumedAt?: number;
+type MessageResponse<T extends 'raw' | 'core_message'> = {
+    raw: MastraMessageV1[];
+    core_message: CoreMessage$1[];
+}[T];
+type MemoryConfig = {
+    lastMessages?: number | false;
+    semanticRecall?: boolean | {
+        topK: number;
+        messageRange: number | {
+            before: number;
+            after: number;
+        };
+    };
+    workingMemory?: {
+        enabled: boolean;
+        template?: string;
+        /** @deprecated The `use` option has been removed. Working memory always uses tool-call mode. */
+        use?: never;
+    };
+    threads?: {
+        generateTitle?: boolean;
+    };
 };
-type StepResult<P, R, S, T> = StepSuccess<P, R, S, T> | StepFailure<P, R, S> | StepSuspended<P, S> | StepRunning<P, R, S>;
-type StepsRecord<T extends readonly Step<any, any, any>[]> = {
-    [K in T[number]['id']]: Extract<T[number], {
-        id: K;
-    }>;
+type SharedMemoryConfig = {
+    storage?: MastraStorage;
+    options?: MemoryConfig;
+    vector?: MastraVector | false;
+    embedder?: EmbeddingModel<string>;
+    processors?: MemoryProcessor[];
 };
-type DynamicMapping<TPrevSchema extends z.ZodTypeAny, TSchemaOut extends z.ZodTypeAny> = {
-    fn: ExecuteFunction<z.infer<TPrevSchema>, z.infer<TSchemaOut>, any, any>;
-    schema: TSchemaOut;
+
+type MastraMessageContentV2 = {
+    format: 2;
+    parts: UIMessage['parts'];
+    experimental_attachments?: UIMessage['experimental_attachments'];
+    content?: UIMessage['content'];
+    toolInvocations?: UIMessage['toolInvocations'];
+    reasoning?: UIMessage['reasoning'];
+    annotations?: UIMessage['annotations'];
 };
-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 Step<any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
-type VariableReference<TStep extends Step<string, any, any> = Step<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 MastraMessageV2 = {
+    id: string;
+    content: MastraMessageContentV2;
+    role: 'user' | 'assistant';
+    createdAt: Date;
+    threadId?: string;
+    resourceId?: string;
+    type?: string;
 };
-type WatchEvent = {
-    type: 'watch';
-    payload: {
-        currentStep?: {
-            id: string;
-            status: 'running' | 'success' | 'failed' | 'suspended';
-            output?: Record<string, any>;
-            resumePayload?: Record<string, any>;
-            payload?: Record<string, any>;
-            error?: string | Error;
+type MessageInput = UIMessage | Message | MastraMessageV1 | CoreMessage$1 | MastraMessageV2;
+type MessageSource = 'memory' | 'response' | 'user' | 'system';
+declare class MessageList {
+    private messages;
+    private systemMessages;
+    private taggedSystemMessages;
+    private memoryInfo;
+    private memoryMessages;
+    private newMessages;
+    private responseMessages;
+    private generateMessageId?;
+    constructor({ threadId, resourceId, generateMessageId, }?: {
+        threadId?: string;
+        resourceId?: string;
+        generateMessageId?: IDGenerator$1;
+    });
+    add(messages: string | string[] | MessageInput | MessageInput[], messageSource: MessageSource): this;
+    getLatestUserContent(): string | null;
+    get get(): {
+        all: {
+            mastra: () => MastraMessageV2[];
+            v1: () => MastraMessageV1[];
+            ui: () => UIMessage[];
+            core: () => CoreMessage$1[];
+            prompt: () => CoreMessage$1[];
         };
-        workflowState: {
-            status: 'running' | 'success' | 'failed' | 'suspended';
-            steps: Record<string, {
-                status: 'running' | 'success' | 'failed' | 'suspended';
-                output?: Record<string, any>;
-                payload?: Record<string, any>;
-                resumePayload?: Record<string, any>;
-                error?: string | Error;
-                startedAt: number;
-                endedAt: number;
-                suspendedAt?: number;
-                resumedAt?: number;
-            }>;
-            output?: Record<string, any>;
-            payload?: Record<string, any>;
-            error?: string | Error;
+        remembered: {
+            mastra: () => MastraMessageV2[];
+            v1: () => MastraMessageV1[];
+            ui: () => UIMessage[];
+            core: () => CoreMessage$1[];
+        };
+        input: {
+            mastra: () => MastraMessageV2[];
+            v1: () => MastraMessageV1[];
+            ui: () => UIMessage[];
+            core: () => CoreMessage$1[];
+        };
+        response: {
+            mastra: () => MastraMessageV2[];
         };
     };
-    eventTimestamp: Date;
+    private all;
+    private remembered;
+    private input;
+    private response;
+    drainUnsavedMessages(): MastraMessageV2[];
+    getSystemMessages(tag?: string): CoreMessage$1[];
+    addSystem(messages: CoreSystemMessage$1 | CoreSystemMessage$1[] | string | string[] | null, tag?: string): this;
+    private convertToCoreMessages;
+    private sanitizeUIMessages;
+    private addOneSystem;
+    private isDuplicateSystem;
+    private static toUIMessage;
+    private getMessageById;
+    private shouldReplaceMessage;
+    private addOne;
+    private inputToMastraMessageV2;
+    private lastCreatedAt?;
+    private generateCreatedAt;
+    private newMessageId;
+    private mastraMessageV1ToMastraMessageV2;
+    private hydrateMastraMessageV2Fields;
+    private vercelUIMessageToMastraMessageV2;
+    private vercelCoreMessageToMastraMessageV2;
+    static isVercelUIMessage(msg: MessageInput): msg is UIMessage;
+    static isVercelCoreMessage(msg: MessageInput): msg is CoreMessage$1;
+    static isMastraMessage(msg: MessageInput): msg is MastraMessageV2 | MastraMessageV1;
+    static isMastraMessageV1(msg: MessageInput): msg is MastraMessageV1;
+    static isMastraMessageV2(msg: MessageInput): msg is MastraMessageV2;
+    private static getRole;
+    private static cacheKeyFromParts;
+    private static coreContentToString;
+    private static cacheKeyFromContent;
+    private static messagesAreEqual;
+}
+
+type MemoryProcessorOpts = {
+    systemMessage?: string;
+    memorySystemMessage?: string;
+    newMessages?: CoreMessage$1[];
 };
-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;
-interface WorkflowRunState {
-    runId: string;
-    value: Record<string, string>;
-    context: {
-        input?: Record<string, any>;
-    } & Record<string, StepResult<any, any, any, any>>;
-    activePaths: Array<unknown>;
-    suspendedPaths: Record<string, number[]>;
-    timestamp: number;
+/**
+ * Interface for message processors that can filter or transform messages
+ * before they're sent to the LLM.
+ */
+declare abstract class MemoryProcessor extends MastraBase {
+    /**
+     * Process a list of messages and return a filtered or transformed list.
+     * @param messages The messages to process
+     * @returns The processed messages
+     */
+    process(messages: CoreMessage$1[], _opts: MemoryProcessorOpts): CoreMessage$1[];
+}
+declare const memoryDefaultOptions: {
+    lastMessages: number;
+    semanticRecall: false;
+    threads: {
+        generateTitle: false;
+    };
+    workingMemory: {
+        enabled: false;
+        template: string;
+    };
+};
+/**
+ * Abstract Memory class that defines the interface for storing and retrieving
+ * conversation threads and messages.
+ */
+declare abstract class MastraMemory extends MastraBase {
+    MAX_CONTEXT_TOKENS?: number;
+    protected _storage?: MastraStorage;
+    vector?: MastraVector;
+    embedder?: EmbeddingModel<string>;
+    private processors;
+    protected threadConfig: MemoryConfig;
+    constructor(config: {
+        name: string;
+    } & SharedMemoryConfig);
+    protected _hasOwnStorage: boolean;
+    get hasOwnStorage(): boolean;
+    get storage(): MastraStorage;
+    setStorage(storage: MastraStorage): void;
+    setVector(vector: MastraVector): void;
+    setEmbedder(embedder: EmbeddingModel<string>): void;
+    /**
+     * Get a system message to inject into the conversation.
+     * This will be called before each conversation turn.
+     * Implementations can override this to inject custom system messages.
+     */
+    getSystemMessage(_input: {
+        threadId: string;
+        memoryConfig?: MemoryConfig;
+    }): Promise<string | null>;
+    /**
+     * Get tools that should be available to the agent.
+     * This will be called when converting tools for the agent.
+     * Implementations can override this to provide additional tools.
+     */
+    getTools(_config?: MemoryConfig): Record<string, CoreTool>;
+    protected createEmbeddingIndex(dimensions?: number): Promise<{
+        indexName: string;
+    }>;
+    getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
+    /**
+     * Apply all configured message processors to a list of messages.
+     * @param messages The messages to process
+     * @returns The processed messages
+     */
+    private applyProcessors;
+    processMessages({ messages, processors, ...opts }: {
+        messages: CoreMessage$1[];
+        processors?: MemoryProcessor[];
+    } & MemoryProcessorOpts): CoreMessage$1[];
+    abstract rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
+        threadId: string;
+        resourceId?: string;
+        vectorMessageSearch?: string;
+        config?: MemoryConfig;
+    }): Promise<{
+        messages: MastraMessageV1[];
+        messagesV2: MastraMessageV2[];
+    }>;
+    estimateTokens(text: string): number;
+    /**
+     * Retrieves a specific thread by its ID
+     * @param threadId - The unique identifier of the thread
+     * @returns Promise resolving to the thread or null if not found
+     */
+    abstract getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    abstract getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    /**
+     * Saves or updates a thread
+     * @param thread - The thread data to save
+     * @returns Promise resolving to the saved thread
+     */
+    abstract saveThread({ thread, memoryConfig, }: {
+        thread: StorageThreadType;
+        memoryConfig?: MemoryConfig;
+    }): Promise<StorageThreadType>;
+    /**
+     * Saves messages to a thread
+     * @param messages - Array of messages to save
+     * @returns Promise resolving to the saved messages
+     */
+    abstract saveMessages({ messages, memoryConfig, }: {
+        messages: (MastraMessageV1 | MastraMessageV2)[];
+        memoryConfig: MemoryConfig | undefined;
+    }): Promise<MastraMessageV2[]>;
+    /**
+     * Retrieves all messages for a specific thread
+     * @param threadId - The unique identifier of the thread
+     * @returns Promise resolving to array of messages and uiMessages
+     */
+    abstract query({ threadId, resourceId, selectBy, }: StorageGetMessagesArg): Promise<{
+        messages: MastraMessageV1[];
+        uiMessages: UIMessage[];
+    }>;
+    /**
+     * Helper method to create a new thread
+     * @param title - Optional title for the thread
+     * @param metadata - Optional metadata for the thread
+     * @returns Promise resolving to the created thread
+     */
+    createThread({ threadId, resourceId, title, metadata, memoryConfig, }: {
+        resourceId: string;
+        threadId?: string;
+        title?: string;
+        metadata?: Record<string, unknown>;
+        memoryConfig?: MemoryConfig;
+    }): Promise<StorageThreadType>;
+    /**
+     * Helper method to delete a thread
+     * @param threadId - the id of the thread to delete
+     */
+    abstract deleteThread(threadId: string): Promise<void>;
+    /**
+     * Helper method to add a single message to a thread
+     * @param threadId - The thread to add the message to
+     * @param content - The message content
+     * @param role - The role of the message sender
+     * @param type - The type of the message
+     * @param toolNames - Optional array of tool names that were called
+     * @param toolCallArgs - Optional array of tool call arguments
+     * @param toolCallIds - Optional array of tool call ids
+     * @returns Promise resolving to the saved message
+     * @deprecated use saveMessages instead
+     */
+    addMessage({ threadId, resourceId, config, content, role, type, toolNames, toolCallArgs, toolCallIds, }: {
+        threadId: string;
+        resourceId: string;
+        config?: MemoryConfig;
+        content: UserContent | AssistantContent;
+        role: 'user' | 'assistant';
+        type: 'text' | 'tool-call' | 'tool-result';
+        toolNames?: string[];
+        toolCallArgs?: Record<string, unknown>[];
+        toolCallIds?: string[];
+    }): Promise<MastraMessageV1>;
+    /**
+     * Generates a unique identifier
+     * @returns A unique string ID
+     */
+    generateId(): string;
 }
 
-/**
- * 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;
+declare class MastraLLMBase extends MastraBase {
+    #private;
+    constructor({ name, model }: {
+        name: string;
+        model: LanguageModel$1;
     });
-    __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, any, any, any>>;
-            resumePayload: any;
-            resumePath: number[];
-        };
-        emitter: {
-            emit: (event: string, data: any) => Promise<void>;
-        };
-        runtimeContext: RuntimeContext;
-        retryConfig?: {
-            attempts?: number;
-            delay?: number;
-        };
-    }): Promise<TOutput>;
+    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>>;
 }
 
-type StepFlowEntry = {
-    type: 'step';
-    step: Step;
-} | {
-    type: 'parallel';
-    steps: StepFlowEntry[];
-} | {
-    type: 'conditional';
-    steps: StepFlowEntry[];
-    conditions: ExecuteFunction<any, any, any, any>[];
-    serializedConditions: {
-        id: string;
-        fn: string;
-    }[];
-} | {
-    type: 'loop';
-    step: Step;
-    condition: ExecuteFunction<any, any, any, any>;
-    serializedCondition: {
-        id: string;
-        fn: string;
-    };
-    loopType: 'dowhile' | 'dountil';
+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;
+type CoreAssistantMessage = CoreAssistantMessage$1;
+type CoreUserMessage = CoreUserMessage$1;
+type CoreToolMessage = CoreToolMessage$1;
+type EmbedResult<T> = EmbedResult$1<T>;
+type EmbedManyResult<T> = EmbedManyResult$1<T>;
+type BaseStructuredOutputType = 'string' | 'number' | 'boolean' | 'date';
+type StructuredOutputType = 'array' | 'string' | 'number' | 'object' | 'boolean' | 'date';
+type StructuredOutputArrayItem = {
+    type: BaseStructuredOutputType;
 } | {
-    type: 'foreach';
-    step: Step;
-    opts: {
-        concurrency: number;
-    };
-};
-type SerializedStep = Pick<Step, 'id' | 'description'> & {
-    component?: string;
-    serializedStepFlow?: SerializedStepFlowEntry[];
-    mapConfig?: string;
+    type: 'object';
+    items: StructuredOutput;
 };
-type SerializedStepFlowEntry = {
-    type: 'step';
-    step: SerializedStep;
-} | {
-    type: 'parallel';
-    steps: SerializedStepFlowEntry[];
-} | {
-    type: 'conditional';
-    steps: SerializedStepFlowEntry[];
-    serializedConditions: {
-        id: string;
-        fn: string;
-    }[];
-} | {
-    type: 'loop';
-    step: SerializedStep;
-    serializedCondition: {
-        id: string;
-        fn: string;
-    };
-    loopType: 'dowhile' | 'dountil';
-} | {
-    type: 'foreach';
-    step: SerializedStep;
-    opts: {
-        concurrency: number;
+type StructuredOutput = {
+    [key: string]: {
+        type: BaseStructuredOutputType;
+    } | {
+        type: 'object';
+        items: StructuredOutput;
+    } | {
+        type: 'array';
+        items: StructuredOutputArrayItem;
     };
 };
-/**
- * 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>>;
-}): Step<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>): Step<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>;
-}): Step<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>>;
-declare function cloneStep<TStepId extends string>(step: Step<string, any, any>, opts: {
-    id: TStepId;
-}): Step<TStepId, 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 Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]>(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TInput>;
-declare function cloneWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]>(workflow: Workflow<TSteps, string, TInput, TOutput>, opts: {
-    id: TWorkflowId;
-}): Workflow<TSteps, TWorkflowId, TInput, TOutput>;
-type WorkflowResult<TOutput extends z.ZodType<any>, TSteps extends Step<string, any, any>[]> = {
-    status: 'success';
-    result: z.infer<TOutput>;
-    steps: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown, unknown, unknown, unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['inputSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['resumeSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['suspendSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+type GenerateReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>;
+type StreamReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>;
+type OutputType = StructuredOutput | ZodSchema | JSONSchema7 | undefined;
+type GenerateTextOptions = Parameters<typeof generateText>[0];
+type StreamTextOptions = Parameters<typeof streamText>[0];
+type GenerateObjectOptions = Parameters<typeof generateObject>[0];
+type StreamObjectOptions = Parameters<typeof streamObject>[0];
+type MastraCustomLLMOptionsKeys = 'messages' | 'tools' | 'model' | 'onStepFinish' | 'experimental_output' | 'experimental_telemetry' | 'messages' | 'onFinish' | 'output';
+type DefaultLLMTextOptions = Omit<GenerateTextOptions, MastraCustomLLMOptionsKeys>;
+type DefaultLLMTextObjectOptions = Omit<GenerateObjectOptions, MastraCustomLLMOptionsKeys>;
+type DefaultLLMStreamOptions = Omit<StreamTextOptions, MastraCustomLLMOptionsKeys>;
+type DefaultLLMStreamObjectOptions = Omit<StreamObjectOptions, MastraCustomLLMOptionsKeys>;
+type MastraCustomLLMOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    tools?: Record<string, CoreTool>;
+    onStepFinish?: (step: unknown) => Promise<void> | void;
+    experimental_output?: Z;
+    telemetry?: TelemetrySettings;
+    threadId?: string;
+    resourceId?: string;
+    runtimeContext: RuntimeContext;
+} & Run$1;
+type LLMTextOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    messages: UIMessage[] | CoreMessage[];
+} & MastraCustomLLMOptions<Z> & DefaultLLMTextOptions;
+type LLMTextObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = LLMTextOptions<T> & DefaultLLMTextObjectOptions & {
+    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
+};
+type LLMStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    output?: OutputType | Z;
+    onFinish?: (result: string) => Promise<void> | void;
+} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
+type LLMInnerStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    messages: UIMessage[] | CoreMessage[];
+    onFinish?: (result: string) => Promise<void> | void;
+} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
+type LLMStreamObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
+} & LLMInnerStreamOptions<T> & DefaultLLMStreamObjectOptions;
+
+type VoiceEventType = 'speaking' | 'writing' | 'error' | string;
+interface VoiceEventMap {
+    speaker: NodeJS.ReadableStream;
+    speaking: {
+        audio?: string;
     };
-} | {
-    status: 'failed';
-    steps: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown, unknown, unknown, unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['inputSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['resumeSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['suspendSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+    writing: {
+        text: string;
+        role: 'assistant' | 'user';
     };
-    error: Error;
-} | {
-    status: 'suspended';
-    steps: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown, unknown, unknown, unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['inputSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['resumeSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['suspendSchema']>>, z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
+    error: {
+        message: string;
+        code?: string;
+        details?: unknown;
     };
-    suspended: [string[], ...string[][]];
-};
-type WorkflowConfig<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]> = {
-    mastra?: Mastra;
-    id: TWorkflowId;
-    description?: string | undefined;
-    inputSchema: TInput;
-    outputSchema: TOutput;
-    executionEngine?: ExecutionEngine;
-    steps?: TSteps;
-    retryConfig?: {
-        attempts?: number;
-        delay?: number;
+    [key: string]: unknown;
+}
+interface BuiltInModelConfig {
+    name: string;
+    apiKey?: string;
+}
+interface VoiceConfig<T = unknown> {
+    listeningModel?: BuiltInModelConfig;
+    speechModel?: BuiltInModelConfig;
+    speaker?: string;
+    name?: string;
+    realtimeConfig?: {
+        model?: string;
+        apiKey?: string;
+        options?: T;
     };
-};
-declare class Workflow<TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, 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 Step<TWorkflowId, TInput, TOutput> {
-    #private;
-    id: TWorkflowId;
-    description?: string | undefined;
-    inputSchema: TInput;
-    outputSchema: TOutput;
-    steps: Record<string, Step<string, any, any, any, any>>;
-    stepDefs?: TSteps;
-    protected stepFlow: StepFlowEntry[];
-    protected serializedStepFlow: SerializedStepFlowEntry[];
-    protected executionEngine: ExecutionEngine;
-    protected executionGraph: ExecutionGraph;
-    protected retryConfig: {
-        attempts?: number;
-        delay?: number;
+}
+declare abstract class MastraVoice<TOptions = unknown, TSpeakOptions = unknown, TListenOptions = unknown, TTools extends ToolsInput = ToolsInput, TEventArgs extends VoiceEventMap = VoiceEventMap, TSpeakerMetadata = unknown> extends MastraBase {
+    protected listeningModel?: BuiltInModelConfig;
+    protected speechModel?: BuiltInModelConfig;
+    protected speaker?: string;
+    protected realtimeConfig?: {
+        model?: string;
+        apiKey?: string;
+        options?: TOptions;
     };
-    constructor({ mastra, id, inputSchema, outputSchema, description, executionEngine, retryConfig, steps, }: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>);
-    get runs(): Map<string, Run<TSteps, TInput, TOutput>>;
-    get mastra(): Mastra<Record<string, Agent<any, ToolsInput, Record<string, Metric>>>, Record<string, LegacyWorkflow<LegacyStep<string, any, any, StepExecutionContext<any, WorkflowContext<any, LegacyStep<string, any, any, any>[], Record<string, any>>>>[], string, any, any>>, Record<string, Workflow<Step<string, any, any, any, any>[], string, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>>>, Record<string, MastraVector>, Record<string, MastraTTS>, IMastraLogger, Record<string, AgentNetwork>, Record<string, MCPServerBase>> | undefined;
-    __registerMastra(mastra: Mastra): void;
-    __registerPrimitives(p: MastraPrimitives): void;
-    setStepFlow(stepFlow: StepFlowEntry[]): void;
+    constructor({ listeningModel, speechModel, speaker, realtimeConfig, name }?: VoiceConfig<TOptions>);
+    traced<T extends Function>(method: T, methodName: string): T;
     /**
-     * Adds a step to the workflow
-     * @param step The step to add to the workflow
-     * @returns The workflow instance for chaining
+     * Convert text to speech
+     * @param input Text or text stream to convert to speech
+     * @param options Speech options including speaker and provider-specific options
+     * @returns Audio stream
      */
-    then<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
-    map<TSteps extends Step<string, any, any>[], TMapping extends {
-        [K in keyof TMapping]: {
-            step: TSteps[number] | 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;
-        } | DynamicMapping<TPrevSchema, z.ZodTypeAny>;
-    }>(mappingConfig: TMapping | ExecuteFunction<z.infer<TPrevSchema>, any, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, any>;
-    parallel<TParallelSteps extends Step<string, TPrevSchema, any, any, any>[]>(steps: TParallelSteps): Workflow<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>,
-        Step<string, TPrevSchema, any, any, any>
-    ]>>(steps: TBranchSteps): Workflow<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: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
-    dountil<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): Workflow<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 ? Step<TStepId, TStepInputSchema, TSchemaOut, any, any> : 'Previous step must return an array type', opts?: {
-        concurrency: number;
-    }): Workflow<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
+     * Convert text to speech
+     * @param input Text or text stream to convert to speech
+     * @param options Speech options including speaker and provider-specific options
+     * @returns Audio stream or void if in chat mode
      */
-    buildExecutionGraph(): ExecutionGraph;
+    abstract speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+    } & TSpeakOptions): Promise<NodeJS.ReadableStream | void>;
     /**
-     * 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
+     * Convert speech to text
+     * @param audioStream Audio stream to transcribe
+     * @param options Provider-specific transcription options
+     * @returns Text or text stream
      */
-    commit(): Workflow<TSteps, TWorkflowId, TInput, TOutput, TOutput>;
-    get stepGraph(): StepFlowEntry[];
-    get serializedStepGraph(): SerializedStepFlowEntry[];
     /**
-     * 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
+     * Convert speech to text
+     * @param audioStream Audio stream to transcribe
+     * @param options Provider-specific transcription options
+     * @returns Text, text stream, or void if in chat mode
      */
-    createRun(options?: {
-        runId?: string;
-    }): Run<TSteps, TInput, TOutput>;
-    execute({ inputData, resumeData, suspend, resume, [EMITTER_SYMBOL]: emitter, mastra, runtimeContext, }: {
-        inputData: z.infer<TInput>;
-        resumeData?: any;
-        getStepResult<T extends Step<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_SYMBOL]: {
-            emit: (event: string, data: any) => void;
-        };
-        mastra: Mastra;
-        runtimeContext?: RuntimeContext;
-    }): Promise<z.infer<TOutput>>;
-    getWorkflowRuns(args?: {
-        fromDate?: Date;
-        toDate?: Date;
-        limit?: number;
-        offset?: number;
-        resourceId?: string;
-    }): Promise<WorkflowRuns>;
-    getWorkflowRunById(runId: string): Promise<WorkflowRun | null>;
+    abstract listen(audioStream: NodeJS.ReadableStream | unknown, // Allow other audio input types for OpenAI realtime API
+    options?: TListenOptions): Promise<string | NodeJS.ReadableStream | void>;
+    updateConfig(_options: Record<string, unknown>): void;
+    /**
+     * Initializes a WebSocket or WebRTC connection for real-time communication
+     * @returns Promise that resolves when the connection is established
+     */
+    connect(_options?: Record<string, unknown>): Promise<void>;
+    /**
+     * Relay audio data to the voice provider for real-time processing
+     * @param audioData Audio data to relay
+     */
+    send(_audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
+    /**
+     * Trigger voice providers to respond
+     */
+    answer(_options?: Record<string, unknown>): Promise<void>;
+    /**
+     * Equip the voice provider with instructions
+     * @param instructions Instructions to add
+     */
+    addInstructions(_instructions?: string): void;
+    /**
+     * Equip the voice provider with tools
+     * @param tools Array of tools to add
+     */
+    addTools(_tools: TTools): void;
+    /**
+     * Disconnect from the WebSocket or WebRTC connection
+     */
+    close(): void;
+    /**
+     * Register an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function that receives event data
+     */
+    on<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
+    /**
+     * Remove an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function to remove
+     */
+    off<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
+    /**
+     * Get available speakers/voices
+     * @returns Array of available voice IDs and their metadata
+     */
+    getSpeakers(): Promise<Array<{
+        voiceId: string;
+    } & TSpeakerMetadata>>;
 }
-/**
- * Represents a workflow run that can be executed
- */
-declare class Run<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>> {
-    #private;
-    protected emitter: EventEmitter$1;
+
+declare class CompositeVoice extends MastraVoice<unknown, unknown, unknown, ToolsInput, VoiceEventMap> {
+    protected speakProvider?: MastraVoice;
+    protected listenProvider?: MastraVoice;
+    protected realtimeProvider?: MastraVoice;
+    constructor({ input, output, realtime, speakProvider, listenProvider, realtimeProvider, }: {
+        /** @deprecated use output instead */
+        speakProvider?: MastraVoice;
+        /** @deprecated use input instead */
+        listenProvider?: MastraVoice;
+        /** @deprecated use realtime instead */
+        realtimeProvider?: MastraVoice;
+        input?: MastraVoice;
+        output?: MastraVoice;
+        realtime?: MastraVoice;
+    });
     /**
-     * Unique identifier for this workflow
+     * Convert text to speech using the configured provider
+     * @param input Text or text stream to convert to speech
+     * @param options Speech options including speaker and provider-specific options
+     * @returns Audio stream or void if in realtime mode
      */
-    readonly workflowId: string;
+    speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+    } & any): Promise<NodeJS.ReadableStream | void>;
+    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<string | void | NodeJS.ReadableStream>;
+    getSpeakers(): Promise<{
+        voiceId: string;
+    }[]>;
+    updateConfig(options: Record<string, unknown>): void;
     /**
-     * Unique identifier for this run
+     * Initializes a WebSocket or WebRTC connection for real-time communication
+     * @returns Promise that resolves when the connection is established
      */
-    readonly runId: string;
+    connect(options?: Record<string, unknown>): Promise<void>;
     /**
-     * Internal state of the workflow run
+     * Relay audio data to the voice provider for real-time processing
+     * @param audioData Audio data to send
      */
-    protected state: Record<string, any>;
+    send(audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
     /**
-     * The execution engine for this run
+     * Trigger voice providers to respond
      */
-    executionEngine: ExecutionEngine;
+    answer(options?: Record<string, unknown>): Promise<void>;
     /**
-     * The execution graph for this run
+     * Equip the voice provider with instructions
+     * @param instructions Instructions to add
      */
-    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;
-    });
+    addInstructions(instructions: string): 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
+     * Equip the voice provider with tools
+     * @param tools Array of tools to add
      */
-    start({ inputData, runtimeContext, }: {
-        inputData?: z.infer<TInput>;
-        runtimeContext?: RuntimeContext;
-    }): Promise<WorkflowResult<TOutput, TSteps>>;
+    addTools(tools: ToolsInput): void;
     /**
-     * Starts the workflow execution with the provided input as a stream
-     * @param input The input data for the workflow
-     * @returns A promise that resolves to the workflow output
+     * Disconnect from the WebSocket or WebRTC connection
      */
-    stream({ inputData, runtimeContext }?: {
-        inputData?: z.infer<TInput>;
-        runtimeContext?: RuntimeContext;
-    }): {
-        stream: ReadableStream<WatchEvent>;
-        getWorkflowState: () => Promise<WorkflowResult<TOutput, TSteps>>;
-    };
-    watch(cb: (event: WatchEvent) => void, type?: 'watch' | 'watch-v2'): () => void;
-    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>>;
+    close(): void;
     /**
-     * Returns the current state of the workflow run
-     * @returns The current state of the workflow run
+     * Register an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function that receives event data
      */
-    getState(): Record<string, any>;
-    updateState(state: Record<string, any>): void;
+    on<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
+    /**
+     * Remove an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function to remove
+     */
+    off<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
+}
+
+declare class DefaultVoice extends MastraVoice {
+    constructor();
+    speak(_input: string | NodeJS.ReadableStream): Promise<NodeJS.ReadableStream>;
+    listen(_input: string | NodeJS.ReadableStream): Promise<string>;
+    getSpeakers(): Promise<{
+        voiceId: string;
+    }[]>;
 }
 
 type ToolsInput = Record<string, ToolAction<any, any, any> | VercelTool>;
@@ -2223,6 +2437,7 @@ type ConvertedTool = {
     description?: string;
     parameters: InternalCoreTool['parameters'];
     execute: InternalCoreTool['execute'];
+    toolType?: MCPToolType;
 };
 interface MCPServerSSEOptionsBase {
     /**
@@ -2458,6 +2673,12 @@ interface ServerDetailInfo extends ServerInfo {
     /** Information about remote access points for this server. */
     remotes?: RemoteInfo[];
 }
+/**
+ * The type of tool registered with the MCP server.
+ * This is used to categorize tools in the MCP Server playground.
+ * If not specified, it defaults to a regular tool.
+ */
+type MCPToolType = 'agent' | 'workflow';
 
 /**
  * Abstract base class for MCP server implementations.
@@ -2854,6 +3075,7 @@ interface IAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined,
     execute?: (context: TContext, options?: TOptions) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
 }
 
+type IDGenerator = () => string;
 declare class Agent<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> extends MastraBase {
     #private;
     id: TAgentId;
@@ -2909,46 +3131,28 @@ declare class Agent<TAgentId extends string = string, TTools extends ToolsInput
      */
     __setTools(tools: TTools): void;
     generateTitleFromUserMessage({ message, runtimeContext, }: {
-        message: CoreUserMessage$1;
+        message: UIMessage;
         runtimeContext?: RuntimeContext;
     }): Promise<string>;
-    getMostRecentUserMessage(messages: Array<CoreMessage$1>): CoreUserMessage$1 | undefined;
-    genTitle(userMessage: CoreUserMessage$1 | undefined): Promise<string>;
-    fetchMemory({ threadId, thread: passedThread, memoryConfig, resourceId, userMessages, systemMessage, runId, }: {
+    getMostRecentUserMessage(messages: Array<UIMessage>): UIMessage | undefined;
+    genTitle(userMessage: UIMessage | undefined): Promise<string>;
+    fetchMemory({ threadId, thread: passedThread, memoryConfig, resourceId, runId, messageList, }: {
         resourceId: string;
         threadId: string;
         thread?: StorageThreadType;
         memoryConfig?: MemoryConfig;
-        userMessages: CoreMessage$1[];
-        systemMessage: CoreMessage$1;
-        time?: Date;
-        keyword?: string;
         runId?: string;
+        messageList: MessageList;
     }): Promise<{
         threadId: string;
-        messages: CoreMessage$1[];
     }>;
-    private getResponseMessages;
-    sanitizeResponseMessages(messages: Array<CoreMessage$1>): Array<CoreMessage$1>;
     private getMemoryTools;
     private getAssignedTools;
     private getToolsets;
     private getClientTools;
     private getWorkflowTools;
     private convertTools;
-    preExecute({ resourceId, runId, threadId, thread, memoryConfig, messages, systemMessage, }: {
-        runId?: string;
-        threadId: string;
-        thread?: StorageThreadType;
-        memoryConfig?: MemoryConfig;
-        messages: CoreMessage$1[];
-        resourceId: string;
-        systemMessage: CoreMessage$1;
-    }): Promise<{
-        coreMessages: CoreMessage$1[];
-        threadIdToUse: string;
-    }>;
-    __primitive({ instructions, messages, context, threadId, memoryConfig, resourceId, runId, toolsets, clientTools, runtimeContext, }: {
+    __primitive({ instructions, messages, context, threadId, memoryConfig, resourceId, runId, toolsets, clientTools, runtimeContext, generateMessageId, }: {
         instructions?: string;
         toolsets?: ToolsetsInput;
         clientTools?: ToolsInput;
@@ -2957,23 +3161,31 @@ declare class Agent<TAgentId extends string = string, TTools extends ToolsInput
         memoryConfig?: MemoryConfig;
         context?: CoreMessage$1[];
         runId?: string;
-        messages: CoreMessage$1[];
+        messages: string | string[] | CoreMessage$1[] | Message[];
         runtimeContext: RuntimeContext;
+        generateMessageId: undefined | IDGenerator;
     }): {
         before: () => Promise<{
             messageObjects: CoreMessage$1[];
+            convertedTools: Record<string, CoreTool>;
+            messageList: MessageList;
+            threadId?: undefined;
+            thread?: undefined;
+        } | {
             convertedTools: Record<string, CoreTool>;
             threadId: string;
-            thread: StorageThreadType | null | undefined;
+            thread: StorageThreadType;
+            messageList: MessageList;
+            messageObjects: CoreMessage$1[];
         }>;
-        after: ({ result, thread: threadAfter, threadId, memoryConfig, outputText, runId, experimental_generateMessageId, }: {
+        after: ({ result, thread: threadAfter, threadId, memoryConfig, outputText, runId, messageList, }: {
             runId: string;
             result: Record<string, any>;
             thread: StorageThreadType | null | undefined;
-            threadId: string;
+            threadId?: string;
             memoryConfig: MemoryConfig | undefined;
             outputText: string;
-            experimental_generateMessageId: any;
+            messageList: MessageList;
         }) => Promise<void>;
     };
     generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[] | Message[], args?: AgentGenerateOptions<Z> & {
@@ -3041,125 +3253,6 @@ declare class Agent<TAgentId extends string = string, TTools extends ToolsInput
     }>, any>;
 }
 
-interface StorageColumn {
-    type: 'text' | 'timestamp' | 'uuid' | 'jsonb' | 'integer' | 'bigint';
-    primaryKey?: boolean;
-    nullable?: boolean;
-    references?: {
-        table: string;
-        column: string;
-    };
-}
-interface LegacyWorkflowRuns {
-    runs: LegacyWorkflowRun[];
-    total: number;
-}
-interface LegacyWorkflowRun {
-    workflowName: string;
-    runId: string;
-    snapshot: LegacyWorkflowRunState | string;
-    createdAt: Date;
-    updatedAt: Date;
-    resourceId?: string;
-}
-interface WorkflowRuns {
-    runs: WorkflowRun[];
-    total: number;
-}
-interface WorkflowRun {
-    workflowName: string;
-    runId: string;
-    snapshot: WorkflowRunState | string;
-    createdAt: Date;
-    updatedAt: Date;
-    resourceId?: string;
-}
-type StorageGetMessagesArg = {
-    threadId: string;
-    resourceId?: string;
-    selectBy?: {
-        vectorSearchString?: string;
-        last?: number | false;
-        include?: {
-            id: string;
-            withPreviousMessages?: number;
-            withNextMessages?: number;
-        }[];
-    };
-    threadConfig?: MemoryConfig;
-};
-type EvalRow = {
-    input: string;
-    output: string;
-    result: MetricResult;
-    agentName: string;
-    createdAt: string;
-    metricName: string;
-    instructions: string;
-    runId: string;
-    globalRunId: string;
-    testInfo?: TestInfo;
-};
-
-declare const TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
-declare const TABLE_EVALS = "mastra_evals";
-declare const TABLE_MESSAGES = "mastra_messages";
-declare const TABLE_THREADS = "mastra_threads";
-declare const TABLE_TRACES = "mastra_traces";
-type TABLE_NAMES = typeof TABLE_WORKFLOW_SNAPSHOT | typeof TABLE_EVALS | typeof TABLE_MESSAGES | typeof TABLE_THREADS | typeof TABLE_TRACES;
-declare const TABLE_SCHEMAS: Record<TABLE_NAMES, Record<string, StorageColumn>>;
-
-type MessageType = {
-    id: string;
-    content: UserContent | AssistantContent | ToolContent;
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    createdAt: Date;
-    threadId: string;
-    resourceId: string;
-    toolCallIds?: string[];
-    toolCallArgs?: Record<string, unknown>[];
-    toolNames?: string[];
-    type: 'text' | 'tool-call' | 'tool-result';
-};
-type StorageThreadType = {
-    id: string;
-    title?: string;
-    resourceId: string;
-    createdAt: Date;
-    updatedAt: Date;
-    metadata?: Record<string, unknown>;
-};
-type MessageResponse<T extends 'raw' | 'core_message'> = {
-    raw: MessageType[];
-    core_message: CoreMessage$1[];
-}[T];
-type MemoryConfig = {
-    lastMessages?: number | false;
-    semanticRecall?: boolean | {
-        topK: number;
-        messageRange: number | {
-            before: number;
-            after: number;
-        };
-    };
-    workingMemory?: {
-        enabled: boolean;
-        template?: string;
-        /** @deprecated The `use` option has been removed. Working memory always uses tool-call mode. */
-        use?: never;
-    };
-    threads?: {
-        generateTitle?: boolean;
-    };
-};
-type SharedMemoryConfig = {
-    storage?: MastraStorage;
-    options?: MemoryConfig;
-    vector?: MastraVector | false;
-    embedder?: EmbeddingModel<string>;
-    processors?: MemoryProcessor[];
-};
-
 declare abstract class MastraStorage extends MastraBase {
     /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
     static readonly TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
@@ -3215,10 +3308,10 @@ declare abstract class MastraStorage extends MastraBase {
     abstract deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    abstract getMessages({ threadId, selectBy, threadConfig }: StorageGetMessagesArg): Promise<MessageType[]>;
+    abstract getMessages({ threadId, selectBy, threadConfig }: StorageGetMessagesArg): Promise<MastraMessageV2[]>;
     abstract saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
+        messages: (MastraMessageV1 | MastraMessageV2)[];
+    }): Promise<MastraMessageV2[]>;
     abstract getTraces({ name, scope, page, perPage, attributes, filters, }: {
         name?: string;
         scope?: string;
@@ -3254,4 +3347,4 @@ declare abstract class MastraStorage extends MastraBase {
     }): Promise<WorkflowRun | null>;
 }
 
-export { type WorkflowActions as $, type ApiRoute as A, type StepGraph as B, type ContextWithMastra as C, type BaseCondition as D, type EvalRow as E, type ActionContext as F, WhenConditionReturnValue as G, type StepDef as H, type StepCondition as I, type StepConfig as J, type StepsRecord$1 as K, type LegacyWorkflowRuns as L, type Methods as M, type WorkflowLogMessage as N, type WorkflowEvent as O, type ResolverFunctionInput as P, type ResolverFunctionOutput as Q, type RetryConfig as R, type StorageColumn as S, type TABLE_NAMES as T, type SubscriberFunctionOutput as U, type VariableReference$1 as V, type WorkflowRuns as W, type DependencyCheckOutput as X, type StepResolverOutput as Y, type WorkflowActors as Z, type WorkflowActionParams as _, Mastra as a, ExecutionEngine as a$, type LegacyWorkflowState as a0, type StepId as a1, type ExtractSchemaFromStep$1 as a2, type ExtractStepResult as a3, type StepInputType as a4, type ExtractSchemaType$1 as a5, type PathsToStringProps$1 as a6, type LegacyWorkflowRunState as a7, type WorkflowResumeResult as a8, type ToolAction as a9, type LLMTextOptions as aA, type LLMTextObjectOptions as aB, type LLMStreamOptions as aC, type LLMInnerStreamOptions as aD, type LLMStreamObjectOptions as aE, createMockModel as aF, type Config as aG, type MessageResponse as aH, type MemoryConfig as aI, type SharedMemoryConfig as aJ, type MemoryProcessorOpts as aK, MemoryProcessor as aL, memoryDefaultOptions as aM, createTool as aN, type VercelTool as aO, type CoreTool as aP, type InternalCoreTool as aQ, type StepFlowEntry as aR, type SerializedStep as aS, type SerializedStepFlowEntry as aT, createStep as aU, cloneStep as aV, createWorkflow as aW, cloneWorkflow as aX, type WorkflowResult as aY, Run as aZ, type ExecutionGraph as a_, type AgentConfig as aa, MastraMemory as ab, type ToolExecutionContext as ac, Tool as ad, type Step as ae, Workflow as af, type WorkflowConfig as ag, type LanguageModel as ah, type CoreMessage as ai, type CoreSystemMessage as aj, type CoreAssistantMessage as ak, type CoreUserMessage as al, type CoreToolMessage as am, type EmbedResult as an, type EmbedManyResult as ao, type BaseStructuredOutputType as ap, type StructuredOutputType as aq, type StructuredOutputArrayItem as ar, type StructuredOutput as as, type GenerateReturn as at, type StreamReturn as au, type OutputType as av, type DefaultLLMTextOptions as aw, type DefaultLLMTextObjectOptions as ax, type DefaultLLMStreamOptions as ay, type DefaultLLMStreamObjectOptions as az, type MastraAuthConfig as b, type ExecuteFunction as b0, type StepSuccess as b1, type StepFailure as b2, type StepSuspended as b3, type StepRunning as b4, type StepResult as b5, type StepsRecord as b6, type DynamicMapping as b7, type PathsToStringProps as b8, type ExtractSchemaType as b9, type CommandInfo as bA, type EnvironmentVariableInfo as bB, type PackageInfo as bC, type RemoteInfo as bD, type MCPServerConfig as bE, type ServerInfo as bF, type ServerDetailInfo as bG, type ToolsetsInput as bH, type DynamicArgument as bI, type AgentGenerateOptions as bJ, type AgentStreamOptions as bK, type ExtractSchemaFromStep as ba, type VariableReference as bb, type WatchEvent as bc, type ZodPathType as bd, type WorkflowRunState as be, type MastraLanguageModel as bf, type MastraPrimitives as bg, AgentNetwork as bh, MCPServerBase as bi, type VoiceEventType as bj, type VoiceEventMap as bk, type VoiceConfig as bl, MastraVoice as bm, CompositeVoice as bn, DefaultVoice as bo, type AgentNetworkConfig as bp, type ConvertedTool as bq, type MCPServerSSEOptions as br, type MCPServerHonoSSEOptions as bs, type MCPServerHTTPOptions as bt, type Repository as bu, type VersionDetail as bv, type ArgumentInfo as bw, type PositionalArgumentInfo as bx, type NamedArgumentInfo as by, type SubcommandInfo as bz, MastraStorage as c, type StorageThreadType as d, type MessageType as e, type StorageGetMessagesArg as f, type WorkflowRun as g, type LegacyWorkflowRun as h, TABLE_WORKFLOW_SNAPSHOT as i, TABLE_EVALS as j, TABLE_MESSAGES as k, TABLE_THREADS as l, TABLE_TRACES as m, TABLE_SCHEMAS as n, type StepResult$1 as o, LegacyStep as p, LegacyWorkflow as q, Agent as r, type WorkflowContext as s, type ToolsInput as t, type StepAction as u, type LegacyWorkflowRunResult as v, type WorkflowOptions as w, type StepExecutionContext as x, type StepVariableType as y, type StepNode as z };
+export { type WorkflowActions as $, type ApiRoute as A, type StepGraph as B, type ContextWithMastra as C, type BaseCondition as D, type EvalRow as E, type ActionContext as F, WhenConditionReturnValue as G, type StepDef as H, type StepCondition as I, type StepConfig as J, type StepsRecord$1 as K, type LegacyWorkflowRuns as L, type Methods as M, type WorkflowLogMessage as N, type WorkflowEvent as O, type ResolverFunctionInput as P, type ResolverFunctionOutput as Q, type RetryConfig as R, type StorageColumn as S, type TABLE_NAMES as T, type SubscriberFunctionOutput as U, type VariableReference$1 as V, type WorkflowRuns as W, type DependencyCheckOutput as X, type StepResolverOutput as Y, type WorkflowActors as Z, type WorkflowActionParams as _, Mastra as a, Run as a$, type LegacyWorkflowState as a0, type StepId as a1, type ExtractSchemaFromStep$1 as a2, type ExtractStepResult as a3, type StepInputType as a4, type ExtractSchemaType$1 as a5, type PathsToStringProps$1 as a6, type LegacyWorkflowRunState as a7, type WorkflowResumeResult as a8, type ToolAction as a9, type LLMTextOptions as aA, type LLMTextObjectOptions as aB, type LLMStreamOptions as aC, type LLMInnerStreamOptions as aD, type LLMStreamObjectOptions as aE, createMockModel as aF, type Config as aG, type MastraMessageV1 as aH, type MessageType as aI, type MessageResponse as aJ, type MemoryConfig as aK, type SharedMemoryConfig as aL, type MemoryProcessorOpts as aM, MemoryProcessor as aN, memoryDefaultOptions as aO, createTool as aP, type VercelTool as aQ, type CoreTool as aR, type InternalCoreTool as aS, type StepFlowEntry as aT, type SerializedStep as aU, type SerializedStepFlowEntry as aV, createStep as aW, cloneStep as aX, createWorkflow as aY, cloneWorkflow as aZ, type WorkflowResult as a_, type AgentConfig as aa, MastraMemory as ab, type ToolExecutionContext as ac, Tool as ad, type Step as ae, Workflow as af, type WorkflowConfig as ag, type LanguageModel as ah, type CoreMessage as ai, type CoreSystemMessage as aj, type CoreAssistantMessage as ak, type CoreUserMessage as al, type CoreToolMessage as am, type EmbedResult as an, type EmbedManyResult as ao, type BaseStructuredOutputType as ap, type StructuredOutputType as aq, type StructuredOutputArrayItem as ar, type StructuredOutput as as, type GenerateReturn as at, type StreamReturn as au, type OutputType as av, type DefaultLLMTextOptions as aw, type DefaultLLMTextObjectOptions as ax, type DefaultLLMStreamOptions as ay, type DefaultLLMStreamObjectOptions as az, type MastraAuthConfig as b, type ExecutionGraph as b0, ExecutionEngine as b1, type ExecuteFunction as b2, type StepSuccess as b3, type StepFailure as b4, type StepSuspended as b5, type StepRunning as b6, type StepResult as b7, type StepsRecord as b8, type DynamicMapping as b9, type NamedArgumentInfo as bA, type SubcommandInfo as bB, type CommandInfo as bC, type EnvironmentVariableInfo as bD, type PackageInfo as bE, type RemoteInfo as bF, type MCPServerConfig as bG, type ServerInfo as bH, type ServerDetailInfo as bI, type MCPToolType as bJ, MessageList as bK, type ToolsetsInput as bL, type DynamicArgument as bM, type AgentGenerateOptions as bN, type AgentStreamOptions as bO, type MastraMessageContentV2 as bP, type PathsToStringProps as ba, type ExtractSchemaType as bb, type ExtractSchemaFromStep as bc, type VariableReference as bd, type WatchEvent as be, type ZodPathType as bf, type WorkflowRunState as bg, type MastraLanguageModel as bh, type MastraPrimitives as bi, AgentNetwork as bj, MCPServerBase as bk, type VoiceEventType as bl, type VoiceEventMap as bm, type VoiceConfig as bn, MastraVoice as bo, CompositeVoice as bp, DefaultVoice as bq, type AgentNetworkConfig as br, type ConvertedTool as bs, type MCPServerSSEOptions as bt, type MCPServerHonoSSEOptions as bu, type MCPServerHTTPOptions as bv, type Repository as bw, type VersionDetail as bx, type ArgumentInfo as by, type PositionalArgumentInfo as bz, MastraStorage as c, type StorageThreadType as d, type MastraMessageV2 as e, type StorageGetMessagesArg as f, type WorkflowRun as g, type LegacyWorkflowRun as h, TABLE_WORKFLOW_SNAPSHOT as i, TABLE_EVALS as j, TABLE_MESSAGES as k, TABLE_THREADS as l, TABLE_TRACES as m, TABLE_SCHEMAS as n, type StepResult$1 as o, LegacyStep as p, LegacyWorkflow as q, Agent as r, type WorkflowContext as s, type ToolsInput as t, type StepAction as u, type LegacyWorkflowRunResult as v, type WorkflowOptions as w, type StepExecutionContext as x, type StepVariableType as y, type StepNode as z };