mcp-use 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

mcp_use/agents/remote.py

@@ -0,0 +1,296 @@
+"""
+Remote agent implementation for executing agents via API.
+"""
+
+import json
+import os
+from typing import Any, TypeVar
+
+import httpx
+from langchain.schema import BaseMessage
+from pydantic import BaseModel
+
+from ..logging import logger
+
+T = TypeVar("T", bound=BaseModel)
+
+# API endpoint constants
+API_CHATS_ENDPOINT = "/api/v1/chats"
+API_CHAT_EXECUTE_ENDPOINT = "/api/v1/chats/{chat_id}/execute"
+API_CHAT_DELETE_ENDPOINT = "/api/v1/chats/{chat_id}"
+
+
+class RemoteAgent:
+    """Agent that executes remotely via API."""
+
+    def __init__(self, agent_id: str, api_key: str | None = None, base_url: str = "https://cloud.mcp-use.com"):
+        """Initialize remote agent.
+
+        Args:
+            agent_id: The ID of the remote agent to execute
+            api_key: API key for authentication. If None, will check MCP_USE_API_KEY env var
+            base_url: Base URL for the remote API
+        """
+        self.agent_id = agent_id
+        self.base_url = base_url
+        self._chat_id = None  # Persistent chat session
+
+        # Handle API key validation
+        if api_key is None:
+            api_key = os.getenv("MCP_USE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "API key is required for remote execution. "
+                "Please provide it as a parameter or set the MCP_USE_API_KEY environment variable. "
+                "You can get an API key from https://cloud.mcp-use.com"
+            )
+
+        self.api_key = api_key
+        # Configure client with reasonable timeouts for agent execution
+        self._client = httpx.AsyncClient(
+            timeout=httpx.Timeout(
+                connect=10.0,  # 10 seconds to establish connection
+                read=300.0,  # 5 minutes to read response (agents can take time)
+                write=10.0,  # 10 seconds to send request
+                pool=10.0,  # 10 seconds to get connection from pool
+            )
+        )
+
+    def _pydantic_to_json_schema(self, model_class: type[T]) -> dict[str, Any]:
+        """Convert a Pydantic model to JSON schema for API transmission.
+
+        Args:
+            model_class: The Pydantic model class to convert
+
+        Returns:
+            JSON schema representation of the model
+        """
+        return model_class.model_json_schema()
+
+    def _parse_structured_response(self, response_data: Any, output_schema: type[T]) -> T:
+        """Parse the API response into the structured output format.
+
+        Args:
+            response_data: Raw response data from the API
+            output_schema: The Pydantic model to parse into
+
+        Returns:
+            Parsed structured output
+        """
+        # Handle different response formats
+        if isinstance(response_data, dict):
+            if "result" in response_data:
+                outer_result = response_data["result"]
+                # Check if this is a nested result structure (agent execution response)
+                if isinstance(outer_result, dict) and "result" in outer_result:
+                    # Extract the actual structured output from the nested result
+                    result_data = outer_result["result"]
+                else:
+                    # Use the outer result directly
+                    result_data = outer_result
+            else:
+                result_data = response_data
+        elif isinstance(response_data, str):
+            try:
+                result_data = json.loads(response_data)
+            except json.JSONDecodeError:
+                # If it's not valid JSON, try to create the model from the string content
+                result_data = {"content": response_data}
+        else:
+            result_data = response_data
+
+        # Parse into the Pydantic model
+        try:
+            return output_schema.model_validate(result_data)
+        except Exception as e:
+            logger.warning(f"Failed to parse structured output: {e}")
+            # Fallback: try to parse it as raw content if the model has a content field
+            if hasattr(output_schema, "model_fields") and "content" in output_schema.model_fields:
+                return output_schema.model_validate({"content": str(result_data)})
+            raise
+
+    async def _create_chat_session(self, query: str) -> str:
+        """Create a persistent chat session for the agent.
+        Args:
+            query: The initial query (not used in title anymore)
+        Returns:
+            The chat ID of the created session
+        Raises:
+            RuntimeError: If chat creation fails
+        """
+        chat_payload = {
+            "title": f"Remote Agent Session - {self.agent_id}",
+            "agent_id": self.agent_id,
+            "type": "agent_execution",
+        }
+
+        headers = {"Content-Type": "application/json", "x-api-key": self.api_key}
+        chat_url = f"{self.base_url}{API_CHATS_ENDPOINT}"
+
+        logger.info(f"📝 Creating chat session for agent {self.agent_id}")
+
+        try:
+            chat_response = await self._client.post(chat_url, json=chat_payload, headers=headers)
+            chat_response.raise_for_status()
+
+            chat_data = chat_response.json()
+            chat_id = chat_data["id"]
+            logger.info(f"✅ Chat session created: {chat_id}")
+            return chat_id
+
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            response_text = e.response.text
+
+            if status_code == 404:
+                raise RuntimeError(
+                    f"Agent not found: Agent '{self.agent_id}' does not exist or you don't have access to it. "
+                    "Please verify the agent ID and ensure it exists in your account."
+                ) from e
+            else:
+                raise RuntimeError(f"Failed to create chat session: {status_code} - {response_text}") from e
+        except Exception as e:
+            raise RuntimeError(f"Failed to create chat session: {str(e)}") from e
+
+    async def run(
+        self,
+        query: str,
+        max_steps: int | None = None,
+        manage_connector: bool = True,
+        external_history: list[BaseMessage] | None = None,
+        output_schema: type[T] | None = None,
+    ) -> str | T:
+        """Run a query on the remote agent.
+
+        Args:
+            query: The query to execute
+            max_steps: Maximum number of steps (default: 10)
+            manage_connector: Ignored for remote execution
+            external_history: Ignored for remote execution (not supported yet)
+            output_schema: Optional Pydantic model for structured output
+
+        Returns:
+            The result from the remote agent execution (string or structured output)
+        """
+        if external_history is not None:
+            logger.warning("External history is not yet supported for remote execution")
+
+        try:
+            logger.info(f"🌐 Executing query on remote agent {self.agent_id}")
+
+            # Step 1: Create a chat session for this agent (only if we don't have one)
+            if self._chat_id is None:
+                self._chat_id = await self._create_chat_session(query)
+
+            chat_id = self._chat_id
+
+            # Step 2: Execute the agent within the chat context
+            execution_payload = {"query": query, "max_steps": max_steps or 10}
+
+            # Add structured output schema if provided
+            if output_schema is not None:
+                execution_payload["output_schema"] = self._pydantic_to_json_schema(output_schema)
+                logger.info(f"🔧 Using structured output with schema: {output_schema.__name__}")
+
+            headers = {"Content-Type": "application/json", "x-api-key": self.api_key}
+            execution_url = f"{self.base_url}{API_CHAT_EXECUTE_ENDPOINT.format(chat_id=chat_id)}"
+            logger.info(f"🚀 Executing agent in chat {chat_id}")
+
+            response = await self._client.post(execution_url, json=execution_payload, headers=headers)
+            response.raise_for_status()
+
+            result = response.json()
+            logger.info(f"🔧 Response: {result}")
+            logger.info("✅ Remote execution completed successfully")
+
+            # Check for error responses (even with 200 status)
+            if isinstance(result, dict):
+                # Check for actual error conditions (not just presence of error field)
+                if result.get("status") == "error" or (result.get("error") is not None):
+                    error_msg = result.get("error", str(result))
+                    logger.error(f"❌ Remote agent execution failed: {error_msg}")
+                    raise RuntimeError(f"Remote agent execution failed: {error_msg}")
+
+                # Check if the response indicates agent initialization failure
+                if "failed to initialize" in str(result):
+                    logger.error(f"❌ Agent initialization failed: {result}")
+                    raise RuntimeError(
+                        f"Agent initialization failed on remote server. "
+                        f"This usually indicates:\n"
+                        f"• Invalid agent configuration (LLM model, system prompt)\n"
+                        f"• Missing or invalid MCP server configurations\n"
+                        f"• Network connectivity issues with MCP servers\n"
+                        f"• Missing environment variables or credentials\n"
+                        f"Raw error: {result}"
+                    )
+
+            # Handle structured output
+            if output_schema is not None:
+                return self._parse_structured_response(result, output_schema)
+
+            # Regular string output
+            if isinstance(result, dict) and "result" in result:
+                return result["result"]
+            elif isinstance(result, str):
+                return result
+            else:
+                return str(result)
+
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            response_text = e.response.text
+
+            # Provide specific error messages based on status code
+            if status_code == 401:
+                logger.error(f"❌ Authentication failed: {response_text}")
+                raise RuntimeError(
+                    "Authentication failed: Invalid or missing API key. "
+                    "Please check your API key and ensure the MCP_USE_API_KEY environment variable is set correctly."
+                ) from e
+            elif status_code == 403:
+                logger.error(f"❌ Access forbidden: {response_text}")
+                raise RuntimeError(
+                    f"Access denied: You don't have permission to execute agent '{self.agent_id}'. "
+                    "Check if the agent exists and you have the necessary permissions."
+                ) from e
+            elif status_code == 404:
+                logger.error(f"❌ Agent not found: {response_text}")
+                raise RuntimeError(
+                    f"Agent not found: Agent '{self.agent_id}' does not exist or you don't have access to it. "
+                    "Please verify the agent ID and ensure it exists in your account."
+                ) from e
+            elif status_code == 422:
+                logger.error(f"❌ Validation error: {response_text}")
+                raise RuntimeError(
+                    f"Request validation failed: {response_text}. "
+                    "Please check your query parameters and output schema format."
+                ) from e
+            elif status_code == 500:
+                logger.error(f"❌ Server error: {response_text}")
+                raise RuntimeError(
+                    "Internal server error occurred during agent execution. "
+                    "Please try again later or contact support if the issue persists."
+                ) from e
+            else:
+                logger.error(f"❌ Remote execution failed with status {status_code}: {response_text}")
+                raise RuntimeError(f"Remote agent execution failed: {status_code} - {response_text}") from e
+        except httpx.TimeoutException as e:
+            logger.error(f"❌ Remote execution timed out: {e}")
+            raise RuntimeError(
+                "Remote agent execution timed out. The server may be overloaded or the query is taking too long to "
+                "process. Try again or use a simpler query."
+            ) from e
+        except httpx.ConnectError as e:
+            logger.error(f"❌ Remote execution connection error: {e}")
+            raise RuntimeError(
+                f"Remote agent connection failed: Cannot connect to {self.base_url}. "
+                f"Check if the server is running and the URL is correct."
+            ) from e
+        except Exception as e:
+            logger.error(f"❌ Remote execution error: {e}")
+            raise RuntimeError(f"Remote agent execution failed: {str(e)}") from e
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        await self._client.aclose()
+        logger.info("🔌 Remote agent client closed")

mcp_use/client.py

@@ -9,7 +9,7 @@ import json
 import warnings
 from typing import Any
 
-from mcp.client.session import ElicitationFnT, SamplingFnT
+from mcp.client.session import ElicitationFnT, LoggingFnT, MessageHandlerFnT, SamplingFnT
 
 from mcp_use.types.sandbox import SandboxOptions
 
@@ -28,10 +28,13 @@ class MCPClient:
     def __init__(
         self,
         config: str | dict[str, Any] | None = None,
+        allowed_servers: list[str] | None = None,
         sandbox: bool = False,
         sandbox_options: SandboxOptions | None = None,
         sampling_callback: SamplingFnT | None = None,
         elicitation_callback: ElicitationFnT | None = None,
+        message_handler: MessageHandlerFnT | None = None,
+        logging_callback: LoggingFnT | None = None,
     ) -> None:
         """Initialize a new MCP client.
 
@@ -43,12 +46,15 @@ class MCPClient:
             sampling_callback: Optional sampling callback function.
         """
         self.config: dict[str, Any] = {}
+        self.allowed_servers: list[str] = allowed_servers
         self.sandbox = sandbox
         self.sandbox_options = sandbox_options
         self.sessions: dict[str, MCPSession] = {}
         self.active_sessions: list[str] = []
         self.sampling_callback = sampling_callback
         self.elicitation_callback = elicitation_callback
+        self.message_handler = message_handler
+        self.logging_callback = logging_callback
         # Load configuration if provided
         if config is not None:
             if isinstance(config, str):
@@ -64,6 +70,8 @@ class MCPClient:
         sandbox_options: SandboxOptions | None = None,
         sampling_callback: SamplingFnT | None = None,
         elicitation_callback: ElicitationFnT | None = None,
+        message_handler: MessageHandlerFnT | None = None,
+        logging_callback: LoggingFnT | None = None,
     ) -> "MCPClient":
         """Create a MCPClient from a dictionary.
 
@@ -80,6 +88,8 @@ class MCPClient:
             sandbox_options=sandbox_options,
             sampling_callback=sampling_callback,
             elicitation_callback=elicitation_callback,
+            message_handler=message_handler,
+            logging_callback=logging_callback,
         )
 
     @classmethod
@@ -90,6 +100,8 @@ class MCPClient:
         sandbox_options: SandboxOptions | None = None,
         sampling_callback: SamplingFnT | None = None,
         elicitation_callback: ElicitationFnT | None = None,
+        message_handler: MessageHandlerFnT | None = None,
+        logging_callback: LoggingFnT | None = None,
     ) -> "MCPClient":
         """Create a MCPClient from a configuration file.
 
@@ -106,6 +118,8 @@ class MCPClient:
             sandbox_options=sandbox_options,
             sampling_callback=sampling_callback,
             elicitation_callback=elicitation_callback,
+            message_handler=message_handler,
+            logging_callback=logging_callback,
         )
 
     def add_server(
@@ -185,6 +199,8 @@ class MCPClient:
             sandbox_options=self.sandbox_options,
             sampling_callback=self.sampling_callback,
             elicitation_callback=self.elicitation_callback,
+            message_handler=self.message_handler,
+            logging_callback=self.logging_callback,
         )
 
         # Create the session
@@ -220,9 +236,10 @@ class MCPClient:
             warnings.warn("No MCP servers defined in config", UserWarning, stacklevel=2)
             return {}
 
-        # Create sessions for all servers
+        # Create sessions only for allowed servers if applicable else create for all servers
         for name in servers:
-            await self.create_session(name, auto_initialize)
+            if self.allowed_servers is None or name in self.allowed_servers:
+                await self.create_session(name, auto_initialize)
 
         return self.sessions
 

mcp_use/config.py

@@ -7,17 +7,11 @@ This module provides functionality to load MCP configuration from JSON files.
 import json
 from typing import Any
 
-from mcp.client.session import ElicitationFnT, SamplingFnT
+from mcp.client.session import ElicitationFnT, LoggingFnT, MessageHandlerFnT, SamplingFnT
 
 from mcp_use.types.sandbox import SandboxOptions
 
-from .connectors import (
-    BaseConnector,
-    HttpConnector,
-    SandboxConnector,
-    StdioConnector,
-    WebSocketConnector,
-)
+from .connectors import BaseConnector, HttpConnector, SandboxConnector, StdioConnector, WebSocketConnector
 from .connectors.utils import is_stdio_server
 
 
@@ -40,6 +34,8 @@ def create_connector_from_config(
     sandbox_options: SandboxOptions | None = None,
     sampling_callback: SamplingFnT | None = None,
     elicitation_callback: ElicitationFnT | None = None,
+    message_handler: MessageHandlerFnT | None = None,
+    logging_callback: LoggingFnT | None = None,
 ) -> BaseConnector:
     """Create a connector based on server configuration.
     This function can be called with just the server_config parameter:
@@ -61,6 +57,8 @@ def create_connector_from_config(
             env=server_config.get("env", None),
             sampling_callback=sampling_callback,
             elicitation_callback=elicitation_callback,
+            message_handler=message_handler,
+            logging_callback=logging_callback,
         )
 
     # Sandboxed connector
@@ -72,6 +70,8 @@ def create_connector_from_config(
             e2b_options=sandbox_options,
             sampling_callback=sampling_callback,
             elicitation_callback=elicitation_callback,
+            message_handler=message_handler,
+            logging_callback=logging_callback,
         )
 
     # HTTP connector
@@ -80,8 +80,12 @@ def create_connector_from_config(
             base_url=server_config["url"],
             headers=server_config.get("headers", None),
             auth_token=server_config.get("auth_token", None),
+            timeout=server_config.get("timeout", 5),
+            sse_read_timeout=server_config.get("sse_read_timeout", 60 * 5),
             sampling_callback=sampling_callback,
             elicitation_callback=elicitation_callback,
+            message_handler=message_handler,
+            logging_callback=logging_callback,
         )
 
     # WebSocket connector

mcp_use/connectors/base.py

@@ -5,14 +5,27 @@ This module provides the base connector interface that all MCP connectors
 must implement.
 """
 
+import warnings
 from abc import ABC, abstractmethod
 from datetime import timedelta
 from typing import Any
 
 from mcp import ClientSession, Implementation
-from mcp.client.session import ElicitationFnT, SamplingFnT
+from mcp.client.session import ElicitationFnT, LoggingFnT, MessageHandlerFnT, SamplingFnT
 from mcp.shared.exceptions import McpError
-from mcp.types import CallToolResult, GetPromptResult, Prompt, ReadResourceResult, Resource, Tool
+from mcp.types import (
+    CallToolResult,
+    GetPromptResult,
+    Prompt,
+    PromptListChangedNotification,
+    ReadResourceResult,
+    Resource,
+    ResourceListChangedNotification,
+    ServerCapabilities,
+    ServerNotification,
+    Tool,
+    ToolListChangedNotification,
+)
 from pydantic import AnyUrl
 
 import mcp_use
@@ -31,6 +44,8 @@ class BaseConnector(ABC):
         self,
         sampling_callback: SamplingFnT | None = None,
         elicitation_callback: ElicitationFnT | None = None,
+        message_handler: MessageHandlerFnT | None = None,
+        logging_callback: LoggingFnT | None = None,
     ):
         """Initialize base connector with common attributes."""
         self.client_session: ClientSession | None = None
@@ -43,6 +58,9 @@ class BaseConnector(ABC):
         self.auto_reconnect = True  # Whether to automatically reconnect on connection loss (not configurable for now)
         self.sampling_callback = sampling_callback
         self.elicitation_callback = elicitation_callback
+        self.message_handler = message_handler
+        self.logging_callback = logging_callback
+        self.capabilities: ServerCapabilities | None = None
 
     @property
     def client_info(self) -> Implementation:
@@ -53,6 +71,20 @@ class BaseConnector(ABC):
             url="https://github.com/mcp-use/mcp-use",
         )
 
+    async def _internal_message_handler(self, message: Any) -> None:
+        """Wrap the user-provided message handler."""
+        if isinstance(message, ServerNotification):
+            if isinstance(message.root, ToolListChangedNotification):
+                logger.debug("Received tool list changed notification")
+            elif isinstance(message.root, ResourceListChangedNotification):
+                logger.debug("Received resource list changed notification")
+            elif isinstance(message.root, PromptListChangedNotification):
+                logger.debug("Received prompt list changed notification")
+
+        # Call the user's handler
+        if self.message_handler:
+            await self.message_handler(message)
+
     @abstractmethod
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
@@ -125,37 +157,37 @@ class BaseConnector(ABC):
         result = await self.client_session.initialize()
         self._initialized = True  # Mark as initialized
 
-        server_capabilities = result.capabilities
+        self.capabilities = result.capabilities
 
-        if server_capabilities.tools:
+        if self.capabilities.tools:
             # Get available tools directly from client session
             try:
                 tools_result = await self.client_session.list_tools()
                 self._tools = tools_result.tools if tools_result else []
             except Exception as e:
-                logger.error(f"Error listing tools: {e}")
+                logger.error(f"Error listing tools for connector {self.public_identifier}: {e}")
                 self._tools = []
         else:
             self._tools = []
 
-        if server_capabilities.resources:
+        if self.capabilities.resources:
             # Get available resources directly from client session
             try:
                 resources_result = await self.client_session.list_resources()
                 self._resources = resources_result.resources if resources_result else []
             except Exception as e:
-                logger.error(f"Error listing resources: {e}")
+                logger.error(f"Error listing resources for connector {self.public_identifier}: {e}")
                 self._resources = []
         else:
             self._resources = []
 
-        if server_capabilities.prompts:
+        if self.capabilities.prompts:
             # Get available prompts directly from client session
             try:
                 prompts_result = await self.client_session.list_prompts()
                 self._prompts = prompts_result.prompts if prompts_result else []
             except Exception as e:
-                logger.error(f"Error listing prompts: {e}")
+                logger.error(f"Error listing prompts for connector {self.public_identifier}: {e}")
                 self._prompts = []
         else:
             self._prompts = []
@@ -170,21 +202,57 @@ class BaseConnector(ABC):
 
     @property
     def tools(self) -> list[Tool]:
-        """Get the list of available tools."""
+        """Get the list of available tools.
+
+        .. deprecated::
+            This property is deprecated because it may return stale data when the server
+            sends list change notifications. Use `await list_tools()` instead to ensure
+            you always get the latest data.
+        """
+        warnings.warn(
+            "The 'tools' property is deprecated and may return stale data. "
+            "Use 'await list_tools()' instead to ensure fresh data.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if self._tools is None:
             raise RuntimeError("MCP client is not initialized")
         return self._tools
 
     @property
     def resources(self) -> list[Resource]:
-        """Get the list of available resources."""
+        """Get the list of available resources.
+
+        .. deprecated::
+            This property is deprecated because it may return stale data when the server
+            sends list change notifications. Use `await list_resources()` instead to ensure
+            you always get the latest data.
+        """
+        warnings.warn(
+            "The 'resources' property is deprecated and may return stale data. "
+            "Use 'await list_resources()' instead to ensure fresh data.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if self._resources is None:
             raise RuntimeError("MCP client is not initialized")
         return self._resources
 
     @property
     def prompts(self) -> list[Prompt]:
-        """Get the list of available prompts."""
+        """Get the list of available prompts.
+
+        .. deprecated::
+            This property is deprecated because it may return stale data when the server
+            sends list change notifications. Use `await list_prompts()' instead to ensure
+            you always get the latest data.
+        """
+        warnings.warn(
+            "The 'prompts' property is deprecated and may return stale data. "
+            "Use 'await list_prompts()' instead to ensure fresh data.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if self._prompts is None:
             raise RuntimeError("MCP client is not initialized")
         return self._prompts
@@ -303,28 +371,39 @@ class BaseConnector(ABC):
     async def list_tools(self) -> list[Tool]:
         """List all available tools from the MCP implementation."""
 
+        if self.capabilities and not self.capabilities.tools:
+            logger.debug(f"Server {self.public_identifier} does not support tools")
+            return []
+
         # Ensure we're connected
         await self._ensure_connected()
 
         logger.debug("Listing tools")
         try:
             result = await self.client_session.list_tools()
+            self._tools = result.tools
             return result.tools
         except McpError as e:
-            logger.error(f"Error listing tools: {e}")
+            logger.error(f"Error listing tools for connector {self.public_identifier}: {e}")
             return []
 
     async def list_resources(self) -> list[Resource]:
         """List all available resources from the MCP implementation."""
+
+        if self.capabilities and not self.capabilities.resources:
+            logger.debug(f"Server {self.public_identifier} does not support resources")
+            return []
+
         # Ensure we're connected
         await self._ensure_connected()
 
         logger.debug("Listing resources")
         try:
             result = await self.client_session.list_resources()
+            self._resources = result.resources
             return result.resources
         except McpError as e:
-            logger.error(f"Error listing resources: {e}")
+            logger.warning(f"Error listing resources for connector {self.public_identifier}: {e}")
             return []
 
     async def read_resource(self, uri: AnyUrl) -> ReadResourceResult:
@@ -337,14 +416,20 @@ class BaseConnector(ABC):
 
     async def list_prompts(self) -> list[Prompt]:
         """List all available prompts from the MCP implementation."""
+
+        if self.capabilities and not self.capabilities.prompts:
+            logger.debug(f"Server {self.public_identifier} does not support prompts")
+            return []
+
         await self._ensure_connected()
 
         logger.debug("Listing prompts")
         try:
             result = await self.client_session.list_prompts()
+            self._prompts = result.prompts
             return result.prompts
         except McpError as e:
-            logger.error(f"Error listing prompts: {e}")
+            logger.error(f"Error listing prompts for connector {self.public_identifier}: {e}")
             return []
 
     async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> GetPromptResult: