@mastra/client-js 0.0.0-separate-trace-data-from-component-20250501141108 → 0.0.0-share-agent-metadata-with-cloud-20250718123411

package/dist/index.d.cts

@@ -1,10 +1,16 @@
-import { processDataStream } from '@ai-sdk/ui-utils';
-import { CoreMessage, AiMessageType, StorageThreadType, MessageType, StepAction, StepGraph, WorkflowRuns, WorkflowRunResult as WorkflowRunResult$1, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
+import { AbstractAgent } from '@ag-ui/client';
+import { ServerInfo, MCPToolType, ServerDetailInfo } from '@mastra/core/mcp';
+import { processDataStream, processTextStream } from '@ai-sdk/ui-utils';
+import { CoreMessage, AiMessageType, StorageThreadType, MastraMessageV1, LegacyWorkflowRuns, WorkflowRuns, WorkflowRun, QueryResult, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
-import { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
-import { NewWorkflow, WorkflowResult, WatchEvent } from '@mastra/core/workflows/vNext';
+import { AgentGenerateOptions, AgentStreamOptions, ToolsInput } from '@mastra/core/agent';
+import { LogLevel, BaseLogMessage } from '@mastra/core/logger';
 import { RuntimeContext } from '@mastra/core/runtime-context';
+import { Workflow as Workflow$1, WatchEvent, WorkflowResult } from '@mastra/core/workflows';
+import { StepAction, StepGraph, LegacyWorkflowRunResult as LegacyWorkflowRunResult$1 } from '@mastra/core/workflows/legacy';
+import * as stream_web from 'stream/web';
+import { AgentCard, TaskSendParams, Task, TaskQueryParams, TaskIdParams } from '@mastra/core/a2a';
 
 interface ClientOptions {
     /** Base URL for API requests */
@@ -17,27 +23,44 @@ interface ClientOptions {
     maxBackoffMs?: number;
     /** Custom headers to include with requests */
     headers?: Record<string, string>;
+    /** Abort signal for request */
+    abortSignal?: AbortSignal;
 }
 interface RequestOptions {
     method?: string;
     headers?: Record<string, string>;
     body?: any;
     stream?: boolean;
-    signal?: AbortSignal;
 }
+type WithoutMethods<T> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? never : T[K] extends {
+        (): any;
+    } ? never : T[K] extends undefined | ((...args: any[]) => any) ? never : K]: T[K];
+};
 interface GetAgentResponse {
     name: string;
     instructions: string;
     tools: Record<string, GetToolResponse>;
+    workflows: Record<string, GetWorkflowResponse>;
     provider: string;
     modelId: string;
+    defaultGenerateOptions: WithoutMethods<AgentGenerateOptions>;
+    defaultStreamOptions: WithoutMethods<AgentStreamOptions>;
 }
 type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
     messages: string | string[] | CoreMessage[] | AiMessageType[];
-} & Partial<AgentGenerateOptions<T>>;
+    output?: T;
+    experimental_output?: T;
+    runtimeContext?: RuntimeContext | Record<string, any>;
+    clientTools?: ToolsInput;
+} & WithoutMethods<Omit<AgentGenerateOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools' | 'abortSignal'>>;
 type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
     messages: string | string[] | CoreMessage[] | AiMessageType[];
-} & Omit<AgentStreamOptions<T>, 'onFinish' | 'onStepFinish' | 'telemetry'>;
+    output?: T;
+    experimental_output?: T;
+    runtimeContext?: RuntimeContext | Record<string, any>;
+    clientTools?: ToolsInput;
+} & WithoutMethods<Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools' | 'abortSignal'>>;
 interface GetEvalsByAgentIdResponse extends GetAgentResponse {
     evals: any[];
     instructions: string;
@@ -50,7 +73,7 @@ interface GetToolResponse {
     inputSchema: string;
     outputSchema: string;
 }
-interface GetWorkflowResponse {
+interface GetLegacyWorkflowResponse {
     name: string;
     triggerSchema: string;
     steps: Record<string, StepAction<any, any, any, any>>;
@@ -58,19 +81,30 @@ interface GetWorkflowResponse {
     stepSubscriberGraph: Record<string, StepGraph>;
     workflowId?: string;
 }
+interface GetWorkflowRunsParams {
+    fromDate?: Date;
+    toDate?: Date;
+    limit?: number;
+    offset?: number;
+    resourceId?: string;
+}
+type GetLegacyWorkflowRunsResponse = LegacyWorkflowRuns;
 type GetWorkflowRunsResponse = WorkflowRuns;
-type WorkflowRunResult = {
+type GetWorkflowRunByIdResponse = WorkflowRun;
+type GetWorkflowRunExecutionResultResponse = WatchEvent['payload']['workflowState'];
+type LegacyWorkflowRunResult = {
     activePaths: Record<string, {
         status: string;
         suspendPayload?: any;
         stepPath: string[];
     }>;
-    results: WorkflowRunResult$1<any, any, any>['results'];
+    results: LegacyWorkflowRunResult$1<any, any, any>['results'];
     timestamp: number;
     runId: string;
 };
-interface GetVNextWorkflowResponse {
+interface GetWorkflowResponse {
     name: string;
+    description?: string;
     steps: {
         [key: string]: {
             id: string;
@@ -81,14 +115,25 @@ interface GetVNextWorkflowResponse {
             suspendSchema: string;
         };
     };
-    stepGraph: NewWorkflow['serializedStepGraph'];
+    allSteps: {
+        [key: string]: {
+            id: string;
+            description: string;
+            inputSchema: string;
+            outputSchema: string;
+            resumeSchema: string;
+            suspendSchema: string;
+            isWorkflow: boolean;
+        };
+    };
+    stepGraph: Workflow$1['serializedStepGraph'];
     inputSchema: string;
     outputSchema: string;
 }
-type VNextWorkflowWatchResult = WatchEvent & {
+type WorkflowWatchResult = WatchEvent & {
     runId: string;
 };
-type VNextWorkflowRunResult = WorkflowResult<any, any>;
+type WorkflowRunResult = WorkflowResult<any, any>;
 interface UpsertVectorParams {
     indexName: string;
     vectors: number[][];
@@ -116,40 +161,79 @@ interface GetVectorIndexResponse {
     count: number;
 }
 interface SaveMessageToMemoryParams {
-    messages: MessageType[];
+    messages: MastraMessageV1[];
     agentId: string;
 }
-type SaveMessageToMemoryResponse = MessageType[];
+interface SaveNetworkMessageToMemoryParams {
+    messages: MastraMessageV1[];
+    networkId: string;
+}
+type SaveMessageToMemoryResponse = MastraMessageV1[];
 interface CreateMemoryThreadParams {
-    title: string;
-    metadata: Record<string, any>;
+    title?: string;
+    metadata?: Record<string, any>;
     resourceId: string;
-    threadId: string;
+    threadId?: string;
     agentId: string;
 }
+interface CreateNetworkMemoryThreadParams {
+    title?: string;
+    metadata?: Record<string, any>;
+    resourceId: string;
+    threadId?: string;
+    networkId: string;
+}
 type CreateMemoryThreadResponse = StorageThreadType;
 interface GetMemoryThreadParams {
     resourceId: string;
     agentId: string;
 }
+interface GetNetworkMemoryThreadParams {
+    resourceId: string;
+    networkId: string;
+}
 type GetMemoryThreadResponse = StorageThreadType[];
 interface UpdateMemoryThreadParams {
     title: string;
     metadata: Record<string, any>;
     resourceId: string;
 }
+interface GetMemoryThreadMessagesParams {
+    /**
+     * Limit the number of messages to retrieve (default: 40)
+     */
+    limit?: number;
+}
 interface GetMemoryThreadMessagesResponse {
     messages: CoreMessage[];
     uiMessages: AiMessageType[];
 }
 interface GetLogsParams {
     transportId: string;
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, string>;
+    page?: number;
+    perPage?: number;
 }
 interface GetLogParams {
     runId: string;
     transportId: string;
+    fromDate?: Date;
+    toDate?: Date;
+    logLevel?: LogLevel;
+    filters?: Record<string, string>;
+    page?: number;
+    perPage?: number;
 }
-type GetLogsResponse = BaseLogMessage[];
+type GetLogsResponse = {
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+};
 type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
 type SpanStatus = {
     code: number;
@@ -197,8 +281,11 @@ interface GetTelemetryParams {
     page?: number;
     perPage?: number;
     attribute?: Record<string, string>;
+    fromDate?: Date;
+    toDate?: Date;
 }
 interface GetNetworkResponse {
+    id: string;
     name: string;
     instructions: string;
     agents: Array<{
@@ -212,6 +299,71 @@ interface GetNetworkResponse {
     };
     state?: Record<string, any>;
 }
+interface GetVNextNetworkResponse {
+    id: string;
+    name: string;
+    instructions: string;
+    agents: Array<{
+        name: string;
+        provider: string;
+        modelId: string;
+    }>;
+    routingModel: {
+        provider: string;
+        modelId: string;
+    };
+    workflows: Array<{
+        name: string;
+        description: string;
+        inputSchema: string | undefined;
+        outputSchema: string | undefined;
+    }>;
+    tools: Array<{
+        id: string;
+        description: string;
+    }>;
+}
+interface GenerateVNextNetworkResponse {
+    task: string;
+    result: string;
+    resourceId: string;
+    resourceType: 'none' | 'tool' | 'agent' | 'workflow';
+}
+interface GenerateOrStreamVNextNetworkParams {
+    message: string;
+    threadId?: string;
+    resourceId?: string;
+    runtimeContext?: RuntimeContext | Record<string, any>;
+}
+interface LoopStreamVNextNetworkParams {
+    message: string;
+    threadId?: string;
+    resourceId?: string;
+    maxIterations?: number;
+    runtimeContext?: RuntimeContext | Record<string, any>;
+}
+interface LoopVNextNetworkResponse {
+    status: 'success';
+    result: {
+        text: string;
+    };
+    steps: WorkflowResult<any, any>['steps'];
+}
+interface McpServerListResponse {
+    servers: ServerInfo[];
+    next: string | null;
+    total_count: number;
+}
+interface McpToolInfo {
+    id: string;
+    name: string;
+    description?: string;
+    inputSchema: string;
+    toolType?: MCPToolType;
+}
+interface McpServerToolListResponse {
+    tools: McpToolInfo[];
+}
 
 declare class BaseResource {
     readonly options: ClientOptions;
@@ -244,7 +396,9 @@ declare class AgentVoice extends BaseResource {
      * @param options - Optional provider-specific options
      * @returns Promise containing the transcribed text
      */
-    listen(audio: Blob, options?: Record<string, any>): Promise<Response>;
+    listen(audio: Blob, options?: Record<string, any>): Promise<{
+        text: string;
+    }>;
     /**
      * Get available speakers for the agent's voice provider
      * @returns Promise containing list of available speakers
@@ -253,6 +407,13 @@ declare class AgentVoice extends BaseResource {
         voiceId: string;
         [key: string]: any;
     }>>;
+    /**
+     * Get the listener configuration for the agent's voice provider
+     * @returns Promise containing a check if the agent has listening capabilities
+     */
+    getListener(): Promise<{
+        enabled: boolean;
+    }>;
 }
 declare class Agent extends BaseResource {
     private agentId;
@@ -268,14 +429,31 @@ declare class Agent extends BaseResource {
      * @param params - Generation parameters including prompt
      * @returns Promise containing the generated response
      */
-    generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: GenerateParams<T>): Promise<GenerateReturn<T>>;
+    generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: GenerateParams<T> & {
+        output?: never;
+        experimental_output?: never;
+    }): Promise<GenerateReturn<T>>;
+    generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: GenerateParams<T> & {
+        output: T;
+        experimental_output?: never;
+    }): Promise<GenerateReturn<T>>;
+    generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: GenerateParams<T> & {
+        output?: never;
+        experimental_output: T;
+    }): Promise<GenerateReturn<T>>;
+    private processChatResponse;
+    /**
+     * Processes the stream response and handles tool calls
+     */
+    private processStreamResponse;
     /**
      * Streams a response from the agent
      * @param params - Stream parameters including prompt
-     * @returns Promise containing the enhanced Response object with processDataStream method
+     * @returns Promise containing the enhanced Response object with processDataStream and processTextStream methods
      */
     stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response & {
         processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+        processTextStream: (options?: Omit<Parameters<typeof processTextStream>[0], 'stream'>) => Promise<void>;
     }>;
     /**
      * Gets details about a specific tool available to the agent
@@ -283,6 +461,16 @@ declare class Agent extends BaseResource {
      * @returns Promise containing tool details
      */
     getTool(toolId: string): Promise<GetToolResponse>;
+    /**
+     * Executes a tool for the agent
+     * @param toolId - ID of the tool to execute
+     * @param params - Parameters required for tool execution
+     * @returns Promise containing the tool execution results
+     */
+    executeTool(toolId: string, params: {
+        data: any;
+        runtimeContext?: RuntimeContext;
+    }): Promise<any>;
     /**
      * Retrieves evaluation results for the agent
      * @returns Promise containing agent evaluations
@@ -343,9 +531,10 @@ declare class MemoryThread extends BaseResource {
     }>;
     /**
      * Retrieves messages associated with the thread
+     * @param params - Optional parameters including limit for number of messages to retrieve
      * @returns Promise containing thread messages and UI messages
      */
-    getMessages(): Promise<GetMemoryThreadMessagesResponse>;
+    getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse>;
 }
 
 declare class Vector extends BaseResource {
@@ -394,28 +583,22 @@ declare class Vector extends BaseResource {
     query(params: QueryVectorParams): Promise<QueryVectorResponse>;
 }
 
-declare class Workflow extends BaseResource {
+declare class LegacyWorkflow extends BaseResource {
     private workflowId;
     constructor(options: ClientOptions, workflowId: string);
     /**
-     * Retrieves details about the workflow
-     * @returns Promise containing workflow details including steps and graphs
-     */
-    details(): Promise<GetWorkflowResponse>;
-    /**
-     * Retrieves all runs for a workflow
-     * @returns Promise containing workflow runs array
+     * Retrieves details about the legacy workflow
+     * @returns Promise containing legacy workflow details including steps and graphs
      */
-    runs(): Promise<GetWorkflowRunsResponse>;
+    details(): Promise<GetLegacyWorkflowResponse>;
     /**
-     * @deprecated Use `startAsync` instead
-     * Executes the workflow with the provided parameters
-     * @param params - Parameters required for workflow execution
-     * @returns Promise containing the workflow execution results
+     * Retrieves all runs for a legacy workflow
+     * @param params - Parameters for filtering runs
+     * @returns Promise containing legacy workflow runs array
      */
-    execute(params: Record<string, any>): Promise<WorkflowRunResult>;
+    runs(params?: GetWorkflowRunsParams): Promise<GetLegacyWorkflowRunsResponse>;
     /**
-     * Creates a new workflow run
+     * Creates a new legacy workflow run
      * @returns Promise containing the generated run ID
      */
     createRun(params?: {
@@ -424,7 +607,7 @@ declare class Workflow extends BaseResource {
         runId: string;
     }>;
     /**
-     * Starts a workflow run synchronously without waiting for the workflow to complete
+     * Starts a legacy workflow run synchronously without waiting for the workflow to complete
      * @param params - Object containing the runId and triggerData
      * @returns Promise containing success message
      */
@@ -435,11 +618,11 @@ declare class Workflow extends BaseResource {
         message: string;
     }>;
     /**
-     * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
+     * Resumes a suspended legacy workflow step synchronously without waiting for the workflow to complete
      * @param stepId - ID of the step to resume
-     * @param runId - ID of the workflow run
-     * @param context - Context to resume the workflow with
-     * @returns Promise containing the workflow resume results
+     * @param runId - ID of the legacy workflow run
+     * @param context - Context to resume the legacy workflow with
+     * @returns Promise containing the legacy workflow resume results
      */
     resume({ stepId, runId, context, }: {
         stepId: string;
@@ -456,9 +639,9 @@ declare class Workflow extends BaseResource {
     startAsync(params: {
         runId?: string;
         triggerData: Record<string, any>;
-    }): Promise<WorkflowRunResult>;
+    }): Promise<LegacyWorkflowRunResult>;
     /**
-     * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+     * Resumes a suspended legacy workflow step asynchronously and returns a promise that resolves when the workflow is complete
      * @param params - Object containing the runId, stepId, and context
      * @returns Promise containing the workflow resume results
      */
@@ -466,7 +649,7 @@ declare class Workflow extends BaseResource {
         runId: string;
         stepId: string;
         context: Record<string, any>;
-    }): Promise<WorkflowRunResult>;
+    }): Promise<LegacyWorkflowRunResult>;
     /**
      * Creates an async generator that processes a readable stream and yields records
      * separated by the Record Separator character (\x1E)
@@ -476,13 +659,13 @@ declare class Workflow extends BaseResource {
      */
     private streamProcessor;
     /**
-     * Watches workflow transitions in real-time
+     * Watches legacy workflow transitions in real-time
      * @param runId - Optional run ID to filter the watch stream
-     * @returns AsyncGenerator that yields parsed records from the workflow watch stream
+     * @returns AsyncGenerator that yields parsed records from the legacy workflow watch stream
      */
     watch({ runId }: {
         runId?: string;
-    }, onRecord: (record: WorkflowRunResult) => void): Promise<void>;
+    }, onRecord: (record: LegacyWorkflowRunResult) => void): Promise<void>;
 }
 
 declare class Tool extends BaseResource {
@@ -501,14 +684,15 @@ declare class Tool extends BaseResource {
     execute(params: {
         data: any;
         runId?: string;
+        runtimeContext?: RuntimeContext | Record<string, any>;
     }): Promise<any>;
 }
 
-declare class VNextWorkflow extends BaseResource {
+declare class Workflow extends BaseResource {
     private workflowId;
     constructor(options: ClientOptions, workflowId: string);
     /**
-     * Creates an async generator that processes a readable stream and yields vNext workflow records
+     * Creates an async generator that processes a readable stream and yields workflow records
      * separated by the Record Separator character (\x1E)
      *
      * @param stream - The readable stream to process
@@ -516,17 +700,50 @@ declare class VNextWorkflow extends BaseResource {
      */
     private streamProcessor;
     /**
-     * Retrieves details about the vNext workflow
-     * @returns Promise containing vNext workflow details including steps and graphs
+     * Retrieves details about the workflow
+     * @returns Promise containing workflow details including steps and graphs
+     */
+    details(): Promise<GetWorkflowResponse>;
+    /**
+     * Retrieves all runs for a workflow
+     * @param params - Parameters for filtering runs
+     * @returns Promise containing workflow runs array
      */
-    details(): Promise<GetVNextWorkflowResponse>;
+    runs(params?: GetWorkflowRunsParams): Promise<GetWorkflowRunsResponse>;
+    /**
+     * Retrieves a specific workflow run by its ID
+     * @param runId - The ID of the workflow run to retrieve
+     * @returns Promise containing the workflow run details
+     */
+    runById(runId: string): Promise<GetWorkflowRunByIdResponse>;
+    /**
+     * Retrieves the execution result for a specific workflow run by its ID
+     * @param runId - The ID of the workflow run to retrieve the execution result for
+     * @returns Promise containing the workflow run execution result
+     */
+    runExecutionResult(runId: string): Promise<GetWorkflowRunExecutionResultResponse>;
+    /**
+     * Cancels a specific workflow run by its ID
+     * @param runId - The ID of the workflow run to cancel
+     * @returns Promise containing a success message
+     */
+    cancelRun(runId: string): Promise<{
+        message: string;
+    }>;
     /**
-     * Retrieves all runs for a vNext workflow
-     * @returns Promise containing vNext workflow runs array
+     * Sends an event to a specific workflow run by its ID
+     * @param params - Object containing the runId, event and data
+     * @returns Promise containing a success message
      */
-    runs(): Promise<GetWorkflowRunsResponse>;
+    sendRunEvent(params: {
+        runId: string;
+        event: string;
+        data: unknown;
+    }): Promise<{
+        message: string;
+    }>;
     /**
-     * Creates a new vNext workflow run
+     * Creates a new workflow run
      * @param params - Optional object containing the optional runId
      * @returns Promise containing the runId of the created run
      */
@@ -536,59 +753,213 @@ declare class VNextWorkflow extends BaseResource {
         runId: string;
     }>;
     /**
-     * Starts a vNext workflow run synchronously without waiting for the workflow to complete
+     * Starts a workflow run synchronously without waiting for the workflow to complete
      * @param params - Object containing the runId, inputData and runtimeContext
      * @returns Promise containing success message
      */
     start(params: {
         runId: string;
         inputData: Record<string, any>;
-        runtimeContext?: RuntimeContext;
+        runtimeContext?: RuntimeContext | Record<string, any>;
     }): Promise<{
         message: string;
     }>;
     /**
-     * Resumes a suspended vNext workflow step synchronously without waiting for the vNext workflow to complete
+     * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
      * @param params - Object containing the runId, step, resumeData and runtimeContext
      * @returns Promise containing success message
      */
-    resume({ step, runId, resumeData, runtimeContext, }: {
+    resume({ step, runId, resumeData, ...rest }: {
         step: string | string[];
         runId: string;
         resumeData?: Record<string, any>;
-        runtimeContext?: RuntimeContext;
+        runtimeContext?: RuntimeContext | Record<string, any>;
     }): Promise<{
         message: string;
     }>;
     /**
-     * Starts a vNext workflow run asynchronously and returns a promise that resolves when the vNext workflow is complete
+     * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
      * @param params - Object containing the optional runId, inputData and runtimeContext
-     * @returns Promise containing the vNext workflow execution results
+     * @returns Promise containing the workflow execution results
      */
     startAsync(params: {
+        runId?: string;
+        inputData: Record<string, any>;
+        runtimeContext?: RuntimeContext | Record<string, any>;
+    }): Promise<WorkflowRunResult>;
+    /**
+     * Starts a workflow run and returns a stream
+     * @param params - Object containing the optional runId, inputData and runtimeContext
+     * @returns Promise containing the workflow execution results
+     */
+    stream(params: {
         runId?: string;
         inputData: Record<string, any>;
         runtimeContext?: RuntimeContext;
-    }): Promise<VNextWorkflowRunResult>;
+    }): Promise<stream_web.ReadableStream<{
+        type: string;
+        payload: any;
+    }>>;
     /**
-     * Resumes a suspended vNext workflow step asynchronously and returns a promise that resolves when the vNext workflow is complete
+     * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
      * @param params - Object containing the runId, step, resumeData and runtimeContext
-     * @returns Promise containing the vNext workflow resume results
+     * @returns Promise containing the workflow resume results
      */
     resumeAsync(params: {
         runId: string;
         step: string | string[];
         resumeData?: Record<string, any>;
-        runtimeContext?: RuntimeContext;
-    }): Promise<VNextWorkflowRunResult>;
+        runtimeContext?: RuntimeContext | Record<string, any>;
+    }): Promise<WorkflowRunResult>;
     /**
-     * Watches vNext workflow transitions in real-time
+     * Watches workflow transitions in real-time
      * @param runId - Optional run ID to filter the watch stream
-     * @returns AsyncGenerator that yields parsed records from the vNext workflow watch stream
+     * @returns AsyncGenerator that yields parsed records from the workflow watch stream
      */
     watch({ runId }: {
         runId?: string;
-    }, onRecord: (record: VNextWorkflowWatchResult) => void): Promise<void>;
+    }, onRecord: (record: WorkflowWatchResult) => void): Promise<void>;
+    /**
+     * Creates a new ReadableStream from an iterable or async iterable of objects,
+     * serializing each as JSON and separating them with the record separator (\x1E).
+     *
+     * @param records - An iterable or async iterable of objects to stream
+     * @returns A ReadableStream emitting the records as JSON strings separated by the record separator
+     */
+    static createRecordStream(records: Iterable<any> | AsyncIterable<any>): ReadableStream;
+}
+
+/**
+ * Class for interacting with an agent via the A2A protocol
+ */
+declare class A2A extends BaseResource {
+    private agentId;
+    constructor(options: ClientOptions, agentId: string);
+    /**
+     * Get the agent card with metadata about the agent
+     * @returns Promise containing the agent card information
+     */
+    getCard(): Promise<AgentCard>;
+    /**
+     * Send a message to the agent and get a response
+     * @param params - Parameters for the task
+     * @returns Promise containing the task response
+     */
+    sendMessage(params: TaskSendParams): Promise<{
+        task: Task;
+    }>;
+    /**
+     * Get the status and result of a task
+     * @param params - Parameters for querying the task
+     * @returns Promise containing the task response
+     */
+    getTask(params: TaskQueryParams): Promise<Task>;
+    /**
+     * Cancel a running task
+     * @param params - Parameters identifying the task to cancel
+     * @returns Promise containing the task response
+     */
+    cancelTask(params: TaskIdParams): Promise<{
+        task: Task;
+    }>;
+    /**
+     * Send a message and subscribe to streaming updates (not fully implemented)
+     * @param params - Parameters for the task
+     * @returns Promise containing the task response
+     */
+    sendAndSubscribe(params: TaskSendParams): Promise<Response>;
+}
+
+/**
+ * Represents a specific tool available on a specific MCP server.
+ * Provides methods to get details and execute the tool.
+ */
+declare class MCPTool extends BaseResource {
+    private serverId;
+    private toolId;
+    constructor(options: ClientOptions, serverId: string, toolId: string);
+    /**
+     * Retrieves details about this specific tool from the MCP server.
+     * @returns Promise containing the tool's information (name, description, schema).
+     */
+    details(): Promise<McpToolInfo>;
+    /**
+     * Executes this specific tool on the MCP server.
+     * @param params - Parameters for tool execution, including data/args and optional runtimeContext.
+     * @returns Promise containing the result of the tool execution.
+     */
+    execute(params: {
+        data?: any;
+        runtimeContext?: RuntimeContext;
+    }): Promise<any>;
+}
+
+declare class NetworkMemoryThread extends BaseResource {
+    private threadId;
+    private networkId;
+    constructor(options: ClientOptions, threadId: string, networkId: string);
+    /**
+     * Retrieves the memory thread details
+     * @returns Promise containing thread details including title and metadata
+     */
+    get(): Promise<StorageThreadType>;
+    /**
+     * Updates the memory thread properties
+     * @param params - Update parameters including title and metadata
+     * @returns Promise containing updated thread details
+     */
+    update(params: UpdateMemoryThreadParams): Promise<StorageThreadType>;
+    /**
+     * Deletes the memory thread
+     * @returns Promise containing deletion result
+     */
+    delete(): Promise<{
+        result: string;
+    }>;
+    /**
+     * Retrieves messages associated with the thread
+     * @param params - Optional parameters including limit for number of messages to retrieve
+     * @returns Promise containing thread messages and UI messages
+     */
+    getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse>;
+}
+
+declare class VNextNetwork extends BaseResource {
+    private networkId;
+    constructor(options: ClientOptions, networkId: string);
+    /**
+     * Retrieves details about the network
+     * @returns Promise containing vNext network details
+     */
+    details(): Promise<GetVNextNetworkResponse>;
+    /**
+     * Generates a response from the v-next network
+     * @param params - Generation parameters including message
+     * @returns Promise containing the generated response
+     */
+    generate(params: GenerateOrStreamVNextNetworkParams): Promise<GenerateVNextNetworkResponse>;
+    /**
+     * Generates a response from the v-next network using multiple primitives
+     * @param params - Generation parameters including message
+     * @returns Promise containing the generated response
+     */
+    loop(params: {
+        message: string;
+        runtimeContext?: RuntimeContext | Record<string, any>;
+    }): Promise<LoopVNextNetworkResponse>;
+    private streamProcessor;
+    /**
+     * Streams a response from the v-next network
+     * @param params - Stream parameters including message
+     * @returns Promise containing the results
+     */
+    stream(params: GenerateOrStreamVNextNetworkParams, onRecord: (record: WatchEvent) => void): Promise<void>;
+    /**
+     * Streams a response from the v-next network loop
+     * @param params - Stream parameters including message
+     * @returns Promise containing the results
+     */
+    loopStream(params: LoopStreamVNextNetworkParams, onRecord: (record: WatchEvent) => void): Promise<void>;
 }
 
 declare class MastraClient extends BaseResource {
@@ -598,6 +969,9 @@ declare class MastraClient extends BaseResource {
      * @returns Promise containing map of agent IDs to agent details
      */
     getAgents(): Promise<Record<string, GetAgentResponse>>;
+    getAGUI({ resourceId }: {
+        resourceId: string;
+    }): Promise<Record<string, AbstractAgent>>;
     /**
      * Gets an agent instance by ID
      * @param agentId - ID of the agent to retrieve
@@ -635,6 +1009,37 @@ declare class MastraClient extends BaseResource {
     getMemoryStatus(agentId: string): Promise<{
         result: boolean;
     }>;
+    /**
+     * Retrieves memory threads for a resource
+     * @param params - Parameters containing the resource ID
+     * @returns Promise containing array of memory threads
+     */
+    getNetworkMemoryThreads(params: GetNetworkMemoryThreadParams): Promise<GetMemoryThreadResponse>;
+    /**
+     * Creates a new memory thread
+     * @param params - Parameters for creating the memory thread
+     * @returns Promise containing the created memory thread
+     */
+    createNetworkMemoryThread(params: CreateNetworkMemoryThreadParams): Promise<CreateMemoryThreadResponse>;
+    /**
+     * Gets a memory thread instance by ID
+     * @param threadId - ID of the memory thread to retrieve
+     * @returns MemoryThread instance
+     */
+    getNetworkMemoryThread(threadId: string, networkId: string): NetworkMemoryThread;
+    /**
+     * Saves messages to memory
+     * @param params - Parameters containing messages to save
+     * @returns Promise containing the saved messages
+     */
+    saveNetworkMessageToMemory(params: SaveNetworkMessageToMemoryParams): Promise<SaveMessageToMemoryResponse>;
+    /**
+     * Gets the status of the memory system
+     * @returns Promise containing memory system status
+     */
+    getNetworkMemoryStatus(networkId: string): Promise<{
+        result: boolean;
+    }>;
     /**
      * Retrieves all available tools
      * @returns Promise containing map of tool IDs to tool details
@@ -646,6 +1051,17 @@ declare class MastraClient extends BaseResource {
      * @returns Tool instance
      */
     getTool(toolId: string): Tool;
+    /**
+     * Retrieves all available legacy workflows
+     * @returns Promise containing map of legacy workflow IDs to legacy workflow details
+     */
+    getLegacyWorkflows(): Promise<Record<string, GetLegacyWorkflowResponse>>;
+    /**
+     * Gets a legacy workflow instance by ID
+     * @param workflowId - ID of the legacy workflow to retrieve
+     * @returns Legacy Workflow instance
+     */
+    getLegacyWorkflow(workflowId: string): LegacyWorkflow;
     /**
      * Retrieves all available workflows
      * @returns Promise containing map of workflow IDs to workflow details
@@ -657,17 +1073,6 @@ declare class MastraClient extends BaseResource {
      * @returns Workflow instance
      */
     getWorkflow(workflowId: string): Workflow;
-    /**
-     * Retrieves all available vNext workflows
-     * @returns Promise containing map of vNext workflow IDs to vNext workflow details
-     */
-    getVNextWorkflows(): Promise<Record<string, GetVNextWorkflowResponse>>;
-    /**
-     * Gets a vNext workflow instance by ID
-     * @param workflowId - ID of the vNext workflow to retrieve
-     * @returns vNext Workflow instance
-     */
-    getVNextWorkflow(workflowId: string): VNextWorkflow;
     /**
      * Gets a vector instance by name
      * @param vectorName - Name of the vector to retrieve
@@ -703,13 +1108,87 @@ declare class MastraClient extends BaseResource {
      * Retrieves all available networks
      * @returns Promise containing map of network IDs to network details
      */
-    getNetworks(): Promise<Record<string, GetNetworkResponse>>;
+    getNetworks(): Promise<Array<GetNetworkResponse>>;
+    /**
+     * Retrieves all available vNext networks
+     * @returns Promise containing map of vNext network IDs to vNext network details
+     */
+    getVNextNetworks(): Promise<Array<GetVNextNetworkResponse>>;
     /**
      * Gets a network instance by ID
      * @param networkId - ID of the network to retrieve
      * @returns Network instance
      */
     getNetwork(networkId: string): Network;
+    /**
+     * Gets a vNext network instance by ID
+     * @param networkId - ID of the vNext network to retrieve
+     * @returns vNext Network instance
+     */
+    getVNextNetwork(networkId: string): VNextNetwork;
+    /**
+     * Retrieves a list of available MCP servers.
+     * @param params - Optional parameters for pagination (limit, offset).
+     * @returns Promise containing the list of MCP servers and pagination info.
+     */
+    getMcpServers(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<McpServerListResponse>;
+    /**
+     * Retrieves detailed information for a specific MCP server.
+     * @param serverId - The ID of the MCP server to retrieve.
+     * @param params - Optional parameters, e.g., specific version.
+     * @returns Promise containing the detailed MCP server information.
+     */
+    getMcpServerDetails(serverId: string, params?: {
+        version?: string;
+    }): Promise<ServerDetailInfo>;
+    /**
+     * Retrieves a list of tools for a specific MCP server.
+     * @param serverId - The ID of the MCP server.
+     * @returns Promise containing the list of tools.
+     */
+    getMcpServerTools(serverId: string): Promise<McpServerToolListResponse>;
+    /**
+     * Gets an MCPTool resource instance for a specific tool on an MCP server.
+     * This instance can then be used to fetch details or execute the tool.
+     * @param serverId - The ID of the MCP server.
+     * @param toolId - The ID of the tool.
+     * @returns MCPTool instance.
+     */
+    getMcpServerTool(serverId: string, toolId: string): MCPTool;
+    /**
+     * Gets an A2A client for interacting with an agent via the A2A protocol
+     * @param agentId - ID of the agent to interact with
+     * @returns A2A client instance
+     */
+    getA2A(agentId: string): A2A;
+    /**
+     * Retrieves the working memory for a specific thread (optionally resource-scoped).
+     * @param agentId - ID of the agent.
+     * @param threadId - ID of the thread.
+     * @param resourceId - Optional ID of the resource.
+     * @returns Working memory for the specified thread or resource.
+     */
+    getWorkingMemory({ agentId, threadId, resourceId, }: {
+        agentId: string;
+        threadId: string;
+        resourceId?: string;
+    }): Promise<unknown>;
+    /**
+     * Updates the working memory for a specific thread (optionally resource-scoped).
+     * @param agentId - ID of the agent.
+     * @param threadId - ID of the thread.
+     * @param workingMemory - The new working memory content.
+     * @param resourceId - Optional ID of the resource.
+     */
+    updateWorkingMemory({ agentId, threadId, workingMemory, resourceId, }: {
+        agentId: string;
+        threadId: string;
+        workingMemory: string;
+        resourceId?: string;
+    }): Promise<unknown>;
 }
 
-export { type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, type GenerateParams, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetNetworkResponse, type GetTelemetryParams, type GetTelemetryResponse, type GetToolResponse, type GetVNextWorkflowResponse, type GetVectorIndexResponse, type GetWorkflowResponse, type GetWorkflowRunsResponse, MastraClient, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type StreamParams, type UpdateMemoryThreadParams, type UpsertVectorParams, type VNextWorkflowRunResult, type VNextWorkflowWatchResult, type WorkflowRunResult };
+export { type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, type CreateNetworkMemoryThreadParams, type GenerateOrStreamVNextNetworkParams, type GenerateParams, type GenerateVNextNetworkResponse, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLegacyWorkflowResponse, type GetLegacyWorkflowRunsResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesParams, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetNetworkMemoryThreadParams, type GetNetworkResponse, type GetTelemetryParams, type GetTelemetryResponse, type GetToolResponse, type GetVNextNetworkResponse, type GetVectorIndexResponse, type GetWorkflowResponse, type GetWorkflowRunByIdResponse, type GetWorkflowRunExecutionResultResponse, type GetWorkflowRunsParams, type GetWorkflowRunsResponse, type LegacyWorkflowRunResult, type LoopStreamVNextNetworkParams, type LoopVNextNetworkResponse, MastraClient, type McpServerListResponse, type McpServerToolListResponse, type McpToolInfo, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type SaveNetworkMessageToMemoryParams, type StreamParams, type UpdateMemoryThreadParams, type UpsertVectorParams, type WorkflowRunResult, type WorkflowWatchResult };