@mastra/client-js 0.0.0-a2a-20250421213654 → 0.0.0-add-runtime-context-to-openai-realtime-20250516201052

package/dist/index.d.cts

@@ -1,8 +1,14 @@
-import { CoreMessage, AiMessageType, StorageThreadType, MessageType, StepAction, StepGraph, WorkflowRunResult as WorkflowRunResult$1, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
+import { AbstractAgent } from '@ag-ui/client';
+import { processDataStream } from '@ai-sdk/ui-utils';
+import { StepAction, StepGraph, CoreMessage, AiMessageType, StorageThreadType, MessageType, WorkflowRuns, WorkflowRunResult as WorkflowRunResult$1, VNextWorkflowRuns, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
-import { processDataStream } from '@ai-sdk/ui-utils';
 import { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
+import { RuntimeContext } from '@mastra/core/runtime-context';
+import { ServerInfo, ServerDetailInfo } from '@mastra/core/mcp';
+import { NewWorkflow, WorkflowResult, WatchEvent } from '@mastra/core/workflows/vNext';
+import { RuntimeContext as RuntimeContext$1 } from '@mastra/core/di';
+import { AgentCard, TaskSendParams, Task, TaskQueryParams, TaskIdParams } from '@mastra/core/a2a';
 
 interface ClientOptions {
     /** Base URL for API requests */
@@ -23,21 +29,36 @@ interface RequestOptions {
     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;
 }
 type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
     messages: string | string[] | CoreMessage[] | AiMessageType[];
-} & Partial<AgentGenerateOptions<T>>;
+    output?: T;
+    experimental_output?: T;
+    runtimeContext?: RuntimeContext;
+} & WithoutMethods<Omit<AgentGenerateOptions<T>, 'output' | 'experimental_output' | 'runtimeContext'>>;
 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;
+} & WithoutMethods<Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext'>>;
 interface GetEvalsByAgentIdResponse extends GetAgentResponse {
     evals: any[];
+    instructions: string;
+    name: string;
+    id: string;
 }
 interface GetToolResponse {
     id: string;
@@ -53,6 +74,15 @@ interface GetWorkflowResponse {
     stepSubscriberGraph: Record<string, StepGraph>;
     workflowId?: string;
 }
+interface GetWorkflowRunsParams {
+    fromDate?: Date;
+    toDate?: Date;
+    limit?: number;
+    offset?: number;
+    resourceId?: string;
+}
+type GetWorkflowRunsResponse = WorkflowRuns;
+type GetVNextWorkflowRunsResponse = VNextWorkflowRuns;
 type WorkflowRunResult = {
     activePaths: Record<string, {
         status: string;
@@ -63,6 +93,26 @@ type WorkflowRunResult = {
     timestamp: number;
     runId: string;
 };
+interface GetVNextWorkflowResponse {
+    name: string;
+    steps: {
+        [key: string]: {
+            id: string;
+            description: string;
+            inputSchema: string;
+            outputSchema: string;
+            resumeSchema: string;
+            suspendSchema: string;
+        };
+    };
+    stepGraph: NewWorkflow['serializedStepGraph'];
+    inputSchema: string;
+    outputSchema: string;
+}
+type VNextWorkflowWatchResult = WatchEvent & {
+    runId: string;
+};
+type VNextWorkflowRunResult = WorkflowResult<any, any>;
 interface UpsertVectorParams {
     indexName: string;
     vectors: number[][];
@@ -97,7 +147,7 @@ type SaveMessageToMemoryResponse = MessageType[];
 interface CreateMemoryThreadParams {
     title: string;
     metadata: Record<string, any>;
-    resourceid: string;
+    resourceId: string;
     threadId: string;
     agentId: string;
 }
@@ -110,7 +160,13 @@ type GetMemoryThreadResponse = StorageThreadType[];
 interface UpdateMemoryThreadParams {
     title: string;
     metadata: Record<string, any>;
-    resourceid: string;
+    resourceId: string;
+}
+interface GetMemoryThreadMessagesParams {
+    /**
+     * Limit the number of messages to retrieve (default: 40)
+     */
+    limit?: number;
 }
 interface GetMemoryThreadMessagesResponse {
     messages: CoreMessage[];
@@ -171,6 +227,8 @@ interface GetTelemetryParams {
     page?: number;
     perPage?: number;
     attribute?: Record<string, string>;
+    fromDate?: Date;
+    toDate?: Date;
 }
 interface GetNetworkResponse {
     name: string;
@@ -186,104 +244,19 @@ interface GetNetworkResponse {
     };
     state?: Record<string, any>;
 }
-declare enum TaskState {
-    PENDING = "pending",
-    RUNNING = "running",
-    COMPLETED = "completed",
-    FAILED = "failed",
-    CANCELED = "canceled"
-}
-declare enum ErrorCode {
-    PARSE_ERROR = -32700,
-    INVALID_REQUEST = -32600,
-    METHOD_NOT_FOUND = -32601,
-    INVALID_PARAMS = -32602,
-    INTERNAL_ERROR = -32603,
-    TASK_NOT_FOUND = -32000,
-    TASK_NOT_CANCELABLE = -32001
-}
-interface A2AMessagePart {
-    type: string;
-    [key: string]: any;
-}
-interface A2AMessage {
-    role: 'user' | 'agent';
-    parts: A2AMessagePart[];
-}
-interface TaskStatus {
-    state: TaskState;
-    message?: A2AMessage;
-    timestamp: string;
-}
-interface Task {
-    id: string;
-    sessionId: string | null;
-    status: TaskStatus;
-    history: A2AMessage[];
-}
-interface JSONRPCRequest {
-    jsonrpc: '2.0';
-    id: string | number | null;
-    method: string;
-    params: Record<string, any>;
-}
-interface SendTaskRequest extends JSONRPCRequest {
-    method: 'tasks/send';
-    params: {
-        id: string;
-        message: A2AMessage;
-        sessionId?: string;
-    };
-}
-interface GetTaskRequest extends JSONRPCRequest {
-    method: 'tasks/get';
-    params: {
-        id: string;
-        historyLength?: number;
-    };
-}
-interface CancelTaskRequest extends JSONRPCRequest {
-    method: 'tasks/cancel';
-    params: {
-        id: string;
-    };
-}
-type A2ARequest = SendTaskRequest | GetTaskRequest | CancelTaskRequest;
-interface JSONRPCSuccessResponse {
-    jsonrpc: '2.0';
-    id: string | number | null;
-    result: any;
-}
-interface JSONRPCErrorResponse {
-    jsonrpc: '2.0';
-    id: string | number | null;
-    error: {
-        code: ErrorCode;
-        message: string;
-        data?: any;
-    };
-}
-type JSONRPCResponse = JSONRPCSuccessResponse | JSONRPCErrorResponse;
-interface AgentCapabilities {
-    tasks: {
-        send: boolean;
-        get: boolean;
-        cancel: boolean;
-    };
-    pushNotifications: boolean;
+interface McpServerListResponse {
+    servers: ServerInfo[];
+    next: string | null;
+    total_count: number;
 }
-interface AgentSkill {
+interface McpToolInfo {
     id: string;
     name: string;
-    description: string;
+    description?: string;
+    inputSchema: string;
 }
-interface AgentCard {
-    name: string;
-    description: string;
-    url: string;
-    version: string;
-    capabilities: AgentCapabilities;
-    skills: AgentSkill[];
+interface McpServerToolListResponse {
+    tools: McpToolInfo[];
 }
 
 declare class BaseResource {
@@ -317,7 +290,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
@@ -356,6 +331,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$1;
+    }): Promise<any>;
     /**
      * Retrieves evaluation results for the agent
      * @returns Promise containing agent evaluations
@@ -416,9 +401,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 {
@@ -475,6 +461,12 @@ declare class Workflow extends BaseResource {
      * @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
+     */
+    runs(params?: GetWorkflowRunsParams): Promise<GetWorkflowRunsResponse>;
     /**
      * @deprecated Use `startAsync` instead
      * Executes the workflow with the provided parameters
@@ -568,51 +560,162 @@ declare class Tool extends BaseResource {
      */
     execute(params: {
         data: any;
+        runId?: string;
+        runtimeContext?: RuntimeContext$1;
     }): Promise<any>;
 }
 
+declare class VNextWorkflow extends BaseResource {
+    private workflowId;
+    constructor(options: ClientOptions, workflowId: string);
+    /**
+     * Creates an async generator that processes a readable stream and yields vNext workflow records
+     * separated by the Record Separator character (\x1E)
+     *
+     * @param stream - The readable stream to process
+     * @returns An async generator that yields parsed records
+     */
+    private streamProcessor;
+    /**
+     * Retrieves details about the vNext workflow
+     * @returns Promise containing vNext workflow details including steps and graphs
+     */
+    details(): Promise<GetVNextWorkflowResponse>;
+    /**
+     * Retrieves all runs for a vNext workflow
+     * @param params - Parameters for filtering runs
+     * @returns Promise containing vNext workflow runs array
+     */
+    runs(params?: GetWorkflowRunsParams): Promise<GetVNextWorkflowRunsResponse>;
+    /**
+     * Creates a new vNext workflow run
+     * @param params - Optional object containing the optional runId
+     * @returns Promise containing the runId of the created run
+     */
+    createRun(params?: {
+        runId?: string;
+    }): Promise<{
+        runId: string;
+    }>;
+    /**
+     * Starts a vNext 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;
+    }): Promise<{
+        message: string;
+    }>;
+    /**
+     * Resumes a suspended vNext workflow step synchronously without waiting for the vNext workflow to complete
+     * @param params - Object containing the runId, step, resumeData and runtimeContext
+     * @returns Promise containing success message
+     */
+    resume({ step, runId, resumeData, ...rest }: {
+        step: string | string[];
+        runId: string;
+        resumeData?: Record<string, any>;
+        runtimeContext?: RuntimeContext;
+    }): Promise<{
+        message: string;
+    }>;
+    /**
+     * Starts a vNext workflow run asynchronously and returns a promise that resolves when the vNext workflow is complete
+     * @param params - Object containing the optional runId, inputData and runtimeContext
+     * @returns Promise containing the vNext workflow execution results
+     */
+    startAsync(params: {
+        runId?: string;
+        inputData: Record<string, any>;
+        runtimeContext?: RuntimeContext;
+    }): Promise<VNextWorkflowRunResult>;
+    /**
+     * Resumes a suspended vNext workflow step asynchronously and returns a promise that resolves when the vNext workflow is complete
+     * @param params - Object containing the runId, step, resumeData and runtimeContext
+     * @returns Promise containing the vNext workflow resume results
+     */
+    resumeAsync(params: {
+        runId: string;
+        step: string | string[];
+        resumeData?: Record<string, any>;
+        runtimeContext?: RuntimeContext;
+    }): Promise<VNextWorkflowRunResult>;
+    /**
+     * Watches vNext 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
+     */
+    watch({ runId }: {
+        runId?: string;
+    }, onRecord: (record: VNextWorkflowWatchResult) => void): Promise<void>;
+}
+
 /**
- * A2A Protocol resource for agent-to-agent communication
+ * Class for interacting with an agent via the A2A protocol
  */
 declare class A2A extends BaseResource {
+    private agentId;
+    constructor(options: ClientOptions, agentId: string);
     /**
-     * Sends an A2A protocol request to the server
-     * @param request - The A2A protocol request
-     * @returns Promise containing the A2A protocol response
+     * Get the agent card with metadata about the agent
+     * @returns Promise containing the agent card information
      */
-    sendRequest(request: A2ARequest): Promise<JSONRPCResponse>;
+    getCard(): Promise<AgentCard>;
     /**
-     * Sends a task to an agent using the A2A protocol
-     * @param params - Parameters for sending the task
-     * @returns Promise containing the task
+     * Send a message to the agent and get a response
+     * @param params - Parameters for the task
+     * @returns Promise containing the task response
      */
-    sendTask(params: {
-        id: string;
-        message: A2AMessage;
-        sessionId?: string;
-    }): Promise<Task>;
+    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>;
     /**
-     * Gets a task by ID using the A2A protocol
-     * @param params - Parameters for getting the task
-     * @returns Promise containing the task
+     * Cancel a running task
+     * @param params - Parameters identifying the task to cancel
+     * @returns Promise containing the task response
      */
-    getTask(params: {
-        id: string;
-        historyLength?: number;
-    }): Promise<Task>;
+    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);
     /**
-     * Cancels a task by ID using the A2A protocol
-     * @param params - Parameters for canceling the task
-     * @returns Promise containing the task
+     * Retrieves details about this specific tool from the MCP server.
+     * @returns Promise containing the tool's information (name, description, schema).
      */
-    cancelTask(params: {
-        id: string;
-    }): Promise<Task>;
+    details(): Promise<McpToolInfo>;
     /**
-     * Gets the agent card for the A2A protocol
-     * @returns Promise containing the agent card
+     * 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.
      */
-    getAgentCard(): Promise<AgentCard>;
+    execute(params: {
+        data?: any;
+        runtimeContext?: RuntimeContext;
+    }): Promise<any>;
 }
 
 declare class MastraClient extends BaseResource {
@@ -622,6 +725,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
@@ -681,6 +787,17 @@ 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
@@ -724,10 +841,43 @@ declare class MastraClient extends BaseResource {
      */
     getNetwork(networkId: string): Network;
     /**
-     * Gets an A2A protocol instance for agent-to-agent communication
-     * @returns A2A instance
+     * 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(): A2A;
+    getA2A(agentId: string): A2A;
 }
 
-export { type A2AMessage, type A2AMessagePart, type A2ARequest, type AgentCapabilities, type AgentCard, type AgentSkill, type CancelTaskRequest, type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, ErrorCode, type GenerateParams, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetNetworkResponse, type GetTaskRequest, type GetTelemetryParams, type GetTelemetryResponse, type GetToolResponse, type GetVectorIndexResponse, type GetWorkflowResponse, type JSONRPCErrorResponse, type JSONRPCRequest, type JSONRPCResponse, type JSONRPCSuccessResponse, MastraClient, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type SendTaskRequest, type StreamParams, type Task, TaskState, type TaskStatus, type UpdateMemoryThreadParams, type UpsertVectorParams, type WorkflowRunResult };
+export { type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, type GenerateParams, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesParams, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetNetworkResponse, type GetTelemetryParams, type GetTelemetryResponse, type GetToolResponse, type GetVNextWorkflowResponse, type GetVNextWorkflowRunsResponse, type GetVectorIndexResponse, type GetWorkflowResponse, type GetWorkflowRunsParams, type GetWorkflowRunsResponse, MastraClient, type McpServerListResponse, type McpServerToolListResponse, type McpToolInfo, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type StreamParams, type UpdateMemoryThreadParams, type UpsertVectorParams, type VNextWorkflowRunResult, type VNextWorkflowWatchResult, type WorkflowRunResult };