@mastra/core 0.7.0 → 0.8.0-alpha.2

package/dist/{base-C0wILuA9.d.cts → base-Dpt4tO56.d.cts}

@@ -1,11 +1,11 @@
 import * as ai from 'ai';
-import { Tool as Tool$1, ToolExecutionOptions, CoreMessage as CoreMessage$1, TelemetrySettings, generateText, generateObject, streamText, GenerateTextResult, GenerateObjectResult, streamObject, StreamTextResult, StreamObjectResult, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, EmbeddingModel, Message, UserContent, AssistantContent, LanguageModelV1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback, LanguageModel as LanguageModel$1, DeepPartial, ToolContent } from 'ai';
-import { M as MastraBase, T as Telemetry, O as OtelConfig } from './base-ObPJ-w8K.cjs';
-import { M as Metric, a as MetricResult, T as TestInfo } from './types-CwTG2XyQ.cjs';
+import { Tool as Tool$1, ToolExecutionOptions, LanguageModelV1, CoreMessage as CoreMessage$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, EmbeddingModel, Message, UserContent, AssistantContent, TelemetrySettings, generateText, generateObject, streamText, streamObject, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback, LanguageModel as LanguageModel$1, DeepPartial, ToolContent } from 'ai';
+import { M as MastraBase, T as Telemetry, O as OtelConfig } from './base-CvQbEqGB.cjs';
+import { a as Metric, M as MetricResult, T as TestInfo } from './types-BtMyV38I.cjs';
 import { Query } from 'sift';
 import { z, ZodSchema } from 'zod';
 import { JSONSchema7 } from 'json-schema';
-import { d as Run, B as BaseLogMessage, R as RegisteredLogger, L as Logger } from './index-CquI0inB.cjs';
+import { B as BaseLogMessage, R as RegisteredLogger, L as Logger, d as Run } from './index-CquI0inB.cjs';
 import { Span } from '@opentelemetry/api';
 import * as xstate from 'xstate';
 import { Snapshot } from 'xstate';
@@ -13,6 +13,8 @@ import EventEmitter from 'node:events';
 import { MastraVector } from './vector/index.cjs';
 import { MastraTTS } from './tts/index.cjs';
 import { MastraDeployer } from './deployer/index.cjs';
+import { Handler, MiddlewareHandler } from 'hono';
+import { DescribeRouteOptions } from 'hono-openapi';
 
 type VercelTool = Tool$1;
 type CoreTool = {
@@ -48,670 +50,309 @@ declare class Tool<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchem
 }
 declare function createTool<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>>(opts: ToolAction<TSchemaIn, TSchemaOut, TContext>): Tool<TSchemaIn, TSchemaOut, TContext>;
 
-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?: ToolsInput;
-    convertedTools?: Record<string, CoreTool>;
-    onStepFinish?: (step: unknown) => void;
-    experimental_output?: Z;
-    telemetry?: TelemetrySettings;
-    threadId?: string;
-    resourceId?: string;
-} & Run;
-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 AgentNetworkConfig = {
+    name: string;
+    agents: Agent[];
+    model: LanguageModelV1;
+    instructions: string;
 };
-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;
 
-/**
- * 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;
-    storage: MastraStorage;
-    vector: MastraVector;
-    embedder: EmbeddingModel<string>;
-    protected threadConfig: MemoryConfig;
-    constructor(config: {
-        name: string;
-    } & SharedMemoryConfig);
-    setStorage(storage: MastraStorage): void;
-    setVector(vector: MastraVector): void;
-    setEmbedder(embedder: EmbeddingModel<string>): void;
+declare class AgentNetwork extends MastraBase {
+    #private;
+    constructor(config: AgentNetworkConfig);
+    formatAgentId(name: string): string;
+    getTools(): {
+        readonly transmit: Tool<z.ZodObject<{
+            actions: z.ZodArray<z.ZodObject<{
+                agent: z.ZodString;
+                input: z.ZodString;
+                includeHistory: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }, {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            actions: {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }[];
+        }, {
+            actions: {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }[];
+        }>, undefined, ToolExecutionContext<z.ZodObject<{
+            actions: z.ZodArray<z.ZodObject<{
+                agent: z.ZodString;
+                input: z.ZodString;
+                includeHistory: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }, {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            actions: {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }[];
+        }, {
+            actions: {
+                input: string;
+                agent: string;
+                includeHistory?: boolean | undefined;
+            }[];
+        }>>>;
+    };
+    getAgentHistory(agentId: string): {
+        input: string;
+        output: string;
+        timestamp: string;
+    }[];
     /**
-     * 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.
+     * Get the history of all agent interactions that have occurred in this network
+     * @returns A record of agent interactions, keyed by agent ID
      */
-    getSystemMessage(_input: {
-        threadId: string;
-        memoryConfig?: MemoryConfig;
-    }): Promise<string | null>;
+    getAgentInteractionHistory(): {
+        [x: string]: {
+            input: string;
+            output: string;
+            timestamp: string;
+        }[];
+    };
     /**
-     * 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.
+     * Get a summary of agent interactions in a more readable format, displayed chronologically
+     * @returns A formatted string with all agent interactions in chronological order
      */
-    getTools(_config?: MemoryConfig): Record<string, CoreTool>;
-    protected createEmbeddingIndex(): Promise<{
-        indexName: string;
-    }>;
-    getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
-    abstract rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
-        threadId: string;
-        resourceId?: string;
-        vectorMessageSearch?: string;
-        config?: MemoryConfig;
-    }): Promise<{
-        threadId: string;
-        messages: CoreMessage$1[];
-        uiMessages: Message[];
+    getAgentInteractionSummary(): string;
+    executeAgent(agentId: string, input: CoreMessage$1[], includeHistory?: boolean): Promise<string>;
+    getInstructions(): string;
+    getRoutingAgent(): Agent<string, ToolsInput, Record<string, Metric>>;
+    getAgents(): Agent<string, ToolsInput, Record<string, Metric>>[];
+    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentGenerateOptions<Z> & {
+        output?: never;
+        experimental_output?: never;
+    }): Promise<GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown>>;
+    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentGenerateOptions<Z> & ({
+        output: Z;
+        experimental_output?: never;
+    } | {
+        experimental_output: Z;
+        output?: never;
+    })): Promise<GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>>;
+    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentStreamOptions<Z> & {
+        output?: never;
+        experimental_output?: never;
+    }): Promise<StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown>>;
+    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentStreamOptions<Z> & ({
+        output: Z;
+        experimental_output?: never;
+    } | {
+        experimental_output: Z;
+        output?: never;
+    })): Promise<StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>>;
+    __registerMastra(p: Mastra): void;
+}
+
+interface WorkflowOptions<TWorkflowName extends string = string, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> {
+    steps?: TSteps;
+    name: TWorkflowName;
+    triggerSchema?: TTriggerSchema;
+    result?: {
+        schema: TResultSchema;
+        mapping?: {
+            [K in keyof z.infer<TResultSchema>]?: any;
+        };
+    };
+    events?: Record<string, {
+        schema: z.ZodObject<any>;
     }>;
-    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, config, content, role, type, toolNames, toolCallArgs, toolCallIds, }: {
-        threadId: 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;
+    retryConfig?: RetryConfig;
+    mastra?: Mastra;
 }
-
-type VoiceEventType = 'speaking' | 'writing' | 'error' | string;
-interface VoiceEventMap {
-    speaker: NodeJS.ReadableStream;
-    speaking: {
-        audio?: string;
-    };
-    writing: {
-        text: string;
-        role: 'assistant' | 'user';
+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;
+}
+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?: Workflow;
+}
+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 = {
+    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<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = TStep extends StepAction<any, any, any, any> ? {
+    step: TStep;
+    path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.';
+} : TStep extends 'trigger' ? {
+    step: 'trigger';
+    path: PathsToStringProps<ExtractSchemaType<TTriggerSchema>> | '.' | '';
+} : {
+    step: {
+        id: string;
     };
-    error: {
-        message: string;
-        code?: string;
-        details?: unknown;
+    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<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.' | 'status';
+    } : TStep extends 'trigger' ? {
+        step: 'trigger';
+        path: PathsToStringProps<ExtractSchemaType<TTriggerSchema>> | '.' | '';
+    } : {
+        step: {
+            id: string;
+        };
+        path: string;
     };
-    [key: string]: unknown;
+    query: Query<any>;
 }
-interface BuiltInModelConfig {
-    name: string;
-    apiKey?: string;
+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"
 }
-interface VoiceConfig<T = unknown> {
-    listeningModel?: BuiltInModelConfig;
-    speechModel?: BuiltInModelConfig;
-    speaker?: string;
-    name?: string;
-    realtimeConfig?: {
-        model?: string;
-        apiKey?: string;
-        options?: T;
+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, {
+    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 Step<string, any, any, any>[] = Step<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<VarStep, TTriggerSchema>> : {
+        [K in keyof StepInputType<TStep, 'inputSchema'>]?: VariableReference<VarStep, TTriggerSchema>;
+    };
+    '#internal'?: {
+        when?: Condition<CondStep, TTriggerSchema> | ((args: {
+            context: WorkflowContext<TTriggerSchema, TSteps>;
+            mastra?: Mastra;
+        }) => Promise<boolean | WhenConditionReturnValue>);
+        loopLabel?: string;
+        loopType?: 'while' | 'until' | undefined;
     };
 }
-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;
+type StepSuccess<T> = {
+    status: 'success';
+    output: T;
+};
+type StepSuspended<T> = {
+    status: 'suspended';
+    suspendPayload?: any;
+    output?: T;
+};
+type StepWaiting = {
+    status: 'waiting';
+};
+type StepFailure = {
+    status: 'failed';
+    error: string;
+};
+type StepSkipped = {
+    status: 'skipped';
+};
+type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended<T> | StepWaiting | StepSkipped;
+type StepsRecord<T extends readonly Step<any, any, z.ZodType<any> | undefined>[]> = {
+    [K in T[number]['id']]: Extract<T[number], {
+        id: K;
+    }>;
+};
+interface WorkflowRunResult<T extends z.ZodObject<any>, TSteps extends Step<string, any, z.ZodType<any> | undefined>[], TResult extends z.ZodObject<any>> {
+    triggerData?: z.infer<T>;
+    result?: z.infer<TResult>;
+    results: {
+        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
     };
-    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({ speakProvider, listenProvider, realtimeProvider, }: {
-        speakProvider?: MastraVoice;
-        listenProvider?: MastraVoice;
-        realtimeProvider?: 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;
-}
-
-type ToolsInput = Record<string, ToolAction<any, any, any> | VercelTool>;
-type ToolsetsInput = Record<string, ToolsInput>;
-type MastraLanguageModel = LanguageModelV1;
-interface AgentConfig<TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> {
-    name: string;
-    instructions: string;
-    model: MastraLanguageModel;
-    tools?: TTools;
-    mastra?: Mastra;
-    /** @deprecated This property is deprecated. Use evals instead to add evaluation metrics. */
-    metrics?: TMetrics;
-    evals?: TMetrics;
-    memory?: MastraMemory;
-    voice?: CompositeVoice;
+    runId: string;
+    timestamp: number;
+    activePaths: Map<keyof StepsRecord<TSteps>, {
+        status: string;
+        suspendPayload?: any;
+        stepPath: string[];
+    }>;
 }
-/**
- * Options for generating responses with an agent
- * @template Z - The schema type for structured output (Zod schema or JSON schema)
- */
-type AgentGenerateOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    /** Optional instructions to override the agent's default instructions */
-    instructions?: string;
-    /** Additional tool sets that can be used for this generation */
-    toolsets?: ToolsetsInput;
-    /** Additional context messages to include */
-    context?: CoreMessage[];
-    /** Memory configuration options */
-    memoryOptions?: MemoryConfig;
-    /** Unique ID for this generation run */
-    runId?: string;
-    /** Callback fired after each generation step completes */
-    onStepFinish?: Z extends undefined ? GenerateTextOnStepFinishCallback<any> : never;
-    /** Maximum number of steps allowed for generation */
-    maxSteps?: number;
-    /** Schema for structured output, does not work with tools, use experimental_output instead */
-    output?: OutputType | Z;
-    /** Schema for structured output generation alongside tool calls. */
-    experimental_output?: Z;
-    /** Controls how tools are selected during generation */
-    toolChoice?: 'auto' | 'none' | 'required' | {
-        type: 'tool';
-        toolName: string;
-    };
-    /** Telemetry settings */
-    telemetry?: TelemetrySettings;
-} & ({
-    resourceId?: undefined;
-    threadId?: undefined;
-} | {
-    resourceId: string;
-    threadId: string;
-}) & (Z extends undefined ? DefaultLLMTextOptions : DefaultLLMTextObjectOptions);
-/**
- * Options for streaming responses with an agent
- * @template Z - The schema type for structured output (Zod schema or JSON schema)
- */
-type AgentStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    /** Optional instructions to override the agent's default instructions */
-    instructions?: string;
-    /** Additional tool sets that can be used for this generation */
-    toolsets?: ToolsetsInput;
-    /** Additional context messages to include */
-    context?: CoreMessage[];
-    /** Memory configuration options */
-    memoryOptions?: MemoryConfig;
-    /** Unique ID for this generation run */
-    runId?: string;
-    /** Callback fired when streaming completes */
-    onFinish?: Z extends undefined ? StreamTextOnFinishCallback<any> : Z extends ZodSchema ? StreamObjectOnFinishCallback<z.infer<Z>> : StreamObjectOnFinishCallback<any>;
-    /** Callback fired after each generation step completes */
-    onStepFinish?: Z extends undefined ? StreamTextOnStepFinishCallback<any> : never;
-    /** Maximum number of steps allowed for generation */
-    maxSteps?: number;
-    /** Schema for structured output */
-    output?: OutputType | Z;
-    /** Temperature parameter for controlling randomness */
-    temperature?: number;
-    /** Controls how tools are selected during generation */
-    toolChoice?: 'auto' | 'none' | 'required' | {
-        type: 'tool';
-        toolName: string;
+interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[], TInputData extends Record<string, any> = Record<string, any>> {
+    isResume?: {
+        runId: string;
+        stepId: string;
     };
-    /** Experimental schema for structured output */
-    experimental_output?: Z;
-    /** Telemetry settings */
-    telemetry?: TelemetrySettings;
-} & ({
-    resourceId?: undefined;
-    threadId?: undefined;
-} | {
-    resourceId: string;
-    threadId: string;
-}) & (Z extends undefined ? DefaultLLMStreamOptions : DefaultLLMStreamObjectOptions);
-
-interface WorkflowOptions<TWorkflowName extends string = string, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> {
-    steps?: TSteps;
-    name: TWorkflowName;
-    triggerSchema?: TTriggerSchema;
-    result?: {
-        schema: TResultSchema;
-        mapping?: {
-            [K in keyof z.infer<TResultSchema>]?: any;
-        };
+    mastra?: MastraUnion;
+    steps: {
+        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
     };
-    events?: Record<string, {
-        schema: z.ZodObject<any>;
-    }>;
-    retryConfig?: RetryConfig;
-    mastra?: Mastra;
+    triggerData: z.infer<TTrigger>;
+    inputData: TInputData;
+    attempts: Record<string, number>;
+    getStepResult(stepId: 'trigger'): z.infer<TTrigger>;
+    getStepResult<T extends keyof StepsRecord<TSteps> | unknown>(stepId: T extends keyof StepsRecord<TSteps> ? T : string): T extends keyof StepsRecord<TSteps> ? StepsRecord<TSteps>[T]['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<StepsRecord<TSteps>[T]['outputSchema']>> : T;
+    getStepResult<T extends Step<any, any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
 }
-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;
-}
-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?: Workflow;
-}
-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 = {
-    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<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = TStep extends StepAction<any, any, any, any> ? {
-    step: TStep;
-    path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.';
-} : TStep extends 'trigger' ? {
-    step: 'trigger';
-    path: PathsToStringProps<ExtractSchemaType<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<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.' | 'status';
-    } : TStep extends 'trigger' ? {
-        step: 'trigger';
-        path: PathsToStringProps<ExtractSchemaType<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, {
-    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 Step<string, any, any, any>[] = Step<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<VarStep, TTriggerSchema>> : {
-        [K in keyof StepInputType<TStep, 'inputSchema'>]?: VariableReference<VarStep, TTriggerSchema>;
-    };
-    '#internal'?: {
-        when?: Condition<CondStep, TTriggerSchema> | ((args: {
-            context: WorkflowContext<TTriggerSchema, TSteps>;
-            mastra?: Mastra;
-        }) => Promise<boolean | WhenConditionReturnValue>);
-        loopLabel?: string;
-        loopType?: 'while' | 'until' | undefined;
-    };
-}
-type StepSuccess<T> = {
-    status: 'success';
-    output: T;
-};
-type StepSuspended<T> = {
-    status: 'suspended';
-    suspendPayload?: any;
-    output?: T;
-};
-type StepWaiting = {
-    status: 'waiting';
-};
-type StepFailure = {
-    status: 'failed';
-    error: string;
-};
-type StepSkipped = {
-    status: 'skipped';
-};
-type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended<T> | StepWaiting | StepSkipped;
-type StepsRecord<T extends readonly Step<any, any, z.ZodType<any> | undefined>[]> = {
-    [K in T[number]['id']]: Extract<T[number], {
-        id: K;
-    }>;
-};
-interface WorkflowRunResult<T extends z.ZodObject<any>, TSteps extends Step<string, any, z.ZodType<any> | undefined>[], TResult extends z.ZodObject<any>> {
-    triggerData?: z.infer<T>;
-    result?: z.infer<TResult>;
-    results: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
-    };
-    runId: string;
-    activePaths: Map<keyof StepsRecord<TSteps>, {
-        status: string;
-        suspendPayload?: any;
-    }>;
-}
-interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[], TInputData extends Record<string, any> = Record<string, any>> {
-    isResume?: {
-        runId: string;
-        stepId: string;
-    };
-    mastra?: MastraUnion;
-    steps: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
-    };
-    triggerData: z.infer<TTrigger>;
-    inputData: TInputData;
-    attempts: Record<string, number>;
-    getStepResult(stepId: 'trigger'): z.infer<TTrigger>;
-    getStepResult<T extends keyof StepsRecord<TSteps> | unknown>(stepId: T extends keyof StepsRecord<TSteps> ? T : string): T extends keyof StepsRecord<TSteps> ? StepsRecord<TSteps>[T]['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<StepsRecord<TSteps>[T]['outputSchema']>> : T;
-    getStepResult<T extends Step<any, any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
-}
-interface WorkflowLogMessage extends BaseLogMessage {
-    type: typeof RegisteredLogger.WORKFLOW;
-    workflowName: string;
-    stepId?: StepId;
-    data?: unknown;
-    runId?: string;
+interface WorkflowLogMessage extends BaseLogMessage {
+    type: typeof RegisteredLogger.WORKFLOW;
+    workflowName: string;
+    stepId?: StepId;
+    data?: unknown;
+    runId?: string;
 }
 type WorkflowEvent = {
     type: 'RESET_TO_PENDING';
@@ -937,7 +578,7 @@ declare class Machine<TSteps extends Step<any, any, any>[] = any, TTriggerSchema
         input?: any;
         snapshot?: Snapshot<any>;
         resumeData?: any;
-    }): Promise<Pick<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths'>>;
+    }): Promise<Pick<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>>;
     private initializeMachine;
     getSnapshot(): xstate.MachineSnapshot<Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
         type: "RESET_TO_PENDING";
@@ -1253,6 +894,7 @@ declare class Machine<TSteps extends Step<any, any, any>[] = any, TTriggerSchema
             }, xstate.AnyEventObject>;
         }) => {
             mastra?: MastraUnion | undefined;
+            triggerData: any;
             isResume?: {
                 runId: string;
                 stepId: string;
@@ -1281,7 +923,6 @@ declare class Machine<TSteps extends Step<any, any, any>[] = any, TTriggerSchema
                     output?: any;
                 };
             };
-            triggerData: any;
             inputData: Record<string, any>;
             attempts: Record<string, number>;
         };
@@ -1289,279 +930,695 @@ declare class Machine<TSteps extends Step<any, any, any>[] = any, TTriggerSchema
     }> | undefined;
 }
 
-interface WorkflowResultReturn<TResult extends z.ZodObject<any>, T extends z.ZodObject<any>, TSteps extends Step<any, any, any>[]> {
-    runId: string;
-    start: (props?: {
-        triggerData?: z.infer<T>;
-    } | undefined) => Promise<WorkflowRunResult<T, TSteps, TResult>>;
-    watch: (onTransition: (state: WorkflowRunState) => void) => () => void;
-    resume: (props: {
-        stepId: string;
-        context?: Record<string, any>;
-    }) => Promise<Omit<WorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
-    resumeWithEvent: (eventName: string, data: any) => Promise<Omit<WorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
+interface WorkflowResultReturn<TResult extends z.ZodObject<any>, T extends z.ZodObject<any>, TSteps extends Step<any, any, any>[]> {
+    runId: string;
+    start: (props?: {
+        triggerData?: z.infer<T>;
+    } | undefined) => Promise<WorkflowRunResult<T, TSteps, TResult>>;
+    watch: (onTransition: (state: Pick<WorkflowRunResult<T, TSteps, TResult>, 'results' | 'activePaths' | 'runId'>) => void) => () => void;
+    resume: (props: {
+        stepId: string;
+        context?: Record<string, any>;
+    }) => Promise<Omit<WorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
+    resumeWithEvent: (eventName: string, data: any) => Promise<Omit<WorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
+}
+declare class WorkflowInstance<TSteps extends Step<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: Logger;
+    events?: Record<string, {
+        schema: z.ZodObject<any>;
+    }>;
+    constructor({ name, logger, steps, runId, retryConfig, mastra, stepGraph, stepSubscriberGraph, onFinish, onStepTransition, resultMapping, events, }: {
+        name: string;
+        logger: Logger;
+        steps: Record<string, StepAction<any, any, any, any>>;
+        mastra?: Mastra;
+        retryConfig?: RetryConfig;
+        runId?: string;
+        stepGraph: StepGraph;
+        stepSubscriberGraph: Record<string, StepGraph>;
+        onFinish?: () => void;
+        onStepTransition?: Set<(state: Pick<WorkflowRunResult<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<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
+    start({ triggerData }?: {
+        triggerData?: z.infer<TTriggerSchema>;
+    }): Promise<{
+        runId: string;
+        timestamp: number;
+        result?: z.TypeOf<TResult> | undefined;
+        results: { [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]["outputSchema"] extends undefined ? StepResult<unknown> : StepResult<z.TypeOf<NonNullable<StepsRecord<TSteps>[K]["outputSchema"]>>>; };
+        triggerData?: z.TypeOf<TTriggerSchema> | undefined;
+        activePaths: Map<TSteps[number]["id"], {
+            status: string;
+            suspendPayload?: any;
+            stepPath: string[];
+        }>;
+    }>;
+    private isCompoundDependencyMet;
+    execute({ triggerData, snapshot, stepId, resumeData, }?: {
+        stepId?: string;
+        triggerData?: z.infer<TTriggerSchema>;
+        snapshot?: Snapshot<any>;
+        resumeData?: any;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'runId'>>;
+    hasSubscribers(stepId: string): boolean;
+    runMachine(parentStepId: string, input: any): Promise<(Pick<WorkflowRunResult<any, any, any>, "runId" | "timestamp" | "results" | "activePaths"> | undefined)[]>;
+    suspend(stepId: string, machine: Machine<TSteps, TTriggerSchema>): Promise<void>;
+    /**
+     * Persists the workflow state to the database
+     */
+    persistWorkflowSnapshot(): Promise<void>;
+    getState(): Promise<WorkflowRunState | null>;
+    resumeWithEvent(eventName: string, data: any): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    resume({ stepId, context: resumeContext }: {
+        stepId: string;
+        context?: Record<string, any>;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    _resume({ stepId, context: resumeContext }: {
+        stepId: string;
+        context?: Record<string, any>;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+}
+
+type WorkflowBuilder<T extends Workflow<any, any>> = Pick<T, 'step' | 'then' | 'after' | 'while' | 'until' | 'if' | 'else' | 'afterEvent' | 'commit'>;
+declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TStepId extends string = string, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends MastraBase {
+    #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>;
+    }>;
+    /**
+     * Creates a new Workflow 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 Workflow<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 Workflow<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>['when'], fallbackStep: FallbackStep): 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): Pick<WorkflowBuilder<this>, "then" | "commit">;
+    if<TStep extends StepAction<string, any, any, any>>(condition: StepConfig<TStep, any, any, TTriggerSchema>['when'], ifStep?: TStep | Workflow, elseStep?: TStep | Workflow): this | WorkflowBuilder<this>;
+    else(): WorkflowBuilder<this>;
+    after<TStep extends StepAction<string, any, any, any>>(steps: TStep | TStep[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
+    after<TWorkflow extends Workflow<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;
+        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): 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;
+    getExecutionSpan(runId: string): Span | undefined;
+    getState(runId: string): Promise<WorkflowRunState | null>;
+    resume({ runId, stepId, context: resumeContext, }: {
+        runId: string;
+        stepId: string;
+        context?: Record<string, any>;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
+    watch(onTransition: (state: Pick<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
+    resumeWithEvent(runId: string, eventName: string, data: any): Promise<Omit<WorkflowRunResult<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;
+    get isNested(): boolean;
+    toStep(): Step<TStepId, TTriggerSchema, z.ZodType<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
+}
+
+type MemoryProcessorOpts = {
+    systemMessage?: string;
+    memorySystemMessage?: string;
+    newMessages?: CoreMessage$1[];
+};
+/**
+ * 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[];
+}
+/**
+ * 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;
+    storage: MastraStorage;
+    vector: MastraVector;
+    embedder: EmbeddingModel<string>;
+    private processors;
+    protected threadConfig: MemoryConfig;
+    constructor(config: {
+        name: string;
+    } & SharedMemoryConfig);
+    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(): 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, 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;
+}
+
+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?: ToolsInput;
+    convertedTools?: Record<string, CoreTool>;
+    onStepFinish?: (step: unknown) => void;
+    experimental_output?: Z;
+    telemetry?: TelemetrySettings;
+    threadId?: string;
+    resourceId?: string;
+} & Run;
+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;
 }
-declare class WorkflowInstance<TSteps extends Step<any, any, any>[] = any, TTriggerSchema extends z.ZodObject<any> = any, TResult extends z.ZodObject<any> = any> implements WorkflowResultReturn<TResult, TTriggerSchema, TSteps> {
-    #private;
+interface BuiltInModelConfig {
     name: string;
-    logger: Logger;
-    events?: Record<string, {
-        schema: z.ZodObject<any>;
-    }>;
-    constructor({ name, logger, steps, runId, retryConfig, mastra, stepGraph, stepSubscriberGraph, onFinish, onStepTransition, resultMapping, events, }: {
-        name: string;
-        logger: Logger;
-        steps: Record<string, StepAction<any, any, any, any>>;
-        mastra?: Mastra;
-        retryConfig?: RetryConfig;
-        runId?: string;
-        stepGraph: StepGraph;
-        stepSubscriberGraph: Record<string, StepGraph>;
-        onFinish?: () => void;
-        onStepTransition?: Set<(state: WorkflowRunState) => 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: WorkflowRunState) => void): () => void;
-    start({ triggerData }?: {
-        triggerData?: z.infer<TTriggerSchema>;
-    }): Promise<{
-        runId: string;
-        result?: z.TypeOf<TResult> | undefined;
-        results: { [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]["outputSchema"] extends undefined ? StepResult<unknown> : StepResult<z.TypeOf<NonNullable<StepsRecord<TSteps>[K]["outputSchema"]>>>; };
-        triggerData?: z.TypeOf<TTriggerSchema> | undefined;
-        activePaths: Map<TSteps[number]["id"], {
-            status: string;
-            suspendPayload?: any;
-        }>;
-    }>;
-    private isCompoundDependencyMet;
-    execute({ triggerData, snapshot, stepId, resumeData, }?: {
-        stepId?: string;
-        triggerData?: z.infer<TTriggerSchema>;
-        snapshot?: Snapshot<any>;
-        resumeData?: any;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'runId'>>;
-    hasSubscribers(stepId: string): boolean;
-    runMachine(parentStepId: string, input: any): Promise<(Pick<WorkflowRunResult<any, any, any>, "results" | "activePaths"> | undefined)[]>;
-    suspend(stepId: string, machine: Machine<TSteps, TTriggerSchema>): Promise<void>;
+    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;
     /**
-     * Persists the workflow state to the database
+     * 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
      */
-    persistWorkflowSnapshot(): Promise<void>;
-    getState(): Promise<WorkflowRunState | null>;
-    resumeWithEvent(eventName: string, data: any): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
-    resume({ stepId, context: resumeContext }: {
-        stepId: string;
-        context?: Record<string, any>;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
-    _resume({ stepId, context: resumeContext }: {
-        stepId: string;
-        context?: Record<string, any>;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    /**
+     * 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 Workflow<TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TStepId extends string = string, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends MastraBase {
-    #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>;
-    }>;
+declare class CompositeVoice extends MastraVoice<unknown, unknown, unknown, ToolsInput, VoiceEventMap> {
+    protected speakProvider?: MastraVoice;
+    protected listenProvider?: MastraVoice;
+    protected realtimeProvider?: MastraVoice;
+    constructor({ speakProvider, listenProvider, realtimeProvider, }: {
+        speakProvider?: MastraVoice;
+        listenProvider?: MastraVoice;
+        realtimeProvider?: MastraVoice;
+    });
     /**
-     * Creates a new Workflow instance
-     * @param name - Identifier for the workflow (not necessarily unique)
-     * @param logger - Optional logger instance
+     * 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
      */
-    constructor({ name, triggerSchema, result, retryConfig, mastra, events, }: WorkflowOptions<TStepId, TSteps, TTriggerSchema, TResultSchema>);
-    step<TWorkflow extends Workflow<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>): 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>): 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 Workflow<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;
-    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>['when'], fallbackStep: FallbackStep): this;
-    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): this;
-    if<TStep extends StepAction<string, any, any, any>>(condition: StepConfig<TStep, any, any, TTriggerSchema>['when'], ifStep?: TStep | Workflow, elseStep?: TStep | Workflow): this;
-    else(): this;
-    after<TStep extends StepAction<string, any, any, any>>(steps: TStep | TStep[]): Omit<typeof this, 'then' | 'after'>;
-    after<TWorkflow extends Workflow<any, any, any, any>>(steps: TWorkflow | TWorkflow[]): Omit<typeof this, 'then' | 'after'>;
-    afterEvent(eventName: string): this;
+    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;
     /**
-     * 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
+     * Disconnect from the WebSocket or WebRTC connection
      */
-    createRun({ runId, events, }?: {
-        runId?: string;
-        events?: Record<string, {
-            schema: z.ZodObject<any>;
-        }>;
-    }): WorkflowResultReturn<TResultSchema, TTriggerSchema, TSteps>;
+    close(): void;
     /**
-     * Gets a workflow run instance by ID
-     * @param runId - ID of the run to retrieve
-     * @returns The workflow run instance if found, undefined otherwise
+     * Register an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function that receives event data
      */
-    getRun(runId: string): WorkflowInstance<TSteps, TTriggerSchema, any> | undefined;
+    on<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
     /**
-     * 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
+     * Remove an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function to remove
      */
-    commit(): this;
-    getExecutionSpan(runId: string): Span | undefined;
-    getState(runId: string): Promise<WorkflowRunState | null>;
-    resume({ runId, stepId, context: resumeContext, }: {
-        runId: string;
-        stepId: string;
-        context?: Record<string, any>;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
-    watch(onTransition: (state: WorkflowRunState) => void): () => void;
-    resumeWithEvent(runId: string, eventName: string, data: any): Promise<Omit<WorkflowRunResult<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;
-    get isNested(): boolean;
-    toStep(): Step<TStepId, TTriggerSchema, z.ZodType<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
+    off<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
 }
 
-type AgentNetworkConfig = {
-    name: string;
-    agents: Agent[];
-    model: LanguageModelV1;
+type ToolsInput = Record<string, ToolAction<any, any, any> | VercelTool>;
+type ToolsetsInput = Record<string, ToolsInput>;
+type MastraLanguageModel = LanguageModelV1;
+interface AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> {
+    name: TAgentId;
     instructions: string;
-};
-
-declare class AgentNetwork extends MastraBase {
-    #private;
-    constructor(config: AgentNetworkConfig);
-    formatAgentId(name: string): string;
-    getTools(): {
-        transmit: Tool<z.ZodObject<{
-            actions: z.ZodArray<z.ZodObject<{
-                agent: z.ZodString;
-                input: z.ZodString;
-                includeHistory: z.ZodOptional<z.ZodBoolean>;
-            }, "strip", z.ZodTypeAny, {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }, {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            actions: {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }[];
-        }, {
-            actions: {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }[];
-        }>, undefined, ToolExecutionContext<z.ZodObject<{
-            actions: z.ZodArray<z.ZodObject<{
-                agent: z.ZodString;
-                input: z.ZodString;
-                includeHistory: z.ZodOptional<z.ZodBoolean>;
-            }, "strip", z.ZodTypeAny, {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }, {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            actions: {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }[];
-        }, {
-            actions: {
-                input: string;
-                agent: string;
-                includeHistory?: boolean | undefined;
-            }[];
-        }>>>;
+    model: MastraLanguageModel;
+    tools?: TTools;
+    mastra?: Mastra;
+    /** @deprecated This property is deprecated. Use evals instead to add evaluation metrics. */
+    metrics?: TMetrics;
+    evals?: TMetrics;
+    memory?: MastraMemory;
+    voice?: CompositeVoice;
+}
+/**
+ * Options for generating responses with an agent
+ * @template Z - The schema type for structured output (Zod schema or JSON schema)
+ */
+type AgentGenerateOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    /** Optional instructions to override the agent's default instructions */
+    instructions?: string;
+    /** Additional tool sets that can be used for this generation */
+    toolsets?: ToolsetsInput;
+    /** Additional context messages to include */
+    context?: CoreMessage[];
+    /** Memory configuration options */
+    memoryOptions?: MemoryConfig;
+    /** Unique ID for this generation run */
+    runId?: string;
+    /** Callback fired after each generation step completes */
+    onStepFinish?: Z extends undefined ? GenerateTextOnStepFinishCallback<any> : never;
+    /** Maximum number of steps allowed for generation */
+    maxSteps?: number;
+    /** Schema for structured output, does not work with tools, use experimental_output instead */
+    output?: OutputType | Z;
+    /** Schema for structured output generation alongside tool calls. */
+    experimental_output?: Z;
+    /** Controls how tools are selected during generation */
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'tool';
+        toolName: string;
     };
-    getAgentHistory(agentId: string): {
-        input: string;
-        output: string;
-        timestamp: string;
-    }[];
-    /**
-     * Get the history of all agent interactions that have occurred in this network
-     * @returns A record of agent interactions, keyed by agent ID
-     */
-    getAgentInteractionHistory(): {
-        [x: string]: {
-            input: string;
-            output: string;
-            timestamp: string;
-        }[];
+    /** Telemetry settings */
+    telemetry?: TelemetrySettings;
+} & ({
+    resourceId?: undefined;
+    threadId?: undefined;
+} | {
+    resourceId: string;
+    threadId: string;
+}) & (Z extends undefined ? DefaultLLMTextOptions : DefaultLLMTextObjectOptions);
+/**
+ * Options for streaming responses with an agent
+ * @template Z - The schema type for structured output (Zod schema or JSON schema)
+ */
+type AgentStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    /** Optional instructions to override the agent's default instructions */
+    instructions?: string;
+    /** Additional tool sets that can be used for this generation */
+    toolsets?: ToolsetsInput;
+    /** Additional context messages to include */
+    context?: CoreMessage[];
+    /** Memory configuration options */
+    memoryOptions?: MemoryConfig;
+    /** Unique ID for this generation run */
+    runId?: string;
+    /** Callback fired when streaming completes */
+    onFinish?: Z extends undefined ? StreamTextOnFinishCallback<any> : Z extends ZodSchema ? StreamObjectOnFinishCallback<z.infer<Z>> : StreamObjectOnFinishCallback<any>;
+    /** Callback fired after each generation step completes */
+    onStepFinish?: Z extends undefined ? StreamTextOnStepFinishCallback<any> : never;
+    /** Maximum number of steps allowed for generation */
+    maxSteps?: number;
+    /** Schema for structured output */
+    output?: OutputType | Z;
+    /** Temperature parameter for controlling randomness */
+    temperature?: number;
+    /** Controls how tools are selected during generation */
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'tool';
+        toolName: string;
     };
-    /**
-     * Get a summary of agent interactions in a more readable format, displayed chronologically
-     * @returns A formatted string with all agent interactions in chronological order
-     */
-    getAgentInteractionSummary(): string;
-    executeAgent(agentId: string, input: CoreMessage$1[], includeHistory?: boolean): Promise<string>;
-    getInstructions(): string;
-    getRoutingAgent(): Agent<ToolsInput, Record<string, Metric>>;
-    getAgents(): Agent<ToolsInput, Record<string, Metric>>[];
-    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentGenerateOptions<Z> & {
-        output?: never;
-        experimental_output?: never;
-    }): Promise<GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown>>;
-    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentGenerateOptions<Z> & ({
-        output: Z;
-        experimental_output?: never;
-    } | {
-        experimental_output: Z;
-        output?: never;
-    })): Promise<GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>>;
-    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentStreamOptions<Z> & {
-        output?: never;
-        experimental_output?: never;
-    }): Promise<StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown>>;
-    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentStreamOptions<Z> & ({
-        output: Z;
-        experimental_output?: never;
-    } | {
-        experimental_output: Z;
-        output?: never;
-    })): Promise<StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>>;
-    __registerMastra(p: Mastra): void;
-}
+    /** Experimental schema for structured output */
+    experimental_output?: Z;
+    /** Telemetry settings */
+    telemetry?: TelemetrySettings;
+} & ({
+    resourceId?: undefined;
+    threadId?: undefined;
+} | {
+    resourceId: string;
+    threadId: string;
+}) & (Z extends undefined ? DefaultLLMStreamOptions : DefaultLLMStreamObjectOptions);
+
+type Methods = 'GET' | 'POST' | 'PUT' | 'DELETE';
+type ApiRoute = {
+    path: string;
+    method: Methods;
+    handler: Handler;
+    middleware?: MiddlewareHandler | MiddlewareHandler[];
+    openapi?: DescribeRouteOptions;
+};
+type Middleware = MiddlewareHandler | {
+    path: string;
+    handler: MiddlewareHandler;
+};
+type ServerConfig = {
+    apiRoutes?: ApiRoute[];
+    middleware?: Middleware | Middleware[];
+};
 
 interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>> {
     agents?: TAgents;
@@ -1573,9 +1630,11 @@ interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Age
     tts?: TTTS;
     telemetry?: OtelConfig;
     deployer?: MastraDeployer;
+    server?: ServerConfig;
     /**
      * Server middleware functions to be applied to API routes
      * Each middleware can specify a path pattern (defaults to '/api/*')
+     * @deprecated use server.middleware instead
      */
     serverMiddleware?: Array<{
         handler: (c: any, next: () => Promise<void>) => Promise<Response | void>;
@@ -1624,6 +1683,7 @@ declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string,
         path: string;
     }[];
     getNetworks(): AgentNetwork[];
+    getServer(): ServerConfig | undefined;
     /**
      * Get a specific network by ID
      * @param networkId - The ID of the network to retrieve
@@ -1683,9 +1743,9 @@ declare class MastraLLMBase extends MastraBase {
     stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options?: LLMStreamOptions<Z>): Promise<StreamReturn<Z>>;
 }
 
-declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> extends MastraBase {
+declare class Agent<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> extends MastraBase {
     #private;
-    name: string;
+    name: TAgentId;
     readonly llm: MastraLLMBase;
     instructions: string;
     readonly model?: MastraLanguageModel;
@@ -1693,8 +1753,8 @@ declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Rec
     /** @deprecated This property is deprecated. Use evals instead. */
     metrics: TMetrics;
     evals: TMetrics;
-    voice?: CompositeVoice;
-    constructor(config: AgentConfig<TTools, TMetrics>);
+    voice: CompositeVoice;
+    constructor(config: AgentConfig<TAgentId, TTools, TMetrics>);
     hasOwnMemory(): boolean;
     getMemory(): MastraMemory | undefined;
     __updateInstructions(newInstructions: string): void;
@@ -1710,11 +1770,12 @@ declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Rec
     }): Promise<string>;
     getMostRecentUserMessage(messages: Array<CoreMessage$1>): CoreUserMessage$1 | undefined;
     genTitle(userMessage: CoreUserMessage$1 | undefined): Promise<string>;
-    fetchMemory({ threadId, memoryConfig, resourceId, userMessages, runId, }: {
+    fetchMemory({ threadId, memoryConfig, resourceId, userMessages, systemMessage, runId, }: {
         resourceId: string;
         threadId: string;
         memoryConfig?: MemoryConfig;
         userMessages: CoreMessage$1[];
+        systemMessage: CoreMessage$1;
         time?: Date;
         keyword?: string;
         runId?: string;
@@ -1736,12 +1797,13 @@ declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Rec
         resourceId?: string;
         runId?: string;
     }): Record<string, CoreTool>;
-    preExecute({ resourceId, runId, threadId, memoryConfig, messages, }: {
+    preExecute({ resourceId, runId, threadId, memoryConfig, messages, systemMessage, }: {
         runId?: string;
         threadId: string;
         memoryConfig?: MemoryConfig;
         messages: CoreMessage$1[];
         resourceId: string;
+        systemMessage: CoreMessage$1;
     }): Promise<{
         coreMessages: CoreMessage$1[];
         threadIdToUse: string;
@@ -1760,10 +1822,12 @@ declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Rec
             messageObjects: CoreMessage$1[];
             convertedTools: Record<string, CoreTool> | undefined;
             threadId: string;
+            thread: StorageThreadType | null | undefined;
         }>;
-        after: ({ result, threadId, memoryConfig, outputText, runId, }: {
+        after: ({ result, thread: threadAfter, threadId, memoryConfig, outputText, runId, }: {
             runId: string;
             result: Record<string, any>;
+            thread: StorageThreadType | null | undefined;
             threadId: string;
             memoryConfig: MemoryConfig | undefined;
             outputText: string;
@@ -1827,6 +1891,11 @@ declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Rec
     getSpeakers(): Promise<{
         voiceId: string;
     }[]>;
+    toStep(): Step<TAgentId, z.ZodObject<{
+        prompt: z.ZodString;
+    }>, z.ZodObject<{
+        text: z.ZodString;
+    }>, any>;
 }
 
 interface StorageColumn {
@@ -1878,6 +1947,7 @@ 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;
@@ -1885,6 +1955,7 @@ type MessageType = {
     role: 'system' | 'user' | 'assistant' | 'tool';
     createdAt: Date;
     threadId: string;
+    resourceId: string;
     toolCallIds?: string[];
     toolCallArgs?: Record<string, unknown>[];
     toolNames?: string[];
@@ -1925,6 +1996,7 @@ type SharedMemoryConfig = {
     options?: MemoryConfig;
     vector?: MastraVector;
     embedder?: EmbeddingModel<string>;
+    processors?: MemoryProcessor[];
 };
 
 declare abstract class MastraStorage extends MastraBase {
@@ -2035,4 +2107,4 @@ declare abstract class MastraStorage extends MastraBase {
     __getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
 }
 
-export { createTool as $, Agent as A, type BaseStructuredOutputType as B, type CoreTool as C, type StructuredOutput as D, type EvalRow as E, type StreamReturn as F, type GenerateReturn as G, type DefaultLLMTextOptions as H, type DefaultLLMTextObjectOptions as I, type DefaultLLMStreamOptions as J, type DefaultLLMStreamObjectOptions as K, type LanguageModel as L, Mastra as M, type LLMTextOptions as N, type OutputType as O, type LLMTextObjectOptions as P, type LLMStreamOptions as Q, type LLMInnerStreamOptions as R, Step as S, type ToolAction as T, type LLMStreamObjectOptions as U, type VercelTool as V, Workflow as W, type Config as X, type MessageResponse as Y, type MemoryConfig as Z, type SharedMemoryConfig as _, type ToolsInput as a, type StepAction as a0, type StepVariableType as a1, type StepNode as a2, type StepGraph as a3, type RetryConfig as a4, type VariableReference as a5, type BaseCondition as a6, type ActionContext as a7, WhenConditionReturnValue as a8, type StepDef as a9, type VoiceEventType as aA, type VoiceEventMap as aB, type VoiceConfig as aC, MastraVoice as aD, CompositeVoice as aE, type AgentNetworkConfig as aF, type ToolsetsInput as aG, type AgentGenerateOptions as aH, type AgentStreamOptions as aI, TABLE_WORKFLOW_SNAPSHOT as aJ, TABLE_EVALS as aK, TABLE_MESSAGES as aL, TABLE_THREADS as aM, TABLE_TRACES as aN, type StepCondition as aa, type StepConfig as ab, type StepResult as ac, type StepsRecord as ad, type WorkflowRunResult as ae, type WorkflowLogMessage as af, type WorkflowEvent as ag, type ResolverFunctionInput as ah, type ResolverFunctionOutput as ai, type SubscriberFunctionOutput as aj, type DependencyCheckOutput as ak, type StepResolverOutput as al, type WorkflowActors as am, type WorkflowActionParams as an, type WorkflowActions as ao, type WorkflowState as ap, type StepId as aq, type ExtractSchemaFromStep as ar, type ExtractStepResult as as, type StepInputType as at, type ExtractSchemaType as au, type PathsToStringProps as av, type WorkflowRunState as aw, type WorkflowResumeResult as ax, createStep as ay, type MastraLanguageModel as az, type MastraPrimitives as b, MastraMemory as c, type StepExecutionContext as d, type WorkflowContext as e, AgentNetwork as f, MastraStorage as g, type TABLE_NAMES as h, type StorageColumn as i, type StorageThreadType as j, type MessageType as k, type StorageGetMessagesArg as l, type AgentConfig as m, type ToolExecutionContext as n, Tool as o, type WorkflowOptions as p, type WorkflowRow as q, type CoreMessage as r, type CoreSystemMessage as s, type CoreAssistantMessage as t, type CoreUserMessage as u, type CoreToolMessage as v, type EmbedResult as w, type EmbedManyResult as x, type StructuredOutputType as y, type StructuredOutputArrayItem as z };
+export { type MemoryProcessorOpts as $, type ApiRoute as A, type BaseStructuredOutputType as B, CompositeVoice as C, type StructuredOutput as D, type EvalRow as E, type StreamReturn as F, type GenerateReturn as G, type DefaultLLMTextOptions as H, type DefaultLLMTextObjectOptions as I, type DefaultLLMStreamOptions as J, type DefaultLLMStreamObjectOptions as K, type LanguageModel as L, type Methods as M, type LLMTextOptions as N, type OutputType as O, type LLMTextObjectOptions as P, type LLMStreamOptions as Q, type LLMInnerStreamOptions as R, type StorageColumn as S, type TABLE_NAMES as T, type LLMStreamObjectOptions as U, type VoiceEventType as V, Workflow as W, type Config as X, type MessageResponse as Y, type MemoryConfig as Z, type SharedMemoryConfig as _, Mastra as a, MemoryProcessor as a0, createTool as a1, type VercelTool as a2, type CoreTool as a3, type StepExecutionContext as a4, type StepAction as a5, type StepVariableType as a6, type StepNode as a7, type StepGraph as a8, type RetryConfig as a9, type ExtractSchemaType as aA, type PathsToStringProps as aB, type WorkflowRunState as aC, type WorkflowResumeResult as aD, createStep as aE, type MastraLanguageModel as aF, type ToolsInput as aG, type MastraPrimitives as aH, AgentNetwork as aI, type AgentNetworkConfig as aJ, type ToolsetsInput as aK, type AgentGenerateOptions as aL, type AgentStreamOptions as aM, TABLE_WORKFLOW_SNAPSHOT as aN, TABLE_EVALS as aO, TABLE_MESSAGES as aP, TABLE_THREADS as aQ, TABLE_TRACES as aR, TABLE_SCHEMAS as aS, type VariableReference as aa, type BaseCondition as ab, type ActionContext as ac, WhenConditionReturnValue as ad, type StepDef as ae, type StepCondition as af, type StepConfig as ag, type StepResult as ah, type StepsRecord as ai, type WorkflowRunResult as aj, type WorkflowContext as ak, type WorkflowLogMessage as al, type WorkflowEvent as am, type ResolverFunctionInput as an, type ResolverFunctionOutput as ao, type SubscriberFunctionOutput as ap, type DependencyCheckOutput as aq, type StepResolverOutput as ar, type WorkflowActors as as, type WorkflowActionParams as at, type WorkflowActions as au, type WorkflowState as av, type StepId as aw, type ExtractSchemaFromStep as ax, type ExtractStepResult as ay, type StepInputType as az, MastraVoice as b, type VoiceEventMap as c, type VoiceConfig as d, MastraStorage as e, type StorageThreadType as f, type MessageType as g, type StorageGetMessagesArg as h, type ToolAction as i, Agent as j, type AgentConfig as k, MastraMemory as l, type ToolExecutionContext as m, Tool as n, Step as o, type WorkflowOptions as p, type WorkflowRow as q, type CoreMessage as r, type CoreSystemMessage as s, type CoreAssistantMessage as t, type CoreUserMessage as u, type CoreToolMessage as v, type EmbedResult as w, type EmbedManyResult as x, type StructuredOutputType as y, type StructuredOutputArrayItem as z };