@mastra/core 0.9.5-alpha.0 → 0.10.0

package/dist/{base-CI7Uz2GO.d.ts → base-DttB7sJD.d.ts}

@@ -1,24 +1,24 @@
 import * as ai from 'ai';
-import { Tool as Tool$1, Schema, ToolExecutionOptions, LanguageModelV1, CoreMessage as CoreMessage$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, EmbeddingModel, Message, UserContent, AssistantContent, LanguageModel as LanguageModel$1, DeepPartial, generateText, generateObject, streamText, streamObject, TelemetrySettings, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback, ToolContent } from 'ai';
-import { M as MastraBase, T as Telemetry, O as OtelConfig } from './base-4Z34GQL8.js';
-import { a as Metric, M as MetricResult, T as TestInfo } from './types-BtMyV38I.js';
+import { Tool as Tool$1, Schema, ToolExecutionOptions, EmbeddingModel, CoreMessage as CoreMessage$1, Message, UserContent, AssistantContent, LanguageModel as LanguageModel$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, DeepPartial, generateText, generateObject, streamText, streamObject, TelemetrySettings, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, LanguageModelV1, GenerateTextOnStepFinishCallback, StreamTextOnFinishCallback, StreamObjectOnFinishCallback, StreamTextOnStepFinishCallback, ToolContent } from 'ai';
+import { M as MastraBase, T as Telemetry, O as OtelConfig } from './base-tc5kgDTD.js';
+import { M as Metric, a as MetricResult, T as TestInfo } from './types-Bo1uigWx.js';
 import { Query } from 'sift';
 import { z, ZodSchema } from 'zod';
 import { JSONSchema7Type, JSONSchema7 } from 'json-schema';
-import { B as BaseLogMessage, R as RegisteredLogger, L as Logger, d as Run$1 } from './index-QV27jkxQ.js';
+import { MastraDeployer } from './deployer/index.js';
+import { B as BaseLogMessage, R as RegisteredLogger, I as IMastraLogger } from './logger-EhZkzZOr.js';
+import * as http from 'node:http';
+import { Context, Handler, MiddlewareHandler, HonoRequest } from 'hono';
 import { RuntimeContext } from './runtime-context/index.js';
+import { MastraVector } from './vector/index.js';
+import { cors } from 'hono/cors';
+import { DescribeRouteOptions } from 'hono-openapi';
+import { MastraTTS } from './tts/index.js';
 import { Span } from '@opentelemetry/api';
 import * as xstate from 'xstate';
 import { Snapshot } from 'xstate';
 import EventEmitter from 'node:events';
-import * as http from 'node:http';
-import { Context, Handler, MiddlewareHandler } from 'hono';
-import { MastraTTS } from './tts/index.js';
-import { MastraVector } from './vector/index.js';
 import EventEmitter$1 from 'events';
-import { MastraDeployer } from './deployer/index.js';
-import { cors } from 'hono/cors';
-import { DescribeRouteOptions } from 'hono-openapi';
 import { MockLanguageModelV1 } from 'ai/test';
 
 type VercelTool = Tool$1;
@@ -75,494 +75,484 @@ declare function createTool<TSchemaIn extends z.ZodSchema | undefined = undefine
     execute: (context: TContext) => Promise<any>;
 } : Tool<TSchemaIn, TSchemaOut, TContext>;
 
-type ConvertedTool = {
-    name: string;
-    description?: string;
-    parameters: InternalCoreTool['parameters'];
-    execute: InternalCoreTool['execute'];
+type RunStatus = 'created' | 'running' | 'completed' | 'failed';
+type Run$1 = {
+    runId?: string;
+    runStatus?: RunStatus;
 };
-interface MCPServerSSEOptionsBase {
+
+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 {
     /**
-     * Parsed URL of the incoming request
+     * Process a list of messages and return a filtered or transformed list.
+     * @param messages The messages to process
+     * @returns The processed messages
      */
-    url: URL;
+    process(messages: CoreMessage$1[], _opts: MemoryProcessorOpts): CoreMessage$1[];
+}
+declare const memoryDefaultOptions: {
+    lastMessages: number;
+    semanticRecall: false;
+    threads: {
+        generateTitle: false;
+    };
+    workingMemory: {
+        enabled: false;
+        template: string;
+    };
+};
+/**
+ * Abstract Memory class that defines the interface for storing and retrieving
+ * conversation threads and messages.
+ */
+declare abstract class MastraMemory extends MastraBase {
+    MAX_CONTEXT_TOKENS?: number;
+    _storage?: MastraStorage;
+    vector?: MastraVector;
+    embedder?: EmbeddingModel<string>;
+    private processors;
+    protected threadConfig: MemoryConfig;
+    constructor(config: {
+        name: string;
+    } & SharedMemoryConfig);
+    protected _hasOwnStorage: boolean;
+    get hasOwnStorage(): boolean;
+    get storage(): MastraStorage;
+    setStorage(storage: MastraStorage): void;
+    setVector(vector: MastraVector): void;
+    setEmbedder(embedder: EmbeddingModel<string>): void;
     /**
-     * Path for establishing the SSE connection (e.g. '/sse')
+     * 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.
      */
-    ssePath: string;
+    getSystemMessage(_input: {
+        threadId: string;
+        memoryConfig?: MemoryConfig;
+    }): Promise<string | null>;
     /**
-     * Path for POSTing client messages (e.g. '/message')
+     * 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.
      */
-    messagePath: string;
-}
-/**
- * Options for starting an MCP server with SSE transport
- */
-interface MCPServerSSEOptions extends MCPServerSSEOptionsBase {
+    getTools(_config?: MemoryConfig): Record<string, CoreTool>;
+    protected createEmbeddingIndex(dimensions?: number): Promise<{
+        indexName: string;
+    }>;
+    getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
     /**
-     * Incoming HTTP request
+     * Apply all configured message processors to a list of messages.
+     * @param messages The messages to process
+     * @returns The processed messages
      */
-    req: http.IncomingMessage;
+    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[];
     /**
-     * HTTP response (must support .write/.end)
+     * 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
      */
-    res: http.ServerResponse<http.IncomingMessage>;
-}
-/**
- * Options for starting an MCP server with Hono SSE transport
- */
-interface MCPServerHonoSSEOptions extends MCPServerSSEOptionsBase {
+    abstract getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    abstract getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
     /**
-     * Incoming Hono context
+     * Saves or updates a thread
+     * @param thread - The thread data to save
+     * @returns Promise resolving to the saved thread
      */
-    context: Context;
-}
-interface MCPServerHTTPOptions {
+    abstract saveThread({ thread, memoryConfig, }: {
+        thread: StorageThreadType;
+        memoryConfig?: MemoryConfig;
+    }): Promise<StorageThreadType>;
     /**
-     * Parsed URL of the incoming request
+     * Saves messages to a thread
+     * @param messages - Array of messages to save
+     * @returns Promise resolving to the saved messages
      */
-    url: URL;
+    abstract saveMessages({ messages, memoryConfig, }: {
+        messages: MessageType[];
+        memoryConfig: MemoryConfig | undefined;
+    }): Promise<MessageType[]>;
     /**
-     * Path for establishing the HTTP connection (e.g. '/mcp')
+     * Retrieves all messages for a specific thread
+     * @param threadId - The unique identifier of the thread
+     * @returns Promise resolving to array of messages and uiMessages
      */
-    httpPath: string;
+    abstract query({ threadId, resourceId, selectBy, }: StorageGetMessagesArg): Promise<{
+        messages: CoreMessage$1[];
+        uiMessages: Message[];
+    }>;
     /**
-     * Incoming HTTP request
+     * 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
      */
-    req: http.IncomingMessage;
+    createThread({ threadId, resourceId, title, metadata, memoryConfig, }: {
+        resourceId: string;
+        threadId?: string;
+        title?: string;
+        metadata?: Record<string, unknown>;
+        memoryConfig?: MemoryConfig;
+    }): Promise<StorageThreadType>;
     /**
-     * HTTP response (must support .write/.end)
+     * Helper method to delete a thread
+     * @param threadId - the id of the thread to delete
      */
-    res: http.ServerResponse<http.IncomingMessage>;
+    abstract deleteThread(threadId: string): Promise<void>;
     /**
-     * Optional options to pass to the transport (e.g. sessionIdGenerator)
+     * 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
      */
-    options?: any;
-}
-/** Describes a source code repository. */
-interface Repository {
-    /** The URL of the repository (e.g., a GitHub URL). */
-    url: string;
-    /** The source control platform (e.g., 'github', 'gitlab'). */
-    source: 'github' | 'gitlab' | string;
-    /** A unique identifier for the repository at the source. */
-    id: string;
-}
-/** Provides details about a specific version of an MCP server. */
-interface VersionDetail {
-    /** The semantic version string (e.g., "1.0.2"). */
-    version: string;
-    /** The ISO 8601 date-time string when this version was released or registered. */
-    release_date: string;
-    /** Indicates if this version is the latest available. */
-    is_latest: boolean;
+    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;
 }
-/** Base interface for command-line arguments. */
-interface ArgumentInfo {
-    /** The name of the argument. */
-    name: string;
-    /** A description of what the argument is for. */
-    description: string;
-    /** Whether the argument is required. */
-    is_required: boolean;
-    /** Whether the argument can be specified multiple times. */
-    is_repeatable?: boolean;
-    /** Whether the argument's value can be edited by the user (e.g., in a UI). */
-    is_editable?: boolean;
-    /** A list of predefined choices for the argument's value. */
-    choices?: string[];
-    /** The default value for the argument if not specified. */
-    default_value?: string | number | boolean;
+
+declare class MastraLLMBase extends MastraBase {
+    #private;
+    constructor({ name, model }: {
+        name: string;
+        model: LanguageModel$1;
+    });
+    getProvider(): string;
+    getModelId(): string;
+    getModel(): ai.LanguageModelV1;
+    convertToMessages(messages: string | string[] | CoreMessage$1[]): CoreMessage$1[];
+    __registerPrimitives(p: MastraPrimitives): void;
+    __registerMastra(p: Mastra): void;
+    __text<Z extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextOptions<Z>): Promise<GenerateTextResult<any, any>>;
+    __textObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<GenerateReturn<Z>>;
+    __stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(input: LLMInnerStreamOptions<Z>): Promise<StreamTextResult<any, any>>;
+    __streamObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMStreamObjectOptions<T>): Promise<StreamObjectResult<DeepPartial<T>, T, never>>;
+    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<StreamReturn<Z>>;
 }
-/** Describes a positional argument for a command. */
-interface PositionalArgumentInfo extends ArgumentInfo {
-    /** The 0-indexed position of the argument. */
-    position: number;
-}
-/** Describes a named argument (flag) for a command. */
-interface NamedArgumentInfo extends ArgumentInfo {
-    /** The short flag for the argument (e.g., "-y"). */
-    short_flag?: string;
-    /** The long flag for the argument (e.g., "--yes"). */
-    long_flag?: string;
-    /** Whether the flag requires a value (e.g., `--config <value>`) or is a boolean flag. */
-    requires_value?: boolean;
-}
-/** Describes a subcommand for a command-line tool. */
-interface SubcommandInfo {
-    /** The name of the subcommand (e.g., "run", "list"). */
-    name: string;
-    /** A description of what the subcommand does. */
-    description: string;
-    /** Whether this subcommand is required if its parent command is used. */
-    is_required?: boolean;
-    /** Nested subcommands. */
-    subcommands?: SubcommandInfo[];
-    /** Positional arguments for this subcommand. */
-    positional_arguments?: PositionalArgumentInfo[];
-    /** Named arguments (flags) for this subcommand. */
-    named_arguments?: NamedArgumentInfo[];
-}
-/** Describes a command to run an MCP server package. */
-interface CommandInfo {
-    /** The primary command executable (e.g., "npx", "docker"). */
-    name: 'npx' | 'docker' | 'pypi' | 'uvx' | string;
-    /** Subcommands to append to the primary command. */
-    subcommands?: SubcommandInfo[];
-    /** Positional arguments for the command. */
-    positional_arguments?: PositionalArgumentInfo[];
-    /** Named arguments (flags) for the command. */
-    named_arguments?: NamedArgumentInfo[];
-}
-/** Describes an environment variable required or used by an MCP server package. */
-interface EnvironmentVariableInfo {
-    /** The name of the environment variable (e.g., "API_KEY"). */
-    name: string;
-    /** A description of what the environment variable is for. */
-    description: string;
-    /** Whether the environment variable is required. */
-    required?: boolean;
-    /** The default value for the environment variable if not set. */
-    default_value?: string;
-}
-/** Describes an installable package for an MCP server. */
-interface PackageInfo {
-    /** The name of the package registry (e.g., "npm", "docker"). */
-    registry_name: 'npm' | 'docker' | 'pypi' | 'homebrew' | string;
-    /** The name of the package. */
-    name: string;
-    /** The version of the package. */
-    version: string;
-    /** The command structure to run this package as an MCP server. */
-    command?: CommandInfo;
-    /** Environment variables relevant to this package. */
-    environment_variables?: EnvironmentVariableInfo[];
-}
-/** Describes a remote endpoint for accessing an MCP server. */
-interface RemoteInfo {
-    /** The transport type for the remote connection (e.g., "sse", "streamable"). */
-    transport_type: 'streamable' | 'sse' | string;
-    /** The URL of the remote endpoint. */
-    url: string;
-}
-/** Configuration options for creating an MCPServer instance. */
-interface MCPServerConfig {
-    /** The display name of the MCP server. */
-    name: string;
-    /** The semantic version of the MCP server. */
-    version: string;
-    /** The tools that this MCP server will expose. */
-    tools: ToolsInput;
-    /**
-     * Optional unique identifier for the server.
-     * If not provided, a UUID will be generated.
-     * If provided, this ID is considered final and cannot be changed by Mastra.
-     */
-    id?: string;
-    /** Optional description of the MCP server. */
-    description?: string;
-    /** Optional repository information for the server's source code. */
-    repository?: Repository;
-    /**
-     * Optional release date of this server version (ISO 8601 string).
-     * Defaults to the time of instantiation if not provided.
-     */
-    releaseDate?: string;
-    /**
-     * Optional flag indicating if this is the latest version.
-     * Defaults to true if not provided.
-     */
-    isLatest?: boolean;
-    /**
-     * Optional canonical packaging format if the server is distributed as a package
-     * (e.g., "npm", "docker").
-     */
-    packageCanonical?: 'npm' | 'docker' | 'pypi' | 'crates' | string;
-    /** Optional list of installable packages for this server. */
-    packages?: PackageInfo[];
-    /** Optional list of remote access points for this server. */
-    remotes?: RemoteInfo[];
+
+declare function createMockModel({ objectGenerationMode, mockText, spyGenerate, spyStream, }: {
+    objectGenerationMode?: 'json';
+    mockText: string | Record<string, any>;
+    spyGenerate?: (props: any) => void;
+    spyStream?: (props: any) => void;
+}): MockLanguageModelV1;
+
+type LanguageModel = MastraLanguageModel;
+type CoreMessage = CoreMessage$1;
+type CoreSystemMessage = CoreSystemMessage$1;
+type CoreAssistantMessage = CoreAssistantMessage$1;
+type CoreUserMessage = CoreUserMessage$1;
+type CoreToolMessage = CoreToolMessage$1;
+type EmbedResult<T> = EmbedResult$1<T>;
+type EmbedManyResult<T> = EmbedManyResult$1<T>;
+type BaseStructuredOutputType = 'string' | 'number' | 'boolean' | 'date';
+type StructuredOutputType = 'array' | 'string' | 'number' | 'object' | 'boolean' | 'date';
+type StructuredOutputArrayItem = {
+    type: BaseStructuredOutputType;
+} | {
+    type: 'object';
+    items: StructuredOutput;
+};
+type StructuredOutput = {
+    [key: string]: {
+        type: BaseStructuredOutputType;
+    } | {
+        type: 'object';
+        items: StructuredOutput;
+    } | {
+        type: 'array';
+        items: StructuredOutputArrayItem;
+    };
+};
+type GenerateReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>;
+type StreamReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>;
+type OutputType = StructuredOutput | ZodSchema | JSONSchema7 | undefined;
+type GenerateTextOptions = Parameters<typeof generateText>[0];
+type StreamTextOptions = Parameters<typeof streamText>[0];
+type GenerateObjectOptions = Parameters<typeof generateObject>[0];
+type StreamObjectOptions = Parameters<typeof streamObject>[0];
+type MastraCustomLLMOptionsKeys = 'messages' | 'tools' | 'model' | 'onStepFinish' | 'experimental_output' | 'experimental_telemetry' | 'messages' | 'onFinish' | 'output';
+type DefaultLLMTextOptions = Omit<GenerateTextOptions, MastraCustomLLMOptionsKeys>;
+type DefaultLLMTextObjectOptions = Omit<GenerateObjectOptions, MastraCustomLLMOptionsKeys>;
+type DefaultLLMStreamOptions = Omit<StreamTextOptions, MastraCustomLLMOptionsKeys>;
+type DefaultLLMStreamObjectOptions = Omit<StreamObjectOptions, MastraCustomLLMOptionsKeys>;
+type MastraCustomLLMOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    tools?: Record<string, CoreTool>;
+    onStepFinish?: (step: unknown) => Promise<void> | void;
+    experimental_output?: Z;
+    telemetry?: TelemetrySettings;
+    threadId?: string;
+    resourceId?: string;
+    runtimeContext: RuntimeContext;
+} & Run$1;
+type LLMTextOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    messages: CoreMessage[];
+} & MastraCustomLLMOptions<Z> & DefaultLLMTextOptions;
+type LLMTextObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = LLMTextOptions<T> & DefaultLLMTextObjectOptions & {
+    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
+};
+type LLMStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    output?: OutputType | Z;
+    onFinish?: (result: string) => Promise<void> | void;
+} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
+type LLMInnerStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    messages: CoreMessage[];
+    onFinish?: (result: string) => Promise<void> | void;
+} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
+type LLMStreamObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
+} & LLMInnerStreamOptions<T> & DefaultLLMStreamObjectOptions;
+
+type VoiceEventType = 'speaking' | 'writing' | 'error' | string;
+interface VoiceEventMap {
+    speaker: NodeJS.ReadableStream;
+    speaking: {
+        audio?: string;
+    };
+    writing: {
+        text: string;
+        role: 'assistant' | 'user';
+    };
+    error: {
+        message: string;
+        code?: string;
+        details?: unknown;
+    };
+    [key: string]: unknown;
 }
-/** Basic information about an MCP server, conforming to the MCP Registry 'Server' schema. */
-interface ServerInfo {
-    /** The unique ID of the server. */
-    id: string;
-    /** The name of the server. */
+interface BuiltInModelConfig {
     name: string;
-    /** A description of the server. */
-    description?: string;
-    /** Repository information for the server. */
-    repository?: Repository;
-    /** Detailed version information. */
-    version_detail: VersionDetail;
+    apiKey?: string;
 }
-/** Detailed information about an MCP server, conforming to the MCP Registry 'ServerDetail' schema. */
-interface ServerDetailInfo extends ServerInfo {
-    /** The canonical packaging format, if applicable. */
-    package_canonical?: MCPServerConfig['packageCanonical'];
-    /** Information about installable packages for this server. */
-    packages?: PackageInfo[];
-    /** Information about remote access points for this server. */
-    remotes?: RemoteInfo[];
+interface VoiceConfig<T = unknown> {
+    listeningModel?: BuiltInModelConfig;
+    speechModel?: BuiltInModelConfig;
+    speaker?: string;
+    name?: string;
+    realtimeConfig?: {
+        model?: string;
+        apiKey?: string;
+        options?: T;
+    };
 }
-
-/**
- * Abstract base class for MCP server implementations.
- * This provides a common interface and shared functionality for all MCP servers
- * that can be registered with Mastra, including handling of server metadata.
- */
-declare abstract class MCPServerBase extends MastraBase {
-    /** Tracks if the server ID has been definitively set. */
-    private idWasSet;
-    /** The display name of the MCP server. */
-    readonly name: string;
-    /** The semantic version of the MCP server. */
-    readonly version: string;
-    /** Internal storage for the server's unique ID. */
-    private _id;
-    /** A description of what the MCP server does. */
-    readonly description?: string;
-    /** Repository information for the server's source code. */
-    readonly repository?: Repository;
-    /** The release date of this server version (ISO 8601 string). */
-    readonly releaseDate: string;
-    /** Indicates if this version is the latest available. */
-    readonly isLatest: boolean;
-    /** The canonical packaging format (e.g., "npm", "docker"), if applicable. */
-    readonly packageCanonical?: MCPServerConfig['packageCanonical'];
-    /** Information about installable packages for this server. */
-    readonly packages?: PackageInfo[];
-    /** Information about remote access points for this server. */
-    readonly remotes?: RemoteInfo[];
-    /** The tools registered with and converted by this MCP server. */
-    readonly convertedTools: Record<string, ConvertedTool>;
-    /** Reference to the Mastra instance if this server is registered with one. */
-    mastra: Mastra | undefined;
-    /**
-     * Public getter for the server's unique ID.
-     * The ID is set at construction or by Mastra and is read-only afterwards.
-     */
-    get id(): string;
-    /**
-     * Gets a read-only view of the registered tools.
-     * @returns A readonly record of converted tools.
-     */
-    tools(): Readonly<Record<string, ConvertedTool>>;
-    /**
-     * Sets the server's unique ID. This method is typically called by Mastra when
-     * registering the server, using the key provided in the Mastra configuration.
-     * It ensures the ID is set only once.
-     * If an ID was already provided in the MCPServerConfig, this method will be a no-op.
-     * @param id The unique ID to assign to the server.
-     */
-    setId(id: string): void;
+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;
     /**
-     * Abstract method to convert and validate tool definitions provided to the server.
-     * @param tools Tool definitions to convert.
-     * @returns A record of converted and validated tools.
+     * 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
      */
-    abstract convertTools(tools: ToolsInput): Record<string, ConvertedTool>;
     /**
-     * Internal method used by Mastra to register itself with the server.
-     * @param mastra The Mastra instance.
-     * @internal
+     * 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
      */
-    __registerMastra(mastra: Mastra): void;
+    abstract speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+    } & TSpeakOptions): Promise<NodeJS.ReadableStream | void>;
     /**
-     * Constructor for the MCPServerBase.
-     * @param config Configuration options for the MCP server, including metadata.
+     * Convert speech to text
+     * @param audioStream Audio stream to transcribe
+     * @param options Provider-specific transcription options
+     * @returns Text or text stream
      */
-    constructor(config: MCPServerConfig);
     /**
-     * Start the MCP server using stdio transport
-     * This is typically used for Windsurf integration
+     * 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 startStdio(): Promise<void>;
+    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;
     /**
-     * Start the MCP server using SSE transport
-     * This is typically used for web integration
-     * @param options Options for the SSE transport
+     * Initializes a WebSocket or WebRTC connection for real-time communication
+     * @returns Promise that resolves when the connection is established
      */
-    abstract startSSE(options: MCPServerSSEOptions): Promise<void>;
+    connect(_options?: Record<string, unknown>): Promise<void>;
     /**
-     * Start the MCP server using Hono SSE transport
-     * Used for Hono servers
-     * @param options Options for the SSE transport
+     * Relay audio data to the voice provider for real-time processing
+     * @param audioData Audio data to relay
      */
-    abstract startHonoSSE(options: MCPServerHonoSSEOptions): Promise<Response | undefined>;
+    send(_audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
     /**
-     * Start the MCP server using HTTP transport
-     * @param options Options for the HTTP transport
+     * Trigger voice providers to respond
      */
-    abstract startHTTP(options: MCPServerHTTPOptions): Promise<void>;
+    answer(_options?: Record<string, unknown>): Promise<void>;
     /**
-     * Close the MCP server and all its connections
+     * Equip the voice provider with instructions
+     * @param instructions Instructions to add
      */
-    abstract close(): Promise<void>;
+    addInstructions(_instructions?: string): void;
     /**
-     * Gets the basic information about the server, conforming to the MCP Registry 'Server' schema.
-     * This information is suitable for listing multiple servers.
-     * @returns ServerInfo object containing basic server metadata.
+     * Equip the voice provider with tools
+     * @param tools Array of tools to add
      */
-    abstract getServerInfo(): ServerInfo;
+    addTools(_tools: TTools): void;
     /**
-     * Gets detailed information about the server, conforming to the MCP Registry 'ServerDetail' schema.
-     * This includes all information from `getServerInfo` plus package and remote details.
-     * @returns ServerDetailInfo object containing comprehensive server metadata.
+     * Disconnect from the WebSocket or WebRTC connection
      */
-    abstract getServerDetail(): ServerDetailInfo;
+    close(): void;
     /**
-     * Gets a list of tools provided by this MCP server, including their schemas.
-     * @returns An object containing an array of tool information.
+     * Register an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function that receives event data
      */
-    abstract getToolListInfo(): {
-        tools: Array<{
-            name: string;
-            description?: string;
-            inputSchema: string;
-        }>;
-    };
+    on<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
     /**
-     * Gets information for a specific tool provided by this MCP server.
-     * @param toolId The ID/name of the tool to retrieve.
-     * @returns Tool information (name, description, inputSchema) or undefined if not found.
+     * Remove an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function to remove
      */
-    abstract getToolInfo(toolId: string): {
-        name: string;
-        description?: string;
-        inputSchema: string;
-    } | undefined;
+    off<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
     /**
-     * Executes a specific tool provided by this MCP server.
-     * @param toolId The ID/name of the tool to execute.
-     * @param args The arguments to pass to the tool's execute function.
-     * @param executionContext Optional context for the tool execution (e.g., messages, toolCallId).
-     * @returns A promise that resolves to the result of the tool execution.
-     * @throws Error if the tool is not found, or if execution fails.
+     * Get available speakers/voices
+     * @returns Array of available voice IDs and their metadata
      */
-    abstract executeTool(toolId: string, args: any, executionContext?: {
-        messages?: any[];
-        toolCallId?: string;
-    }): Promise<any>;
+    getSpeakers(): Promise<Array<{
+        voiceId: string;
+    } & TSpeakerMetadata>>;
 }
 
-type AgentNetworkConfig = {
-    name: string;
-    agents: Agent[];
-    model: LanguageModelV1;
-    instructions: string;
-};
-
-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;
-    }[];
+declare class CompositeVoice extends MastraVoice<unknown, unknown, unknown, ToolsInput, VoiceEventMap> {
+    protected speakProvider?: MastraVoice;
+    protected listenProvider?: MastraVoice;
+    protected realtimeProvider?: MastraVoice;
+    constructor({ input, output, realtime, speakProvider, listenProvider, realtimeProvider, }: {
+        /** @deprecated use output instead */
+        speakProvider?: MastraVoice;
+        /** @deprecated use input instead */
+        listenProvider?: MastraVoice;
+        /** @deprecated use realtime instead */
+        realtimeProvider?: MastraVoice;
+        input?: MastraVoice;
+        output?: MastraVoice;
+        realtime?: MastraVoice;
+    });
+    /**
+     * Convert text to speech using the configured provider
+     * @param input Text or text stream to convert to speech
+     * @param options Speech options including speaker and provider-specific options
+     * @returns Audio stream or void if in realtime mode
+     */
+    speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+    } & any): Promise<NodeJS.ReadableStream | void>;
+    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<string | void | NodeJS.ReadableStream>;
+    getSpeakers(): Promise<{
+        voiceId: string;
+    }[]>;
+    updateConfig(options: Record<string, unknown>): void;
     /**
-     * Get the history of all agent interactions that have occurred in this network
-     * @returns A record of agent interactions, keyed by agent ID
+     * Initializes a WebSocket or WebRTC connection for real-time communication
+     * @returns Promise that resolves when the connection is established
      */
-    getAgentInteractionHistory(): {
-        [x: string]: {
-            input: string;
-            output: string;
-            timestamp: string;
-        }[];
-    };
+    connect(options?: Record<string, unknown>): Promise<void>;
     /**
-     * Get a summary of agent interactions in a more readable format, displayed chronologically
-     * @returns A formatted string with all agent interactions in chronological order
+     * Relay audio data to the voice provider for real-time processing
+     * @param audioData Audio data to send
      */
-    getAgentInteractionSummary(): string;
-    executeAgent(agentId: string, input: CoreMessage$1[], includeHistory?: boolean, runtimeContext?: RuntimeContext): 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;
+    send(audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
+    /**
+     * Trigger voice providers to respond
+     */
+    answer(options?: Record<string, unknown>): Promise<void>;
+    /**
+     * Equip the voice provider with instructions
+     * @param instructions Instructions to add
+     */
+    addInstructions(instructions: string): void;
+    /**
+     * Equip the voice provider with tools
+     * @param tools Array of tools to add
+     */
+    addTools(tools: ToolsInput): void;
+    /**
+     * Disconnect from the WebSocket or WebRTC connection
+     */
+    close(): void;
+    /**
+     * Register an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function that receives event data
+     */
+    on<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
+    /**
+     * Remove an event listener
+     * @param event Event name (e.g., 'speaking', 'writing', 'error')
+     * @param callback Callback function to remove
+     */
+    off<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
+}
+
+declare class DefaultVoice extends MastraVoice {
+    constructor();
+    speak(_input: string | NodeJS.ReadableStream): Promise<NodeJS.ReadableStream>;
+    listen(_input: string | NodeJS.ReadableStream): Promise<string>;
+    getSpeakers(): Promise<{
+        voiceId: string;
+    }[]>;
 }
 
-interface WorkflowOptions<TWorkflowName extends string = string, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> {
+interface WorkflowOptions<TWorkflowName extends string = string, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> {
     steps?: TSteps;
     name: TWorkflowName;
     triggerSchema?: TTriggerSchema;
@@ -593,7 +583,7 @@ interface StepAction<TId extends string, TSchemaIn extends z.ZodSchema | undefin
     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;
+    workflow?: LegacyWorkflow;
     workflowId?: string;
 }
 interface SimpleConditionalType {
@@ -675,7 +665,7 @@ type Condition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchem
 } | {
     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>[]> {
+interface StepConfig<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[]> {
     when?: Condition<CondStep, TTriggerSchema> | ((args: {
         context: WorkflowContext<TTriggerSchema, TSteps>;
         mastra?: Mastra;
@@ -713,12 +703,12 @@ type StepSkipped = {
     status: 'skipped';
 };
 type StepResult$1<T> = StepSuccess$1<T> | StepFailure$1 | StepSuspended$1<T> | StepWaiting | StepSkipped;
-type StepsRecord$1<T extends readonly Step<any, any, z.ZodType<any> | undefined>[]> = {
+type StepsRecord$1<T extends readonly LegacyStep<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>> {
+interface LegacyWorkflowRunResult<T extends z.ZodObject<any>, TSteps extends LegacyStep<string, any, z.ZodType<any> | undefined>[], TResult extends z.ZodObject<any>> {
     triggerData?: z.infer<T>;
     result?: z.infer<TResult>;
     results: {
@@ -732,7 +722,7 @@ interface WorkflowRunResult<T extends z.ZodObject<any>, TSteps extends Step<stri
         stepPath: 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>> {
+interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extends LegacyStep<string, any, any, any>[] = LegacyStep<string, any, any, any>[], TInputData extends Record<string, any> = Record<string, any>> {
     isResume?: {
         runId: string;
         stepId: string;
@@ -746,7 +736,7 @@ interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extend
     attempts: Record<string, number>;
     getStepResult(stepId: 'trigger'): z.infer<TTrigger>;
     getStepResult<T extends keyof StepsRecord$1<TSteps> | unknown>(stepId: T extends keyof StepsRecord$1<TSteps> ? T : string): T extends keyof StepsRecord$1<TSteps> ? StepsRecord$1<TSteps>[T]['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<StepsRecord$1<TSteps>[T]['outputSchema']>> : T;
-    getStepResult<T extends Step<any, any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
+    getStepResult<T extends LegacyStep<any, any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
 }
 interface WorkflowLogMessage extends BaseLogMessage {
     type: typeof RegisteredLogger.WORKFLOW;
@@ -844,7 +834,7 @@ type WorkflowActions = {
     type: 'updateStepResult' | 'setStepError' | 'notifyStepCompletion' | 'decrementAttemptCount';
     params: WorkflowActionParams;
 };
-type WorkflowState = {
+type LegacyWorkflowState = {
     [key: string]: {
         initial: 'pending';
         states: {
@@ -918,7 +908,7 @@ type ExtractSchemaType$1<T extends z.ZodSchema> = T extends z.ZodSchema<infer V>
 type PathsToStringProps$1<T> = T extends object ? {
     [K in keyof T]: T[K] extends object ? K extends string ? K | `${K}.${PathsToStringProps$1<T[K]>}` : never : K extends string ? K : never;
 }[keyof T] : never;
-interface WorkflowRunState {
+interface LegacyWorkflowRunState {
     value: Record<string, string>;
     context: {
         steps: Record<string, {
@@ -937,7 +927,7 @@ interface WorkflowRunState {
     suspendedPaths: Record<string, number[]>;
     runId: string;
     timestamp: number;
-    childStates?: Record<string, WorkflowRunState>;
+    childStates?: Record<string, LegacyWorkflowRunState>;
     suspendedSteps?: Record<string, string>;
 }
 type WorkflowResumeResult<TTriggerSchema extends z.ZodObject<any>> = {
@@ -945,7 +935,7 @@ type WorkflowResumeResult<TTriggerSchema extends z.ZodObject<any>> = {
     results: Record<string, StepResult$1<any>>;
 };
 
-declare class Step<TStepId extends string = any, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends StepExecutionContext<TSchemaIn> = StepExecutionContext<TSchemaIn>> implements StepAction<TStepId, TSchemaIn, TSchemaOut, TContext> {
+declare class LegacyStep<TStepId extends string = any, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends StepExecutionContext<TSchemaIn> = StepExecutionContext<TSchemaIn>> implements StepAction<TStepId, TSchemaIn, TSchemaOut, TContext> {
     id: TStepId;
     description?: string;
     inputSchema?: TSchemaIn;
@@ -957,12 +947,12 @@ declare class Step<TStepId extends string = any, TSchemaIn extends z.ZodSchema |
     constructor({ id, description, execute, payload, outputSchema, inputSchema, retryConfig, }: StepAction<TStepId, TSchemaIn, TSchemaOut, TContext>);
 }
 
-declare class Machine<TSteps extends Step<any, any, any, any>[] = Step<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends EventEmitter {
+declare class Machine<TSteps extends LegacyStep<any, any, any, any>[] = LegacyStep<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends EventEmitter {
     #private;
-    logger: Logger;
+    logger: IMastraLogger;
     name: string;
     constructor({ logger, mastra, runtimeContext, workflowInstance, executionSpan, name, runId, steps, stepGraph, retryConfig, startStepId, }: {
-        logger: Logger;
+        logger: IMastraLogger;
         mastra?: Mastra;
         runtimeContext: RuntimeContext;
         workflowInstance: WorkflowInstance;
@@ -980,9 +970,9 @@ declare class Machine<TSteps extends Step<any, any, any, any>[] = Step<any, any,
         input?: any;
         snapshot?: Snapshot<any>;
         resumeData?: any;
-    }): Promise<Pick<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>>;
+    }): Promise<Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>>;
     private initializeMachine;
-    getSnapshot(): xstate.MachineSnapshot<Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
+    getSnapshot(): xstate.MachineSnapshot<Omit<WorkflowContext<any, LegacyStep<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
         type: "RESET_TO_PENDING";
         stepId: string;
     } | {
@@ -1244,8 +1234,8 @@ declare class Machine<TSteps extends Step<any, any, any, any>[] = Step<any, any,
                     syncSnapshot?: boolean;
                 } & { [K in xstate.RequiredLogicInput<TLogic>]: unknown; }) | undefined], xstate.IsNotNever<xstate.RequiredLogicInput<TLogic>>>): xstate.ActorRefFromLogic<TLogic>;
             };
-            input: Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">;
-            self: xstate.ActorRef<xstate.MachineSnapshot<Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
+            input: Omit<WorkflowContext<any, LegacyStep<string, any, any, any>[], Record<string, any>>, "getStepResult">;
+            self: xstate.ActorRef<xstate.MachineSnapshot<Omit<WorkflowContext<any, LegacyStep<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
                 type: "RESET_TO_PENDING";
                 stepId: string;
             } | {
@@ -1332,30 +1322,30 @@ declare class Machine<TSteps extends Step<any, any, any, any>[] = Step<any, any,
     }> | undefined;
 }
 
-interface WorkflowResultReturn<TResult extends z.ZodObject<any>, T extends z.ZodObject<any>, TSteps extends Step<any, any, any>[]> {
+interface WorkflowResultReturn<TResult extends z.ZodObject<any>, T extends z.ZodObject<any>, TSteps extends LegacyStep<any, any, any>[]> {
     runId: string;
     start: (props?: {
         triggerData?: z.infer<T>;
         runtimeContext?: RuntimeContext;
-    } | undefined) => Promise<WorkflowRunResult<T, TSteps, TResult>>;
-    watch: (onTransition: (state: Pick<WorkflowRunResult<T, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void) => () => void;
+    } | undefined) => Promise<LegacyWorkflowRunResult<T, TSteps, TResult>>;
+    watch: (onTransition: (state: Pick<LegacyWorkflowRunResult<T, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void) => () => void;
     resume: (props: {
         stepId: string;
         context?: Record<string, any>;
         runtimeContext?: RuntimeContext;
-    }) => Promise<Omit<WorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
-    resumeWithEvent: (eventName: string, data: any, runtimeContext?: RuntimeContext) => Promise<Omit<WorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
+    }) => Promise<Omit<LegacyWorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
+    resumeWithEvent: (eventName: string, data: any, runtimeContext?: RuntimeContext) => Promise<Omit<LegacyWorkflowRunResult<T, TSteps, TResult>, 'runId'> | undefined>;
 }
-declare class WorkflowInstance<TSteps extends Step<any, any, any, any>[] = Step<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResult extends z.ZodObject<any> = any> implements WorkflowResultReturn<TResult, TTriggerSchema, TSteps> {
+declare class WorkflowInstance<TSteps extends LegacyStep<any, any, any, any>[] = LegacyStep<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResult extends z.ZodObject<any> = any> implements WorkflowResultReturn<TResult, TTriggerSchema, TSteps> {
     #private;
     name: string;
-    logger: Logger;
+    logger: IMastraLogger;
     events?: Record<string, {
         schema: z.ZodObject<any>;
     }>;
     constructor({ name, logger, steps, runId, retryConfig, mastra, stepGraph, stepSubscriberGraph, onFinish, onStepTransition, resultMapping, events, }: {
         name: string;
-        logger: Logger;
+        logger: IMastraLogger;
         steps: Record<string, StepNode>;
         mastra?: Mastra;
         retryConfig?: RetryConfig;
@@ -1363,7 +1353,7 @@ declare class WorkflowInstance<TSteps extends Step<any, any, any, any>[] = Step<
         stepGraph: StepGraph;
         stepSubscriberGraph: Record<string, StepGraph>;
         onFinish?: () => void;
-        onStepTransition?: Set<(state: Pick<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void | Promise<void>>;
+        onStepTransition?: Set<(state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void | Promise<void>>;
         resultMapping?: Record<string, {
             step: StepAction<any, any, any, any>;
             path: string;
@@ -1375,16 +1365,16 @@ declare class WorkflowInstance<TSteps extends Step<any, any, any, any>[] = Step<
     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;
+    watch(onTransition: (state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
     start({ triggerData, runtimeContext, }?: {
         triggerData?: z.infer<TTriggerSchema>;
         runtimeContext?: RuntimeContext;
     }): Promise<{
         runId: string;
         result?: z.TypeOf<TResult> | undefined;
-        timestamp: number;
         triggerData?: z.TypeOf<TTriggerSchema> | undefined;
         results: { [K in keyof StepsRecord$1<TSteps>]: StepsRecord$1<TSteps>[K]["outputSchema"] extends undefined ? StepResult$1<unknown> : StepResult$1<z.TypeOf<NonNullable<StepsRecord$1<TSteps>[K]["outputSchema"]>>>; };
+        timestamp: number;
         activePaths: Map<TSteps[number]["id"], {
             status: string;
             suspendPayload?: any;
@@ -1398,30 +1388,30 @@ declare class WorkflowInstance<TSteps extends Step<any, any, any, any>[] = Step<
         snapshot?: Snapshot<any>;
         resumeData?: any;
         runtimeContext: RuntimeContext;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'runId'>>;
+    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, 'runId'>>;
     hasSubscribers(stepId: string): boolean;
-    runMachine(parentStepId: string, input: any, runtimeContext?: RuntimeContext): Promise<(Pick<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId" | "timestamp" | "results" | "activePaths"> | undefined)[]>;
+    runMachine(parentStepId: string, input: any, runtimeContext?: RuntimeContext): Promise<(Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId" | "results" | "timestamp" | "activePaths"> | undefined)[]>;
     suspend(stepId: string, machine: Machine<TSteps, TTriggerSchema>): Promise<void>;
     /**
      * Persists the workflow state to the database
      */
     persistWorkflowSnapshot(): Promise<void>;
-    getState(): Promise<WorkflowRunState | null>;
-    resumeWithEvent(eventName: string, data: any, runtimeContext?: RuntimeContext): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    getState(): Promise<LegacyWorkflowRunState | null>;
+    resumeWithEvent(eventName: string, data: any, runtimeContext?: RuntimeContext): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
     resume({ stepId, context: resumeContext, runtimeContext, }: {
         stepId: string;
         context?: Record<string, any>;
         runtimeContext?: RuntimeContext;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
     _resume({ stepId, context: resumeContext, runtimeContext, }: {
         stepId: string;
         context?: Record<string, any>;
         runtimeContext: RuntimeContext;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps, TResult>, "runId"> | undefined>;
+    }): Promise<Omit<LegacyWorkflowRunResult<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 {
+type WorkflowBuilder<T extends LegacyWorkflow<any, any>> = Pick<T, 'step' | 'then' | 'after' | 'while' | 'until' | 'if' | 'else' | 'afterEvent' | 'commit'>;
+declare class LegacyWorkflow<TSteps extends LegacyStep<string, any, any>[] = LegacyStep<string, any, any>[], TStepId extends string = string, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends MastraBase {
     #private;
     name: TStepId;
     triggerSchema?: TTriggerSchema;
@@ -1435,24 +1425,24 @@ declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, an
     }>;
     isNested: boolean;
     /**
-     * Creates a new Workflow instance
+     * Creates a new LegacyWorkflow instance
      * @param name - Identifier for the workflow (not necessarily unique)
      * @param logger - Optional logger instance
      */
     constructor({ name, triggerSchema, result, retryConfig, mastra, events, }: WorkflowOptions<TStepId, TSteps, TTriggerSchema, TResultSchema>);
-    step<TWorkflow extends 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<TWorkflow extends LegacyWorkflow<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(next: TWorkflow, config?: StepConfig<ReturnType<TWorkflow['toStep']>, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
     step<TAgent extends Agent<any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(next: TAgent, config?: StepConfig<ReturnType<TAgent['toStep']>, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
     step<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, Steps extends StepAction<any, any, any, any>[] = TSteps>(step: TStep, config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema, Steps>): WorkflowBuilder<this>;
     then<TStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TStep | TStep[], config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema>): this;
-    then<TWorkflow extends 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<TWorkflow extends LegacyWorkflow<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TWorkflow | TWorkflow[], config?: StepConfig<StepAction<string, any, any, any>, CondStep, VarStep, TTriggerSchema>): this;
     then<TAgent extends Agent<any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(next: TAgent | TAgent[], config?: StepConfig<StepAction<string, any, any, any>, CondStep, VarStep, TTriggerSchema>): this;
     private loop;
     while<FallbackStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['when'], fallbackStep: FallbackStep, variables?: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['variables']): Pick<WorkflowBuilder<this>, "then" | "commit">;
     until<FallbackStep extends StepAction<string, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['when'], fallbackStep: FallbackStep, variables?: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['variables']): Pick<WorkflowBuilder<this>, "then" | "commit">;
-    if<TStep extends StepAction<string, any, any, any>>(condition: StepConfig<TStep, any, any, TTriggerSchema>['when'], ifStep?: TStep | Workflow, elseStep?: TStep | Workflow): this | WorkflowBuilder<this>;
+    if<TStep extends StepAction<string, any, any, any>>(condition: StepConfig<TStep, any, any, TTriggerSchema>['when'], ifStep?: TStep | LegacyWorkflow, elseStep?: TStep | LegacyWorkflow): this | WorkflowBuilder<this>;
     else(): WorkflowBuilder<this>;
     after<TStep extends StepAction<string, any, any, any>>(steps: string | TStep | TStep[] | (TStep | string)[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
-    after<TWorkflow extends Workflow<any, any, any, any>>(steps: TWorkflow | TWorkflow[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
+    after<TWorkflow extends LegacyWorkflow<any, any, any, any>>(steps: TWorkflow | TWorkflow[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
     after<TAgent extends Agent<any, any, any>>(steps: TAgent | TAgent[]): Omit<WorkflowBuilder<this>, 'then' | 'after'>;
     afterEvent(eventName: string): WorkflowBuilder<this>;
     /**
@@ -1494,17 +1484,17 @@ declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, an
         limit?: number;
         offset?: number;
         resourceId?: string;
-    }): Promise<WorkflowRuns>;
+    }): Promise<LegacyWorkflowRuns>;
     getExecutionSpan(runId: string): Span | undefined;
-    getState(runId: string): Promise<WorkflowRunState | null>;
+    getState(runId: string): Promise<LegacyWorkflowRunState | null>;
     resume({ runId, stepId, context: resumeContext, runtimeContext, }: {
         runId: string;
         stepId: string;
         context?: Record<string, any>;
         runtimeContext: RuntimeContext;
-    }): 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>;
+    }): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
+    watch(onTransition: (state: Pick<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>) => void): () => void;
+    resumeWithEvent(runId: string, eventName: string, data: any): Promise<Omit<LegacyWorkflowRunResult<TTriggerSchema, TSteps, any>, "runId"> | undefined>;
     __registerMastra(mastra: Mastra): void;
     __registerPrimitives(p: MastraPrimitives): void;
     get stepGraph(): StepGraph;
@@ -1513,7 +1503,7 @@ declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, an
     get serializedStepSubscriberGraph(): Record<string, StepGraph>;
     get steps(): Record<string, StepAction<string, any, any, any>>;
     setNested(isNested: boolean): void;
-    toStep(): Step<TStepId, TTriggerSchema, z.ZodType<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
+    toStep(): LegacyStep<TStepId, TTriggerSchema, z.ZodType<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
 }
 
 type ExecuteFunction<TStepInput, TStepOutput, TResumeSchema, TSuspendSchema> = (params: {
@@ -1522,8 +1512,8 @@ type ExecuteFunction<TStepInput, TStepOutput, TResumeSchema, TSuspendSchema> = (
     inputData: TStepInput;
     resumeData?: TResumeSchema;
     getInitData<T extends z.ZodType<any>>(): z.infer<T>;
-    getInitData<T extends NewWorkflow<any, any, any, any, any>>(): T extends undefined ? unknown : z.infer<NonNullable<T['inputSchema']>>;
-    getStepResult<T extends NewStep<any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
+    getInitData<T extends Workflow<any, any, any, any, any>>(): T extends undefined ? unknown : z.infer<NonNullable<T['inputSchema']>>;
+    getStepResult<T extends Step<any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
     suspend(suspendPayload: TSuspendSchema): Promise<void>;
     resume?: {
         steps: string[];
@@ -1533,7 +1523,7 @@ type ExecuteFunction<TStepInput, TStepOutput, TResumeSchema, TSuspendSchema> = (
         emit: (event: string, data: any) => Promise<void>;
     };
 }) => Promise<TStepOutput>;
-interface NewStep<TStepId extends string = string, TSchemaIn extends z.ZodType<any> = z.ZodType<any>, TSchemaOut extends z.ZodType<any> = z.ZodType<any>, TResumeSchema extends z.ZodType<any> = z.ZodType<any>, TSuspendSchema extends z.ZodType<any> = z.ZodType<any>> {
+interface Step<TStepId extends string = string, TSchemaIn extends z.ZodType<any> = z.ZodType<any>, TSchemaOut extends z.ZodType<any> = z.ZodType<any>, TResumeSchema extends z.ZodType<any> = z.ZodType<any>, TSuspendSchema extends z.ZodType<any> = z.ZodType<any>> {
     id: TStepId;
     description?: string;
     inputSchema: TSchemaIn;
@@ -1557,7 +1547,7 @@ type StepSuspended<T> = {
     payload: T;
 };
 type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended<T>;
-type StepsRecord<T extends readonly NewStep<any, any, any>[]> = {
+type StepsRecord<T extends readonly Step<any, any, any>[]> = {
     [K in T[number]['id']]: Extract<T[number], {
         id: K;
     }>;
@@ -1570,8 +1560,8 @@ type PathsToStringProps<T> = T extends object ? {
     [K in keyof T]: T[K] extends object ? K extends string ? K | `${K}.${PathsToStringProps<T[K]>}` : never : K extends string ? K : never;
 }[keyof T] : never;
 type ExtractSchemaType<T extends z.ZodType<any>> = T extends z.ZodObject<infer V> ? V : never;
-type ExtractSchemaFromStep<TStep extends NewStep<any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
-type VariableReference<TStep extends NewStep<string, any, any> = NewStep<string, any, any>, TVarPath extends PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.' = PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.'> = {
+type ExtractSchemaFromStep<TStep extends Step<any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
+type VariableReference<TStep extends Step<string, any, any> = Step<string, any, any>, TVarPath extends PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.' = PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.'> = {
     step: TStep;
     path: TVarPath;
 } | {
@@ -1601,7 +1591,7 @@ type WatchEvent = {
     eventTimestamp: Date;
 };
 type ZodPathType<T extends z.ZodTypeAny, P extends string> = T extends z.ZodObject<infer Shape> ? P extends `${infer Key}.${infer Rest}` ? Key extends keyof Shape ? Shape[Key] extends z.ZodTypeAny ? ZodPathType<Shape[Key], Rest> : never : never : P extends keyof Shape ? Shape[P] : never : never;
-interface VNextWorkflowRunState {
+interface WorkflowRunState {
     runId: string;
     value: Record<string, string>;
     context: {
@@ -1659,7 +1649,7 @@ declare abstract class ExecutionEngine extends MastraBase {
 
 type StepFlowEntry = {
     type: 'step';
-    step: NewStep;
+    step: Step;
 } | {
     type: 'parallel';
     steps: StepFlowEntry[];
@@ -1673,7 +1663,7 @@ type StepFlowEntry = {
     }[];
 } | {
     type: 'loop';
-    step: NewStep;
+    step: Step;
     condition: ExecuteFunction<any, any, any, any>;
     serializedCondition: {
         id: string;
@@ -1682,12 +1672,12 @@ type StepFlowEntry = {
     loopType: 'dowhile' | 'dountil';
 } | {
     type: 'foreach';
-    step: NewStep;
+    step: Step;
     opts: {
         concurrency: number;
     };
 };
-type SerializedStep = Pick<NewStep, 'id' | 'description'> & {
+type SerializedStep = Pick<Step, 'id' | 'description'> & {
     component?: string;
     serializedStepFlow?: SerializedStepFlowEntry[];
 };
@@ -1737,25 +1727,25 @@ declare function createStep<TStepId extends string, TStepInput extends z.ZodType
     resumeSchema?: TResumeSchema;
     suspendSchema?: TSuspendSchema;
     execute: ExecuteFunction<z.infer<TStepInput>, z.infer<TStepOutput>, z.infer<TResumeSchema>, z.infer<TSuspendSchema>>;
-}): NewStep<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema>;
+}): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema>;
 declare function createStep<TStepId extends string, TStepInput extends z.ZodObject<{
     prompt: z.ZodString;
 }>, TStepOutput extends z.ZodObject<{
     text: z.ZodString;
-}>, TResumeSchema extends z.ZodType<any>, TSuspendSchema extends z.ZodType<any>>(agent: Agent<TStepId, any, any>): NewStep<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema>;
+}>, TResumeSchema extends z.ZodType<any>, TSuspendSchema extends z.ZodType<any>>(agent: Agent<TStepId, any, any>): Step<TStepId, TStepInput, TStepOutput, TResumeSchema, TSuspendSchema>;
 declare function createStep<TSchemaIn extends z.ZodType<any>, TSchemaOut extends z.ZodType<any>, TContext extends ToolExecutionContext<TSchemaIn>>(tool: Tool<TSchemaIn, TSchemaOut, TContext> & {
     inputSchema: TSchemaIn;
     outputSchema: TSchemaOut;
     execute: (context: TContext) => Promise<any>;
-}): NewStep<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>>;
-declare function cloneStep<TStepId extends string>(step: NewStep<string, any, any>, opts: {
+}): Step<string, TSchemaIn, TSchemaOut, z.ZodType<any>, z.ZodType<any>>;
+declare function cloneStep<TStepId extends string>(step: Step<string, any, any>, opts: {
     id: TStepId;
-}): NewStep<TStepId, any, any>;
-declare function createWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends NewStep<string, any, any, any, any>[] = NewStep<string, any, any, any, any>[]>(params: NewWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TInput>;
-declare function cloneWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends NewStep<string, any, any, any, any>[] = NewStep<string, any, any, any, any>[]>(workflow: NewWorkflow<TSteps, string, TInput, TOutput>, opts: {
+}): Step<TStepId, any, any>;
+declare function createWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]>(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TInput>;
+declare function cloneWorkflow<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]>(workflow: Workflow<TSteps, string, TInput, TOutput>, opts: {
     id: TWorkflowId;
-}): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput>;
-type WorkflowResult<TOutput extends z.ZodType<any>, TSteps extends NewStep<string, any, any>[]> = {
+}): Workflow<TSteps, TWorkflowId, TInput, TOutput>;
+type WorkflowResult<TOutput extends z.ZodType<any>, TSteps extends Step<string, any, any>[]> = {
     status: 'success';
     result: z.infer<TOutput>;
     steps: {
@@ -1774,7 +1764,7 @@ type WorkflowResult<TOutput extends z.ZodType<any>, TSteps extends NewStep<strin
     };
     suspended: [string[], ...string[][]];
 };
-type NewWorkflowConfig<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends NewStep<string, any, any, any, any>[] = NewStep<string, any, any, any, any>[]> = {
+type WorkflowConfig<TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[]> = {
     mastra?: Mastra;
     id: TWorkflowId;
     description?: string | undefined;
@@ -1787,13 +1777,13 @@ type NewWorkflowConfig<TWorkflowId extends string = string, TInput extends z.Zod
         delay?: number;
     };
 };
-declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] = NewStep<string, any, any, any, any>[], TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TPrevSchema extends z.ZodType<any> = TInput> extends MastraBase implements NewStep<TWorkflowId, TInput, TOutput> {
+declare class Workflow<TSteps extends Step<string, any, any, any, any>[] = Step<string, any, any, any, any>[], TWorkflowId extends string = string, TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>, TPrevSchema extends z.ZodType<any> = TInput> extends MastraBase implements Step<TWorkflowId, TInput, TOutput> {
     #private;
     id: TWorkflowId;
     description?: string | undefined;
     inputSchema: TInput;
     outputSchema: TOutput;
-    steps: Record<string, NewStep<string, any, any, any, any>>;
+    steps: Record<string, Step<string, any, any, any, any>>;
     stepDefs?: TSteps;
     protected stepFlow: StepFlowEntry[];
     protected serializedStepFlow: SerializedStepFlowEntry[];
@@ -1803,9 +1793,9 @@ declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] =
         attempts?: number;
         delay?: number;
     };
-    constructor({ mastra, id, inputSchema, outputSchema, description, executionEngine, retryConfig, steps, }: NewWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>);
+    constructor({ mastra, id, inputSchema, outputSchema, description, executionEngine, retryConfig, steps, }: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>);
     get runs(): Map<string, Run<TSteps, TInput, TOutput>>;
-    get mastra(): Mastra<Record<string, Agent<any, ToolsInput, Record<string, Metric>>>, Record<string, Workflow<Step<string, any, any, StepExecutionContext<any, WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>>>[], string, any, any>>, Record<string, NewWorkflow<NewStep<string, any, any, any, any>[], string, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger, Record<string, AgentNetwork>, Record<string, MCPServerBase>> | undefined;
+    get mastra(): Mastra<Record<string, Agent<any, ToolsInput, Record<string, Metric>>>, Record<string, LegacyWorkflow<LegacyStep<string, any, any, StepExecutionContext<any, WorkflowContext<any, LegacyStep<string, any, any, any>[], Record<string, any>>>>[], string, any, any>>, Record<string, Workflow<Step<string, any, any, any, any>[], string, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>>>, Record<string, MastraVector>, Record<string, MastraTTS>, IMastraLogger, Record<string, AgentNetwork>, Record<string, MCPServerBase>> | undefined;
     __registerMastra(mastra: Mastra): void;
     __registerPrimitives(p: MastraPrimitives): void;
     setStepFlow(stepFlow: StepFlowEntry[]): void;
@@ -1814,8 +1804,8 @@ declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] =
      * @param step The step to add to the workflow
      * @returns The workflow instance for chaining
      */
-    then<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
-    map<TSteps extends NewStep<string, any, any>[], TMapping extends {
+    then<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    map<TSteps extends Step<string, any, any>[], TMapping extends {
         [K in keyof TMapping]: {
             step: TSteps[number] | TSteps[number][];
             path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TSteps[number], 'outputSchema'>>> | '.';
@@ -1829,17 +1819,17 @@ declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] =
             runtimeContextPath: string;
             schema: z.ZodTypeAny;
         } | DynamicMapping<TPrevSchema, z.ZodTypeAny>;
-    }>(mappingConfig: TMapping | ExecuteFunction<z.infer<TPrevSchema>, any, any, any>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, any>;
-    parallel<TParallelSteps extends NewStep<string, TPrevSchema, any, any, any>[]>(steps: TParallelSteps): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodObject<{ [K in keyof StepsRecord<TParallelSteps>]: StepsRecord<TParallelSteps>[K]["outputSchema"]["path"]; }, any, z.ZodTypeAny>>;
+    }>(mappingConfig: TMapping | ExecuteFunction<z.infer<TPrevSchema>, any, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, any>;
+    parallel<TParallelSteps extends Step<string, TPrevSchema, any, any, any>[]>(steps: TParallelSteps): Workflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodObject<{ [K in keyof StepsRecord<TParallelSteps>]: StepsRecord<TParallelSteps>[K]["outputSchema"]["path"]; }, any, z.ZodTypeAny>>;
     branch<TBranchSteps extends Array<[
         ExecuteFunction<z.infer<TPrevSchema>, any, any, any>,
-        NewStep<string, TPrevSchema, any, any, any>
-    ]>>(steps: TBranchSteps): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodObject<{ [K in keyof StepsRecord<{ [K_1 in keyof TBranchSteps]: TBranchSteps[K_1][1]; }[number][]>]: StepsRecord<{ [K_1 in keyof TBranchSteps]: TBranchSteps[K_1][1]; }[number][]>[K]["outputSchema"]; }, any, z.ZodTypeAny>>;
-    dowhile<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
-    dountil<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
-    foreach<TPrevIsArray extends TPrevSchema extends z.ZodArray<any> ? true : false, TStepInputSchema extends TPrevSchema extends z.ZodArray<infer TElement> ? TElement : never, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: TPrevIsArray extends true ? NewStep<TStepId, TStepInputSchema, TSchemaOut, any, any> : 'Previous step must return an array type', opts?: {
+        Step<string, TPrevSchema, any, any, any>
+    ]>>(steps: TBranchSteps): Workflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodObject<{ [K in keyof StepsRecord<{ [K_1 in keyof TBranchSteps]: TBranchSteps[K_1][1]; }[number][]>]: StepsRecord<{ [K_1 in keyof TBranchSteps]: TBranchSteps[K_1][1]; }[number][]>[K]["outputSchema"]; }, any, z.ZodTypeAny>>;
+    dowhile<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    dountil<TStepInputSchema extends TPrevSchema, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: Step<TStepId, TStepInputSchema, TSchemaOut, any, any>, condition: ExecuteFunction<z.infer<TSchemaOut>, any, any, any>): Workflow<TSteps, TWorkflowId, TInput, TOutput, TSchemaOut>;
+    foreach<TPrevIsArray extends TPrevSchema extends z.ZodArray<any> ? true : false, TStepInputSchema extends TPrevSchema extends z.ZodArray<infer TElement> ? TElement : never, TStepId extends string, TSchemaOut extends z.ZodType<any>>(step: TPrevIsArray extends true ? Step<TStepId, TStepInputSchema, TSchemaOut, any, any> : 'Previous step must return an array type', opts?: {
         concurrency: number;
-    }): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodArray<TSchemaOut>>;
+    }): Workflow<TSteps, TWorkflowId, TInput, TOutput, z.ZodArray<TSchemaOut>>;
     /**
      * Builds the execution graph for this workflow
      * @returns The execution graph that can be used to execute the workflow
@@ -1850,7 +1840,7 @@ declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] =
      * This method should be called after all steps have been added to the workflow
      * @returns A built workflow instance ready for execution
      */
-    commit(): NewWorkflow<TSteps, TWorkflowId, TInput, TOutput, TOutput>;
+    commit(): Workflow<TSteps, TWorkflowId, TInput, TOutput, TOutput>;
     get stepGraph(): StepFlowEntry[];
     get serializedStepGraph(): SerializedStepFlowEntry[];
     /**
@@ -1861,10 +1851,10 @@ declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] =
     createRun(options?: {
         runId?: string;
     }): Run<TSteps, TInput, TOutput>;
-    execute({ inputData, resumeData, suspend, resume, emitter, mastra, }: {
+    execute({ inputData, resumeData, suspend, resume, emitter, mastra, runtimeContext, }: {
         inputData: z.infer<TInput>;
         resumeData?: any;
-        getStepResult<T extends NewStep<any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
+        getStepResult<T extends Step<any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
         suspend: (suspendPayload: any) => Promise<void>;
         resume?: {
             steps: string[];
@@ -1875,6 +1865,7 @@ declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] =
             emit: (event: string, data: any) => void;
         };
         mastra: Mastra;
+        runtimeContext?: RuntimeContext;
     }): Promise<z.infer<TOutput>>;
     getWorkflowRuns(args?: {
         fromDate?: Date;
@@ -1882,657 +1873,667 @@ declare class NewWorkflow<TSteps extends NewStep<string, any, any, any, any>[] =
         limit?: number;
         offset?: number;
         resourceId?: string;
-    }): Promise<VNextWorkflowRuns>;
-    getWorkflowRunById(runId: string): Promise<VNextWorkflowRun | null>;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById(runId: string): Promise<WorkflowRun | null>;
 }
 /**
  * Represents a workflow run that can be executed
  */
-declare class Run<TSteps extends NewStep<string, any, any>[] = NewStep<string, any, any>[], TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>> {
+declare class Run<TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TInput extends z.ZodType<any> = z.ZodType<any>, TOutput extends z.ZodType<any> = z.ZodType<any>> {
+    #private;
+    protected emitter: EventEmitter$1;
+    /**
+     * Unique identifier for this workflow
+     */
+    readonly workflowId: string;
+    /**
+     * Unique identifier for this run
+     */
+    readonly runId: string;
+    /**
+     * Internal state of the workflow run
+     */
+    protected state: Record<string, any>;
+    /**
+     * The execution engine for this run
+     */
+    executionEngine: ExecutionEngine;
+    /**
+     * The execution graph for this run
+     */
+    executionGraph: ExecutionGraph;
+    protected cleanup?: () => void;
+    protected retryConfig?: {
+        attempts?: number;
+        delay?: number;
+    };
+    constructor(params: {
+        workflowId: string;
+        runId: string;
+        executionEngine: ExecutionEngine;
+        executionGraph: ExecutionGraph;
+        mastra?: Mastra;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        cleanup?: () => void;
+    });
+    /**
+     * Starts the workflow execution with the provided input
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    start({ inputData, runtimeContext, }: {
+        inputData?: z.infer<TInput>;
+        runtimeContext?: RuntimeContext;
+    }): Promise<WorkflowResult<TOutput, TSteps>>;
+    watch(cb: (event: WatchEvent) => void): () => void;
+    resume<TResumeSchema extends z.ZodType<any>>(params: {
+        resumeData?: z.infer<TResumeSchema>;
+        step: Step<string, any, any, TResumeSchema, any> | [...Step<string, any, any, any, any>[], Step<string, any, any, TResumeSchema, any>] | string | string[];
+        runtimeContext?: RuntimeContext;
+    }): Promise<WorkflowResult<TOutput, TSteps>>;
+    /**
+     * Returns the current state of the workflow run
+     * @returns The current state of the workflow run
+     */
+    getState(): Record<string, any>;
+    updateState(state: Record<string, any>): void;
+}
+
+type ToolsInput = Record<string, ToolAction<any, any, any> | VercelTool>;
+type ToolsetsInput = Record<string, ToolsInput>;
+type MastraLanguageModel = LanguageModelV1;
+type DynamicArgument<T> = T | (({ runtimeContext }: {
+    runtimeContext: RuntimeContext;
+}) => Promise<T> | T);
+interface AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> {
+    name: TAgentId;
+    instructions: DynamicArgument<string>;
+    model: DynamicArgument<MastraLanguageModel>;
+    tools?: DynamicArgument<TTools>;
+    workflows?: DynamicArgument<Record<string, Workflow>>;
+    defaultGenerateOptions?: AgentGenerateOptions;
+    defaultStreamOptions?: AgentStreamOptions;
+    mastra?: Mastra;
+    evals?: TMetrics;
+    memory?: MastraMemory;
+    voice?: CompositeVoice;
+    /** @deprecated This property is deprecated. Use evals instead to add evaluation metrics. */
+    metrics?: TMetrics;
+}
+/**
+ * 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;
+    clientTools?: ToolsInput;
+    /** 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;
+    /** RuntimeContext for dependency injection */
+    runtimeContext?: RuntimeContext;
+} & ({
+    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;
+    clientTools?: ToolsInput;
+    /** 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;
+    };
+    /** Experimental schema for structured output */
+    experimental_output?: Z;
+    /** Telemetry settings */
+    telemetry?: TelemetrySettings;
+    /** RuntimeContext for dependency injection */
+    runtimeContext?: RuntimeContext;
+} & ({
+    resourceId?: undefined;
+    threadId?: undefined;
+} | {
+    resourceId: string;
+    threadId: string;
+}) & (Z extends undefined ? DefaultLLMStreamOptions : DefaultLLMStreamObjectOptions);
+
+type AgentNetworkConfig = {
+    name: string;
+    agents: Agent[];
+    model: LanguageModelV1;
+    instructions: string;
+};
+
+declare class AgentNetwork extends MastraBase {
     #private;
-    protected emitter: EventEmitter$1;
-    /**
-     * Unique identifier for this workflow
-     */
-    readonly workflowId: string;
-    /**
-     * Unique identifier for this run
-     */
-    readonly runId: string;
-    /**
-     * Internal state of the workflow run
-     */
-    protected state: Record<string, any>;
-    /**
-     * The execution engine for this run
-     */
-    executionEngine: ExecutionEngine;
-    /**
-     * The execution graph for this run
-     */
-    executionGraph: ExecutionGraph;
-    protected cleanup?: () => void;
-    protected retryConfig?: {
-        attempts?: number;
-        delay?: number;
+    constructor(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;
+            }[];
+        }>>>;
     };
-    constructor(params: {
-        workflowId: string;
-        runId: string;
-        executionEngine: ExecutionEngine;
-        executionGraph: ExecutionGraph;
-        mastra?: Mastra;
-        retryConfig?: {
-            attempts?: number;
-            delay?: number;
-        };
-        cleanup?: () => void;
-    });
+    getAgentHistory(agentId: string): {
+        input: string;
+        output: string;
+        timestamp: string;
+    }[];
     /**
-     * Starts the workflow execution with the provided input
-     * @param input The input data for the workflow
-     * @returns A promise that resolves to the workflow output
+     * Get the history of all agent interactions that have occurred in this network
+     * @returns A record of agent interactions, keyed by agent ID
      */
-    start({ inputData, runtimeContext, }: {
-        inputData?: z.infer<TInput>;
-        runtimeContext?: RuntimeContext;
-    }): Promise<WorkflowResult<TOutput, TSteps>>;
-    watch(cb: (event: WatchEvent) => void): () => void;
-    resume<TResumeSchema extends z.ZodType<any>>(params: {
-        resumeData?: z.infer<TResumeSchema>;
-        step: NewStep<string, any, any, TResumeSchema, any> | [...NewStep<string, any, any, any, any>[], NewStep<string, any, any, TResumeSchema, any>] | string | string[];
-        runtimeContext?: RuntimeContext;
-    }): Promise<WorkflowResult<TOutput, TSteps>>;
+    getAgentInteractionHistory(): {
+        [x: string]: {
+            input: string;
+            output: string;
+            timestamp: string;
+        }[];
+    };
     /**
-     * Returns the current state of the workflow run
-     * @returns The current state of the workflow run
+     * Get a summary of agent interactions in a more readable format, displayed chronologically
+     * @returns A formatted string with all agent interactions in chronological order
      */
-    getState(): Record<string, any>;
-    updateState(state: Record<string, any>): void;
+    getAgentInteractionSummary(): string;
+    executeAgent(agentId: string, input: CoreMessage$1[], includeHistory?: boolean, runtimeContext?: RuntimeContext): 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;
 }
 
-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[];
-}
-declare const memoryDefaultOptions: {
-    lastMessages: number;
-    semanticRecall: {
-        topK: number;
-        messageRange: {
-            before: number;
-            after: number;
-        };
-    };
-    threads: {
-        generateTitle: true;
-    };
-    workingMemory: {
-        use: "text-stream";
-        enabled: false;
-        template: string;
-    };
+type ConvertedTool = {
+    name: string;
+    description?: string;
+    parameters: InternalCoreTool['parameters'];
+    execute: InternalCoreTool['execute'];
 };
-/**
- * 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;
-    private deprecationWarnings;
-    protected threadConfig: MemoryConfig;
-    constructor(config: {
-        name: string;
-    } & SharedMemoryConfig);
-    private addImplicitDefaultsWarning;
-    setStorage(storage: MastraStorage): void;
-    setVector(vector: MastraVector): void;
-    setEmbedder(embedder: EmbeddingModel<string>): void;
-    /**
-     * 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>;
+interface MCPServerSSEOptionsBase {
     /**
-     * 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.
+     * Parsed URL of the incoming request
      */
-    getTools(_config?: MemoryConfig): Record<string, CoreTool>;
-    protected createEmbeddingIndex(dimensions?: number): Promise<{
-        indexName: string;
-    }>;
-    getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
+    url: URL;
     /**
-     * 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[];
+     * Path for establishing the SSE connection (e.g. '/sse')
+     */
+    ssePath: string;
     /**
-     * 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
+     * Path for POSTing client messages (e.g. '/message')
      */
-    abstract getThreadById({ threadId }: {
-        threadId: string;
-    }): Promise<StorageThreadType | null>;
-    abstract getThreadsByResourceId({ resourceId }: {
-        resourceId: string;
-    }): Promise<StorageThreadType[]>;
+    messagePath: string;
+}
+/**
+ * Options for starting an MCP server with SSE transport
+ */
+interface MCPServerSSEOptions extends MCPServerSSEOptionsBase {
     /**
-     * Saves or updates a thread
-     * @param thread - The thread data to save
-     * @returns Promise resolving to the saved thread
+     * Incoming HTTP request
      */
-    abstract saveThread({ thread, memoryConfig, }: {
-        thread: StorageThreadType;
-        memoryConfig?: MemoryConfig;
-    }): Promise<StorageThreadType>;
+    req: http.IncomingMessage;
     /**
-     * Saves messages to a thread
-     * @param messages - Array of messages to save
-     * @returns Promise resolving to the saved messages
+     * HTTP response (must support .write/.end)
      */
-    abstract saveMessages({ messages, memoryConfig, }: {
-        messages: MessageType[];
-        memoryConfig: MemoryConfig | undefined;
-    }): Promise<MessageType[]>;
+    res: http.ServerResponse<http.IncomingMessage>;
+}
+/**
+ * Options for starting an MCP server with Hono SSE transport
+ */
+interface MCPServerHonoSSEOptions extends MCPServerSSEOptionsBase {
     /**
-     * Retrieves all messages for a specific thread
-     * @param threadId - The unique identifier of the thread
-     * @returns Promise resolving to array of messages and uiMessages
+     * Incoming Hono context
      */
-    abstract query({ threadId, resourceId, selectBy, }: StorageGetMessagesArg): Promise<{
-        messages: CoreMessage$1[];
-        uiMessages: Message[];
-    }>;
+    context: Context;
+}
+interface MCPServerHTTPOptions {
     /**
-     * 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
+     * Parsed URL of the incoming request
      */
-    createThread({ threadId, resourceId, title, metadata, memoryConfig, }: {
-        resourceId: string;
-        threadId?: string;
-        title?: string;
-        metadata?: Record<string, unknown>;
-        memoryConfig?: MemoryConfig;
-    }): Promise<StorageThreadType>;
+    url: URL;
     /**
-     * Helper method to delete a thread
-     * @param threadId - the id of the thread to delete
+     * Path for establishing the HTTP connection (e.g. '/mcp')
      */
-    abstract deleteThread(threadId: string): Promise<void>;
+    httpPath: string;
     /**
-     * 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
+     * Incoming HTTP request
      */
-    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>;
+    req: http.IncomingMessage;
     /**
-     * Generates a unique identifier
-     * @returns A unique string ID
+     * HTTP response (must support .write/.end)
      */
-    generateId(): string;
+    res: http.ServerResponse<http.IncomingMessage>;
+    /**
+     * Optional options to pass to the transport (e.g. sessionIdGenerator)
+     */
+    options?: any;
 }
-
-declare class MastraLLMBase extends MastraBase {
-    #private;
-    constructor({ name, model }: {
-        name: string;
-        model: LanguageModel$1;
-    });
-    getProvider(): string;
-    getModelId(): string;
-    getModel(): ai.LanguageModelV1;
-    convertToMessages(messages: string | string[] | CoreMessage$1[]): CoreMessage$1[];
-    __registerPrimitives(p: MastraPrimitives): void;
-    __registerMastra(p: Mastra): void;
-    __text<Z extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextOptions<Z>): Promise<GenerateTextResult<any, any>>;
-    __textObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextObjectOptions<T>): Promise<GenerateObjectResult<T>>;
-    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<GenerateReturn<Z>>;
-    __stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(input: LLMInnerStreamOptions<Z>): Promise<StreamTextResult<any, any>>;
-    __streamObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMStreamObjectOptions<T>): Promise<StreamObjectResult<DeepPartial<T>, T, never>>;
-    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options: LLMStreamOptions<Z>): Promise<StreamReturn<Z>>;
+/** Describes a source code repository. */
+interface Repository {
+    /** The URL of the repository (e.g., a GitHub URL). */
+    url: string;
+    /** The source control platform (e.g., 'github', 'gitlab'). */
+    source: 'github' | 'gitlab' | string;
+    /** A unique identifier for the repository at the source. */
+    id: string;
 }
-
-declare function createMockModel({ objectGenerationMode, mockText, spyGenerate, spyStream, }: {
-    objectGenerationMode?: 'json';
-    mockText: string | Record<string, any>;
-    spyGenerate?: (props: any) => void;
-    spyStream?: (props: any) => void;
-}): MockLanguageModelV1;
-
-type LanguageModel = MastraLanguageModel;
-type CoreMessage = CoreMessage$1;
-type CoreSystemMessage = CoreSystemMessage$1;
-type CoreAssistantMessage = CoreAssistantMessage$1;
-type CoreUserMessage = CoreUserMessage$1;
-type CoreToolMessage = CoreToolMessage$1;
-type EmbedResult<T> = EmbedResult$1<T>;
-type EmbedManyResult<T> = EmbedManyResult$1<T>;
-type BaseStructuredOutputType = 'string' | 'number' | 'boolean' | 'date';
-type StructuredOutputType = 'array' | 'string' | 'number' | 'object' | 'boolean' | 'date';
-type StructuredOutputArrayItem = {
-    type: BaseStructuredOutputType;
-} | {
-    type: 'object';
-    items: StructuredOutput;
-};
-type StructuredOutput = {
-    [key: string]: {
-        type: BaseStructuredOutputType;
-    } | {
-        type: 'object';
-        items: StructuredOutput;
-    } | {
-        type: 'array';
-        items: StructuredOutputArrayItem;
-    };
-};
-type GenerateReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>;
-type StreamReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>;
-type OutputType = StructuredOutput | ZodSchema | JSONSchema7 | undefined;
-type GenerateTextOptions = Parameters<typeof generateText>[0];
-type StreamTextOptions = Parameters<typeof streamText>[0];
-type GenerateObjectOptions = Parameters<typeof generateObject>[0];
-type StreamObjectOptions = Parameters<typeof streamObject>[0];
-type MastraCustomLLMOptionsKeys = 'messages' | 'tools' | 'model' | 'onStepFinish' | 'experimental_output' | 'experimental_telemetry' | 'messages' | 'onFinish' | 'output';
-type DefaultLLMTextOptions = Omit<GenerateTextOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMTextObjectOptions = Omit<GenerateObjectOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMStreamOptions = Omit<StreamTextOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMStreamObjectOptions = Omit<StreamObjectOptions, MastraCustomLLMOptionsKeys>;
-type MastraCustomLLMOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    tools?: Record<string, CoreTool>;
-    onStepFinish?: (step: unknown) => void;
-    experimental_output?: Z;
-    telemetry?: TelemetrySettings;
-    threadId?: string;
-    resourceId?: string;
-    runtimeContext: RuntimeContext;
-} & Run$1;
-type LLMTextOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    messages: CoreMessage[];
-} & MastraCustomLLMOptions<Z> & DefaultLLMTextOptions;
-type LLMTextObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = LLMTextOptions<T> & DefaultLLMTextObjectOptions & {
-    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
-};
-type LLMStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    output?: OutputType | Z;
-    onFinish?: (result: string) => Promise<void> | void;
-} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
-type LLMInnerStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    messages: CoreMessage[];
-    onFinish?: (result: string) => Promise<void> | void;
-} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
-type LLMStreamObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
-} & LLMInnerStreamOptions<T> & DefaultLLMStreamObjectOptions;
-
-type VoiceEventType = 'speaking' | 'writing' | 'error' | string;
-interface VoiceEventMap {
-    speaker: NodeJS.ReadableStream;
-    speaking: {
-        audio?: string;
-    };
-    writing: {
-        text: string;
-        role: 'assistant' | 'user';
-    };
-    error: {
-        message: string;
-        code?: string;
-        details?: unknown;
-    };
-    [key: string]: unknown;
+/** Provides details about a specific version of an MCP server. */
+interface VersionDetail {
+    /** The semantic version string (e.g., "1.0.2"). */
+    version: string;
+    /** The ISO 8601 date-time string when this version was released or registered. */
+    release_date: string;
+    /** Indicates if this version is the latest available. */
+    is_latest: boolean;
+}
+/** Base interface for command-line arguments. */
+interface ArgumentInfo {
+    /** The name of the argument. */
+    name: string;
+    /** A description of what the argument is for. */
+    description: string;
+    /** Whether the argument is required. */
+    is_required: boolean;
+    /** Whether the argument can be specified multiple times. */
+    is_repeatable?: boolean;
+    /** Whether the argument's value can be edited by the user (e.g., in a UI). */
+    is_editable?: boolean;
+    /** A list of predefined choices for the argument's value. */
+    choices?: string[];
+    /** The default value for the argument if not specified. */
+    default_value?: string | number | boolean;
+}
+/** Describes a positional argument for a command. */
+interface PositionalArgumentInfo extends ArgumentInfo {
+    /** The 0-indexed position of the argument. */
+    position: number;
+}
+/** Describes a named argument (flag) for a command. */
+interface NamedArgumentInfo extends ArgumentInfo {
+    /** The short flag for the argument (e.g., "-y"). */
+    short_flag?: string;
+    /** The long flag for the argument (e.g., "--yes"). */
+    long_flag?: string;
+    /** Whether the flag requires a value (e.g., `--config <value>`) or is a boolean flag. */
+    requires_value?: boolean;
 }
-interface BuiltInModelConfig {
+/** Describes a subcommand for a command-line tool. */
+interface SubcommandInfo {
+    /** The name of the subcommand (e.g., "run", "list"). */
     name: string;
-    apiKey?: string;
+    /** A description of what the subcommand does. */
+    description: string;
+    /** Whether this subcommand is required if its parent command is used. */
+    is_required?: boolean;
+    /** Nested subcommands. */
+    subcommands?: SubcommandInfo[];
+    /** Positional arguments for this subcommand. */
+    positional_arguments?: PositionalArgumentInfo[];
+    /** Named arguments (flags) for this subcommand. */
+    named_arguments?: NamedArgumentInfo[];
 }
-interface VoiceConfig<T = unknown> {
-    listeningModel?: BuiltInModelConfig;
-    speechModel?: BuiltInModelConfig;
-    speaker?: string;
-    name?: string;
-    realtimeConfig?: {
-        model?: string;
-        apiKey?: string;
-        options?: T;
-    };
+/** Describes a command to run an MCP server package. */
+interface CommandInfo {
+    /** The primary command executable (e.g., "npx", "docker"). */
+    name: 'npx' | 'docker' | 'pypi' | 'uvx' | string;
+    /** Subcommands to append to the primary command. */
+    subcommands?: SubcommandInfo[];
+    /** Positional arguments for the command. */
+    positional_arguments?: PositionalArgumentInfo[];
+    /** Named arguments (flags) for the command. */
+    named_arguments?: NamedArgumentInfo[];
 }
-declare abstract class MastraVoice<TOptions = unknown, TSpeakOptions = unknown, TListenOptions = unknown, TTools extends ToolsInput = ToolsInput, TEventArgs extends VoiceEventMap = VoiceEventMap, TSpeakerMetadata = unknown> extends MastraBase {
-    protected listeningModel?: BuiltInModelConfig;
-    protected speechModel?: BuiltInModelConfig;
-    protected speaker?: string;
-    protected realtimeConfig?: {
-        model?: string;
-        apiKey?: string;
-        options?: TOptions;
-    };
-    constructor({ listeningModel, speechModel, speaker, realtimeConfig, name }?: VoiceConfig<TOptions>);
-    traced<T extends Function>(method: T, methodName: string): T;
-    /**
-     * Convert text to speech
-     * @param input Text or text stream to convert to speech
-     * @param options Speech options including speaker and provider-specific options
-     * @returns Audio stream
-     */
-    /**
-     * Convert text to speech
-     * @param input Text or text stream to convert to speech
-     * @param options Speech options including speaker and provider-specific options
-     * @returns Audio stream or void if in chat mode
-     */
-    abstract speak(input: string | NodeJS.ReadableStream, options?: {
-        speaker?: string;
-    } & TSpeakOptions): Promise<NodeJS.ReadableStream | void>;
-    /**
-     * Convert speech to text
-     * @param audioStream Audio stream to transcribe
-     * @param options Provider-specific transcription options
-     * @returns Text or text stream
-     */
-    /**
-     * Convert speech to text
-     * @param audioStream Audio stream to transcribe
-     * @param options Provider-specific transcription options
-     * @returns Text, text stream, or void if in chat mode
-     */
-    abstract listen(audioStream: NodeJS.ReadableStream | unknown, // Allow other audio input types for OpenAI realtime API
-    options?: TListenOptions): Promise<string | NodeJS.ReadableStream | void>;
-    updateConfig(_options: Record<string, unknown>): void;
-    /**
-     * Initializes a WebSocket or WebRTC connection for real-time communication
-     * @returns Promise that resolves when the connection is established
-     */
-    connect(_options?: Record<string, unknown>): Promise<void>;
+/** Describes an environment variable required or used by an MCP server package. */
+interface EnvironmentVariableInfo {
+    /** The name of the environment variable (e.g., "API_KEY"). */
+    name: string;
+    /** A description of what the environment variable is for. */
+    description: string;
+    /** Whether the environment variable is required. */
+    required?: boolean;
+    /** The default value for the environment variable if not set. */
+    default_value?: string;
+}
+/** Describes an installable package for an MCP server. */
+interface PackageInfo {
+    /** The name of the package registry (e.g., "npm", "docker"). */
+    registry_name: 'npm' | 'docker' | 'pypi' | 'homebrew' | string;
+    /** The name of the package. */
+    name: string;
+    /** The version of the package. */
+    version: string;
+    /** The command structure to run this package as an MCP server. */
+    command?: CommandInfo;
+    /** Environment variables relevant to this package. */
+    environment_variables?: EnvironmentVariableInfo[];
+}
+/** Describes a remote endpoint for accessing an MCP server. */
+interface RemoteInfo {
+    /** The transport type for the remote connection (e.g., "sse", "streamable"). */
+    transport_type: 'streamable' | 'sse' | string;
+    /** The URL of the remote endpoint. */
+    url: string;
+}
+/** Configuration options for creating an MCPServer instance. */
+interface MCPServerConfig {
+    /** The display name of the MCP server. */
+    name: string;
+    /** The semantic version of the MCP server. */
+    version: string;
+    /** The tools that this MCP server will expose. */
+    tools: ToolsInput;
     /**
-     * Relay audio data to the voice provider for real-time processing
-     * @param audioData Audio data to relay
+     * Optional unique identifier for the server.
+     * If not provided, a UUID will be generated.
+     * If provided, this ID is considered final and cannot be changed by Mastra.
      */
-    send(_audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
+    id?: string;
+    /** Optional description of the MCP server. */
+    description?: string;
+    /** Optional repository information for the server's source code. */
+    repository?: Repository;
     /**
-     * Trigger voice providers to respond
+     * Optional release date of this server version (ISO 8601 string).
+     * Defaults to the time of instantiation if not provided.
      */
-    answer(_options?: Record<string, unknown>): Promise<void>;
+    releaseDate?: string;
     /**
-     * Equip the voice provider with instructions
-     * @param instructions Instructions to add
+     * Optional flag indicating if this is the latest version.
+     * Defaults to true if not provided.
      */
-    addInstructions(_instructions?: string): void;
+    isLatest?: boolean;
     /**
-     * Equip the voice provider with tools
-     * @param tools Array of tools to add
+     * Optional canonical packaging format if the server is distributed as a package
+     * (e.g., "npm", "docker").
      */
-    addTools(_tools: TTools): void;
+    packageCanonical?: 'npm' | 'docker' | 'pypi' | 'crates' | string;
+    /** Optional list of installable packages for this server. */
+    packages?: PackageInfo[];
+    /** Optional list of remote access points for this server. */
+    remotes?: RemoteInfo[];
+}
+/** Basic information about an MCP server, conforming to the MCP Registry 'Server' schema. */
+interface ServerInfo {
+    /** The unique ID of the server. */
+    id: string;
+    /** The name of the server. */
+    name: string;
+    /** A description of the server. */
+    description?: string;
+    /** Repository information for the server. */
+    repository?: Repository;
+    /** Detailed version information. */
+    version_detail: VersionDetail;
+}
+/** Detailed information about an MCP server, conforming to the MCP Registry 'ServerDetail' schema. */
+interface ServerDetailInfo extends ServerInfo {
+    /** The canonical packaging format, if applicable. */
+    package_canonical?: MCPServerConfig['packageCanonical'];
+    /** Information about installable packages for this server. */
+    packages?: PackageInfo[];
+    /** Information about remote access points for this server. */
+    remotes?: RemoteInfo[];
+}
+
+/**
+ * Abstract base class for MCP server implementations.
+ * This provides a common interface and shared functionality for all MCP servers
+ * that can be registered with Mastra, including handling of server metadata.
+ */
+declare abstract class MCPServerBase extends MastraBase {
+    /** Tracks if the server ID has been definitively set. */
+    private idWasSet;
+    /** The display name of the MCP server. */
+    readonly name: string;
+    /** The semantic version of the MCP server. */
+    readonly version: string;
+    /** Internal storage for the server's unique ID. */
+    private _id;
+    /** A description of what the MCP server does. */
+    readonly description?: string;
+    /** Repository information for the server's source code. */
+    readonly repository?: Repository;
+    /** The release date of this server version (ISO 8601 string). */
+    readonly releaseDate: string;
+    /** Indicates if this version is the latest available. */
+    readonly isLatest: boolean;
+    /** The canonical packaging format (e.g., "npm", "docker"), if applicable. */
+    readonly packageCanonical?: MCPServerConfig['packageCanonical'];
+    /** Information about installable packages for this server. */
+    readonly packages?: PackageInfo[];
+    /** Information about remote access points for this server. */
+    readonly remotes?: RemoteInfo[];
+    /** The tools registered with and converted by this MCP server. */
+    readonly convertedTools: Record<string, ConvertedTool>;
+    /** Reference to the Mastra instance if this server is registered with one. */
+    mastra: Mastra | undefined;
     /**
-     * Disconnect from the WebSocket or WebRTC connection
+     * Public getter for the server's unique ID.
+     * The ID is set at construction or by Mastra and is read-only afterwards.
      */
-    close(): void;
+    get id(): string;
     /**
-     * Register an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function that receives event data
+     * Gets a read-only view of the registered tools.
+     * @returns A readonly record of converted tools.
      */
-    on<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
+    tools(): Readonly<Record<string, ConvertedTool>>;
     /**
-     * Remove an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function to remove
+     * Sets the server's unique ID. This method is typically called by Mastra when
+     * registering the server, using the key provided in the Mastra configuration.
+     * It ensures the ID is set only once.
+     * If an ID was already provided in the MCPServerConfig, this method will be a no-op.
+     * @param id The unique ID to assign to the server.
      */
-    off<E extends VoiceEventType>(_event: E, _callback: (data: E extends keyof TEventArgs ? TEventArgs[E] : unknown) => void): void;
+    setId(id: string): void;
     /**
-     * Get available speakers/voices
-     * @returns Array of available voice IDs and their metadata
-     */
-    getSpeakers(): Promise<Array<{
-        voiceId: string;
-    } & TSpeakerMetadata>>;
-}
-
-declare class CompositeVoice extends MastraVoice<unknown, unknown, unknown, ToolsInput, VoiceEventMap> {
-    protected speakProvider?: MastraVoice;
-    protected listenProvider?: MastraVoice;
-    protected realtimeProvider?: MastraVoice;
-    constructor({ input, output, realtime, speakProvider, listenProvider, realtimeProvider, }: {
-        /** @deprecated use output instead */
-        speakProvider?: MastraVoice;
-        /** @deprecated use input instead */
-        listenProvider?: MastraVoice;
-        /** @deprecated use realtime instead */
-        realtimeProvider?: MastraVoice;
-        input?: MastraVoice;
-        output?: MastraVoice;
-        realtime?: MastraVoice;
-    });
+     * Abstract method to convert and validate tool definitions provided to the server.
+     * @param tools Tool definitions to convert.
+     * @returns A record of converted and validated tools.
+     */
+    abstract convertTools(tools: ToolsInput): Record<string, ConvertedTool>;
     /**
-     * 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
+     * Internal method used by Mastra to register itself with the server.
+     * @param mastra The Mastra instance.
+     * @internal
      */
-    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;
+    __registerMastra(mastra: Mastra): void;
     /**
-     * Initializes a WebSocket or WebRTC connection for real-time communication
-     * @returns Promise that resolves when the connection is established
+     * Constructor for the MCPServerBase.
+     * @param config Configuration options for the MCP server, including metadata.
      */
-    connect(options?: Record<string, unknown>): Promise<void>;
+    constructor(config: MCPServerConfig);
     /**
-     * Relay audio data to the voice provider for real-time processing
-     * @param audioData Audio data to send
+     * Start the MCP server using stdio transport
+     * This is typically used for Windsurf integration
      */
-    send(audioData: NodeJS.ReadableStream | Int16Array): Promise<void>;
+    abstract startStdio(): Promise<void>;
     /**
-     * Trigger voice providers to respond
+     * Start the MCP server using SSE transport
+     * This is typically used for web integration
+     * @param options Options for the SSE transport
      */
-    answer(options?: Record<string, unknown>): Promise<void>;
+    abstract startSSE(options: MCPServerSSEOptions): Promise<void>;
     /**
-     * Equip the voice provider with instructions
-     * @param instructions Instructions to add
+     * Start the MCP server using Hono SSE transport
+     * Used for Hono servers
+     * @param options Options for the SSE transport
      */
-    addInstructions(instructions: string): void;
+    abstract startHonoSSE(options: MCPServerHonoSSEOptions): Promise<Response | undefined>;
     /**
-     * Equip the voice provider with tools
-     * @param tools Array of tools to add
+     * Start the MCP server using HTTP transport
+     * @param options Options for the HTTP transport
      */
-    addTools(tools: ToolsInput): void;
+    abstract startHTTP(options: MCPServerHTTPOptions): Promise<void>;
     /**
-     * Disconnect from the WebSocket or WebRTC connection
+     * Close the MCP server and all its connections
      */
-    close(): void;
+    abstract close(): Promise<void>;
     /**
-     * Register an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function that receives event data
+     * Gets the basic information about the server, conforming to the MCP Registry 'Server' schema.
+     * This information is suitable for listing multiple servers.
+     * @returns ServerInfo object containing basic server metadata.
      */
-    on<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
+    abstract getServerInfo(): ServerInfo;
     /**
-     * Remove an event listener
-     * @param event Event name (e.g., 'speaking', 'writing', 'error')
-     * @param callback Callback function to remove
+     * Gets detailed information about the server, conforming to the MCP Registry 'ServerDetail' schema.
+     * This includes all information from `getServerInfo` plus package and remote details.
+     * @returns ServerDetailInfo object containing comprehensive server metadata.
      */
-    off<E extends VoiceEventType>(event: E, callback: (data: E extends keyof VoiceEventMap ? VoiceEventMap[E] : unknown) => void): void;
-}
-
-declare class DefaultVoice extends MastraVoice {
-    constructor();
-    speak(_input: string | NodeJS.ReadableStream): Promise<NodeJS.ReadableStream>;
-    listen(_input: string | NodeJS.ReadableStream): Promise<string>;
-    getSpeakers(): Promise<{
-        voiceId: string;
-    }[]>;
-}
-
-type ToolsInput = Record<string, ToolAction<any, any, any> | VercelTool>;
-type ToolsetsInput = Record<string, ToolsInput>;
-type MastraLanguageModel = LanguageModelV1;
-type DynamicArgument<T> = T | (({ runtimeContext }: {
-    runtimeContext: RuntimeContext;
-}) => Promise<T> | T);
-interface AgentConfig<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> {
-    name: TAgentId;
-    instructions: DynamicArgument<string>;
-    model: DynamicArgument<MastraLanguageModel>;
-    tools?: DynamicArgument<TTools>;
-    workflows?: DynamicArgument<Record<string, NewWorkflow>>;
-    defaultGenerateOptions?: AgentGenerateOptions;
-    defaultStreamOptions?: AgentStreamOptions;
-    mastra?: Mastra;
-    evals?: TMetrics;
-    memory?: MastraMemory;
-    voice?: CompositeVoice;
-    /** @deprecated This property is deprecated. Use evals instead to add evaluation metrics. */
-    metrics?: TMetrics;
-}
-/**
- * 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;
-    clientTools?: ToolsInput;
-    /** 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;
-    /** RuntimeContext for dependency injection */
-    runtimeContext?: RuntimeContext;
-} & ({
-    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;
-    clientTools?: ToolsInput;
-    /** 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;
+    abstract getServerDetail(): ServerDetailInfo;
+    /**
+     * Gets a list of tools provided by this MCP server, including their schemas.
+     * @returns An object containing an array of tool information.
+     */
+    abstract getToolListInfo(): {
+        tools: Array<{
+            name: string;
+            description?: string;
+            inputSchema: string;
+        }>;
     };
-    /** Experimental schema for structured output */
-    experimental_output?: Z;
-    /** Telemetry settings */
-    telemetry?: TelemetrySettings;
-    /** RuntimeContext for dependency injection */
-    runtimeContext?: RuntimeContext;
-} & ({
-    resourceId?: undefined;
-    threadId?: undefined;
-} | {
-    resourceId: string;
-    threadId: string;
-}) & (Z extends undefined ? DefaultLLMStreamOptions : DefaultLLMStreamObjectOptions);
+    /**
+     * Gets information for a specific tool provided by this MCP server.
+     * @param toolId The ID/name of the tool to retrieve.
+     * @returns Tool information (name, description, inputSchema) or undefined if not found.
+     */
+    abstract getToolInfo(toolId: string): {
+        name: string;
+        description?: string;
+        inputSchema: string;
+    } | undefined;
+    /**
+     * Executes a specific tool provided by this MCP server.
+     * @param toolId The ID/name of the tool to execute.
+     * @param args The arguments to pass to the tool's execute function.
+     * @param executionContext Optional context for the tool execution (e.g., messages, toolCallId).
+     * @returns A promise that resolves to the result of the tool execution.
+     * @throws Error if the tool is not found, or if execution fails.
+     */
+    abstract executeTool(toolId: string, args: any, executionContext?: {
+        messages?: any[];
+        toolCallId?: string;
+    }): Promise<any>;
+}
 
 type Methods = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'ALL';
 type ApiRoute = {
@@ -2554,6 +2555,47 @@ type Middleware = MiddlewareHandler | {
     path: string;
     handler: MiddlewareHandler;
 };
+type ContextWithMastra = Context<{
+    Variables: {
+        mastra: Mastra;
+        runtimeContext: RuntimeContext;
+    };
+}>;
+type MastraAuthConfig<TUser = unknown> = {
+    /**
+     * Public paths for the server
+     */
+    public?: (RegExp | string | [string, Methods | Methods[]])[];
+    /**
+     * Public paths for the server
+     */
+    authenticateToken?: (token: string, request: HonoRequest) => Promise<TUser>;
+    /**
+     * Authorization function for the server
+     */
+    authorize?: (path: string, method: string, user: TUser, context: ContextWithMastra) => Promise<boolean>;
+    /**
+     * Rules for the server
+     */
+    rules?: {
+        /**
+         * Path for the rule
+         */
+        path?: RegExp | string | string[];
+        /**
+         * Method for the rule
+         */
+        methods?: Methods | Methods[];
+        /**
+         * Condition for the rule
+         */
+        condition?: (user: TUser) => Promise<boolean> | boolean;
+        /**
+         * Allow the rule
+         */
+        allow?: boolean;
+    }[];
+};
 type ServerConfig = {
     /**
      * Port for the server
@@ -2607,16 +2649,20 @@ type ServerConfig = {
      * @default 4.5mb
      */
     bodySizeLimit?: number;
+    /**
+     * Authentication configuration for the server
+     */
+    experimental_auth?: MastraAuthConfig<any>;
 };
 
-interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TNewWorkflows extends Record<string, NewWorkflow> = Record<string, NewWorkflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>, TMCPServers extends Record<string, MCPServerBase> = Record<string, MCPServerBase>> {
+interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TLegacyWorkflows extends Record<string, LegacyWorkflow> = Record<string, LegacyWorkflow>, 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 IMastraLogger = IMastraLogger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>, TMCPServers extends Record<string, MCPServerBase> = Record<string, MCPServerBase>> {
     agents?: TAgents;
     networks?: TNetworks;
     storage?: MastraStorage;
     vectors?: TVectors;
     logger?: TLogger | false;
+    legacy_workflows?: TLegacyWorkflows;
     workflows?: TWorkflows;
-    vnext_workflows?: TNewWorkflows;
     tts?: TTTS;
     telemetry?: OtelConfig;
     deployer?: MastraDeployer;
@@ -2631,9 +2677,9 @@ interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Age
         handler: (c: any, next: () => Promise<void>) => Promise<Response | void>;
         path?: string;
     }>;
-    memory?: MastraMemory;
+    memory?: never;
 }
-declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TNewWorkflows extends Record<string, NewWorkflow> = Record<string, NewWorkflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>, TMCPServers extends Record<string, MCPServerBase> = Record<string, MCPServerBase>> {
+declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TLegacyWorkflows extends Record<string, LegacyWorkflow> = Record<string, LegacyWorkflow>, 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 IMastraLogger = IMastraLogger, TNetworks extends Record<string, AgentNetwork> = Record<string, AgentNetwork>, TMCPServers extends Record<string, MCPServerBase> = Record<string, MCPServerBase>> {
     #private;
     /**
      * @deprecated use getTelemetry() instead
@@ -2647,24 +2693,24 @@ declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string,
      * @deprecated use getMemory() instead
      */
     get memory(): MastraMemory | undefined;
-    constructor(config?: Config<TAgents, TWorkflows, TNewWorkflows, TVectors, TTTS, TLogger, TNetworks, TMCPServers>);
+    constructor(config?: Config<TAgents, TLegacyWorkflows, TWorkflows, TVectors, TTTS, TLogger, TNetworks, TMCPServers>);
     getAgent<TAgentName extends keyof TAgents>(name: TAgentName): TAgents[TAgentName];
     getAgents(): TAgents;
     getVector<TVectorName extends keyof TVectors>(name: TVectorName): TVectors[TVectorName];
     getVectors(): TVectors | undefined;
     getDeployer(): MastraDeployer | undefined;
+    legacy_getWorkflow<TWorkflowId extends keyof TLegacyWorkflows>(id: TWorkflowId, { serialized }?: {
+        serialized?: boolean;
+    }): TLegacyWorkflows[TWorkflowId];
     getWorkflow<TWorkflowId extends keyof TWorkflows>(id: TWorkflowId, { serialized }?: {
         serialized?: boolean;
     }): TWorkflows[TWorkflowId];
-    vnext_getWorkflow<TWorkflowId extends keyof TNewWorkflows>(id: TWorkflowId, { serialized }?: {
+    legacy_getWorkflows(props?: {
         serialized?: boolean;
-    }): TNewWorkflows[TWorkflowId];
+    }): Record<string, LegacyWorkflow>;
     getWorkflows(props?: {
         serialized?: boolean;
     }): Record<string, Workflow>;
-    vnext_getWorkflows(props?: {
-        serialized?: boolean;
-    }): Record<string, NewWorkflow>;
     setStorage(storage: MastraStorage): void;
     setLogger({ logger }: {
         logger: TLogger;
@@ -2690,8 +2736,8 @@ declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string,
     getLogsByRunId({ runId, transportId }: {
         runId: string;
         transportId: string;
-    }): Promise<BaseLogMessage[] | undefined>;
-    getLogs(transportId: string): Promise<BaseLogMessage[]>;
+    }): Promise<any[]>;
+    getLogs(transportId: string): Promise<any[]>;
     /**
      * Get all registered MCP server instances.
      * @returns A record of MCP server ID to MCPServerBase instance, or undefined if none are registered.
@@ -2710,7 +2756,7 @@ declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string,
 }
 
 type MastraPrimitives = {
-    logger?: Logger;
+    logger?: IMastraLogger;
     telemetry?: Telemetry;
     storage?: MastraStorage;
     agents?: Record<string, Agent>;
@@ -2749,7 +2795,7 @@ declare class Agent<TAgentId extends string = string, TTools extends ToolsInput
     get voice(): CompositeVoice;
     getWorkflows({ runtimeContext, }?: {
         runtimeContext?: RuntimeContext;
-    }): Promise<Record<string, NewWorkflow>>;
+    }): Promise<Record<string, Workflow>>;
     getVoice({ runtimeContext }?: {
         runtimeContext?: RuntimeContext;
     }): Promise<CompositeVoice | DefaultVoice>;
@@ -2912,7 +2958,7 @@ declare class Agent<TAgentId extends string = string, TTools extends ToolsInput
     getSpeakers(): Promise<{
         voiceId: string;
     }[]>;
-    toStep(): Step<TAgentId, z.ZodObject<{
+    toStep(): LegacyStep<TAgentId, z.ZodObject<{
         prompt: z.ZodString;
     }>, z.ZodObject<{
         text: z.ZodString;
@@ -2928,26 +2974,26 @@ interface StorageColumn {
         column: string;
     };
 }
-interface WorkflowRuns {
-    runs: WorkflowRun[];
+interface LegacyWorkflowRuns {
+    runs: LegacyWorkflowRun[];
     total: number;
 }
-interface WorkflowRun {
+interface LegacyWorkflowRun {
     workflowName: string;
     runId: string;
-    snapshot: WorkflowRunState | string;
+    snapshot: LegacyWorkflowRunState | string;
     createdAt: Date;
     updatedAt: Date;
     resourceId?: string;
 }
-interface VNextWorkflowRuns {
-    runs: VNextWorkflowRun[];
+interface WorkflowRuns {
+    runs: WorkflowRun[];
     total: number;
 }
-interface VNextWorkflowRun {
+interface WorkflowRun {
     workflowName: string;
     runId: string;
-    snapshot: VNextWorkflowRunState | string;
+    snapshot: WorkflowRunState | string;
     createdAt: Date;
     updatedAt: Date;
     resourceId?: string;
@@ -3023,12 +3069,8 @@ type MemoryConfig = {
     workingMemory?: {
         enabled: boolean;
         template?: string;
-        use: 'tool-call';
-    } | {
-        enabled: boolean;
-        template?: string;
-        /** @deprecated the 'text-stream' working memory option (which is the current default) will be full removed in favor of the 'tool-call' option in a future breaking change. */
-        use?: 'text-stream';
+        /** @deprecated The `use` option has been removed. Working memory always uses tool-call mode. */
+        use?: never;
     };
     threads?: {
         generateTitle?: boolean;
@@ -3136,4 +3178,4 @@ declare abstract class MastraStorage extends MastraBase {
     }): Promise<WorkflowRun | null>;
 }
 
-export { type CoreSystemMessage as $, type ApiRoute as A, type WatchEvent as B, type VNextWorkflowRunState as C, type DynamicMapping as D, type EvalRow as E, type ToolAction as F, Agent as G, type AgentConfig as H, MastraMemory as I, type ToolExecutionContext as J, Tool as K, Step as L, type Methods as M, type NewStep as N, Workflow as O, type PathsToStringProps as P, type WorkflowOptions as Q, Run as R, type StorageColumn as S, type TABLE_NAMES as T, type VNextWorkflowRuns as U, type VariableReference as V, type WorkflowRuns as W, type VNextWorkflowRun as X, type LanguageModel as Y, type ZodPathType as Z, type CoreMessage as _, Mastra as a, type ExtractStepResult as a$, type CoreAssistantMessage as a0, type CoreUserMessage as a1, type CoreToolMessage as a2, type EmbedResult as a3, type EmbedManyResult as a4, type BaseStructuredOutputType as a5, type StructuredOutputType as a6, type StructuredOutputArrayItem as a7, type StructuredOutput as a8, type GenerateReturn as a9, type StepNode as aA, type StepGraph as aB, type RetryConfig as aC, type VariableReference$1 as aD, type BaseCondition as aE, type ActionContext as aF, WhenConditionReturnValue as aG, type StepDef as aH, type StepCondition as aI, type StepConfig as aJ, type StepResult$1 as aK, type StepsRecord$1 as aL, type WorkflowRunResult as aM, type WorkflowContext as aN, type WorkflowLogMessage as aO, type WorkflowEvent as aP, type ResolverFunctionInput as aQ, type ResolverFunctionOutput as aR, type SubscriberFunctionOutput as aS, type DependencyCheckOutput as aT, type StepResolverOutput as aU, type WorkflowActors as aV, type WorkflowActionParams as aW, type WorkflowActions as aX, type WorkflowState as aY, type StepId as aZ, type ExtractSchemaFromStep$1 as a_, type StreamReturn as aa, type OutputType as ab, type DefaultLLMTextOptions as ac, type DefaultLLMTextObjectOptions as ad, type DefaultLLMStreamOptions as ae, type DefaultLLMStreamObjectOptions as af, type LLMTextOptions as ag, type LLMTextObjectOptions as ah, type LLMStreamOptions as ai, type LLMInnerStreamOptions as aj, type LLMStreamObjectOptions as ak, createMockModel as al, type Config as am, type MessageResponse as an, type MemoryConfig as ao, type SharedMemoryConfig as ap, type MemoryProcessorOpts as aq, MemoryProcessor as ar, memoryDefaultOptions as as, createTool as at, type VercelTool as au, type CoreTool as av, type InternalCoreTool as aw, type StepExecutionContext as ax, type StepAction as ay, type StepVariableType as az, MastraStorage as b, type StepInputType as b0, type ExtractSchemaType$1 as b1, type PathsToStringProps$1 as b2, type WorkflowRunState as b3, type WorkflowResumeResult as b4, type MastraLanguageModel as b5, type MastraPrimitives as b6, type ToolsInput as b7, AgentNetwork as b8, MCPServerBase as b9, type AgentGenerateOptions as bA, type AgentStreamOptions as bB, TABLE_WORKFLOW_SNAPSHOT as bC, TABLE_EVALS as bD, TABLE_MESSAGES as bE, TABLE_THREADS as bF, TABLE_TRACES as bG, TABLE_SCHEMAS as bH, type ConvertedTool as ba, type MCPServerSSEOptions as bb, type MCPServerHonoSSEOptions as bc, type MCPServerHTTPOptions as bd, type Repository as be, type VersionDetail as bf, type ArgumentInfo as bg, type PositionalArgumentInfo as bh, type NamedArgumentInfo as bi, type SubcommandInfo as bj, type CommandInfo as bk, type EnvironmentVariableInfo as bl, type PackageInfo as bm, type RemoteInfo as bn, type MCPServerConfig as bo, type ServerInfo as bp, type ServerDetailInfo as bq, type AgentNetworkConfig as br, type VoiceEventType as bs, type VoiceEventMap as bt, type VoiceConfig as bu, MastraVoice as bv, CompositeVoice as bw, DefaultVoice as bx, type ToolsetsInput as by, type DynamicArgument as bz, type StorageThreadType as c, type MessageType as d, type StorageGetMessagesArg as e, type WorkflowRun as f, ExecutionEngine as g, type StepResult as h, type ExecutionGraph as i, type StepFlowEntry as j, type ExecuteFunction as k, type SerializedStep as l, type SerializedStepFlowEntry as m, createStep as n, cloneStep as o, createWorkflow as p, cloneWorkflow as q, type WorkflowResult as r, type NewWorkflowConfig as s, NewWorkflow as t, type StepSuccess as u, type StepFailure as v, type StepSuspended as w, type StepsRecord as x, type ExtractSchemaType as y, type ExtractSchemaFromStep as z };
+export { type WorkflowActions as $, type ApiRoute as A, type StepGraph as B, type ContextWithMastra as C, type BaseCondition as D, type EvalRow as E, type ActionContext as F, WhenConditionReturnValue as G, type StepDef as H, type StepCondition as I, type StepConfig as J, type StepsRecord$1 as K, type LegacyWorkflowRuns as L, type Methods as M, type WorkflowLogMessage as N, type WorkflowEvent as O, type ResolverFunctionInput as P, type ResolverFunctionOutput as Q, type RetryConfig as R, type StorageColumn as S, type TABLE_NAMES as T, type SubscriberFunctionOutput as U, type VariableReference$1 as V, type WorkflowRuns as W, type DependencyCheckOutput as X, type StepResolverOutput as Y, type WorkflowActors as Z, type WorkflowActionParams as _, Mastra as a, ExecutionEngine as a$, type LegacyWorkflowState as a0, type StepId as a1, type ExtractSchemaFromStep$1 as a2, type ExtractStepResult as a3, type StepInputType as a4, type ExtractSchemaType$1 as a5, type PathsToStringProps$1 as a6, type LegacyWorkflowRunState as a7, type WorkflowResumeResult as a8, type ToolAction as a9, type LLMTextOptions as aA, type LLMTextObjectOptions as aB, type LLMStreamOptions as aC, type LLMInnerStreamOptions as aD, type LLMStreamObjectOptions as aE, createMockModel as aF, type Config as aG, type MessageResponse as aH, type MemoryConfig as aI, type SharedMemoryConfig as aJ, type MemoryProcessorOpts as aK, MemoryProcessor as aL, memoryDefaultOptions as aM, createTool as aN, type VercelTool as aO, type CoreTool as aP, type InternalCoreTool as aQ, type StepFlowEntry as aR, type SerializedStep as aS, type SerializedStepFlowEntry as aT, createStep as aU, cloneStep as aV, createWorkflow as aW, cloneWorkflow as aX, type WorkflowResult as aY, Run as aZ, type ExecutionGraph as a_, type AgentConfig as aa, MastraMemory as ab, type ToolExecutionContext as ac, Tool as ad, type Step as ae, Workflow as af, type WorkflowConfig as ag, type LanguageModel as ah, type CoreMessage as ai, type CoreSystemMessage as aj, type CoreAssistantMessage as ak, type CoreUserMessage as al, type CoreToolMessage as am, type EmbedResult as an, type EmbedManyResult as ao, type BaseStructuredOutputType as ap, type StructuredOutputType as aq, type StructuredOutputArrayItem as ar, type StructuredOutput as as, type GenerateReturn as at, type StreamReturn as au, type OutputType as av, type DefaultLLMTextOptions as aw, type DefaultLLMTextObjectOptions as ax, type DefaultLLMStreamOptions as ay, type DefaultLLMStreamObjectOptions as az, type MastraAuthConfig as b, type ExecuteFunction as b0, type StepSuccess as b1, type StepFailure as b2, type StepSuspended as b3, type StepResult as b4, type StepsRecord as b5, type DynamicMapping as b6, type PathsToStringProps as b7, type ExtractSchemaType as b8, type ExtractSchemaFromStep as b9, type EnvironmentVariableInfo as bA, type PackageInfo as bB, type RemoteInfo as bC, type MCPServerConfig as bD, type ServerInfo as bE, type ServerDetailInfo as bF, type ToolsetsInput as bG, type DynamicArgument as bH, type AgentGenerateOptions as bI, type AgentStreamOptions as bJ, type VariableReference as ba, type WatchEvent as bb, type ZodPathType as bc, type WorkflowRunState as bd, type MastraLanguageModel as be, type MastraPrimitives as bf, AgentNetwork as bg, MCPServerBase as bh, type VoiceEventType as bi, type VoiceEventMap as bj, type VoiceConfig as bk, MastraVoice as bl, CompositeVoice as bm, DefaultVoice as bn, type AgentNetworkConfig as bo, type ConvertedTool as bp, type MCPServerSSEOptions as bq, type MCPServerHonoSSEOptions as br, type MCPServerHTTPOptions as bs, type Repository as bt, type VersionDetail as bu, type ArgumentInfo as bv, type PositionalArgumentInfo as bw, type NamedArgumentInfo as bx, type SubcommandInfo as by, type CommandInfo as bz, MastraStorage as c, type StorageThreadType as d, type MessageType as e, type StorageGetMessagesArg as f, type WorkflowRun as g, type LegacyWorkflowRun as h, TABLE_WORKFLOW_SNAPSHOT as i, TABLE_EVALS as j, TABLE_MESSAGES as k, TABLE_THREADS as l, TABLE_TRACES as m, TABLE_SCHEMAS as n, type StepResult$1 as o, LegacyStep as p, LegacyWorkflow as q, Agent as r, type WorkflowContext as s, type ToolsInput as t, type StepAction as u, type LegacyWorkflowRunResult as v, type WorkflowOptions as w, type StepExecutionContext as x, type StepVariableType as y, type StepNode as z };