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

mcp_use/agents/__init__.py

@@ -5,10 +5,10 @@ This module provides ready-to-use agent implementations
 that are pre-configured for using MCP tools.
 """
 
-from .base import BaseAgent
 from .mcpagent import MCPAgent
+from .remote import RemoteAgent
 
 __all__ = [
-    "BaseAgent",
     "MCPAgent",
+    "RemoteAgent",
 ]

mcp_use/agents/mcpagent.py

@@ -8,6 +8,7 @@ to provide a simple interface for using MCP tools with different LLMs.
 import logging
 import time
 from collections.abc import AsyncGenerator, AsyncIterator
+from typing import TypeVar
 
 from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain.agents.output_parsers.tools import ToolAgentAction
@@ -20,6 +21,7 @@ from langchain_core.exceptions import OutputParserException
 from langchain_core.runnables.schema import StreamEvent
 from langchain_core.tools import BaseTool
 from langchain_core.utils.input import get_color_mapping
+from pydantic import BaseModel
 
 from mcp_use.client import MCPClient
 from mcp_use.connectors.base import BaseConnector
@@ -31,9 +33,13 @@ from ..logging import logger
 from ..managers.server_manager import ServerManager
 from .prompts.system_prompt_builder import create_system_message
 from .prompts.templates import DEFAULT_SYSTEM_PROMPT_TEMPLATE, SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE
+from .remote import RemoteAgent
 
 set_debug(logger.level == logging.DEBUG)
 
+# Type variable for structured output
+T = TypeVar("T", bound=BaseModel)
+
 
 class MCPAgent:
     """Main class for using MCP tools with various LLM providers.
@@ -44,7 +50,7 @@ class MCPAgent:
 
     def __init__(
         self,
-        llm: BaseLanguageModel,
+        llm: BaseLanguageModel | None = None,
         client: MCPClient | None = None,
         connectors: list[BaseConnector] | None = None,
         max_steps: int = 5,
@@ -54,13 +60,17 @@ class MCPAgent:
         system_prompt_template: str | None = None,  # User can still override the template
         additional_instructions: str | None = None,
         disallowed_tools: list[str] | None = None,
+        tools_used_names: list[str] | None = None,
         use_server_manager: bool = False,
         verbose: bool = False,
+        agent_id: str | None = None,
+        api_key: str | None = None,
+        base_url: str = "https://cloud.mcp-use.com",
     ):
         """Initialize a new MCPAgent instance.
 
         Args:
-            llm: The LangChain LLM to use.
+            llm: The LangChain LLM to use. Not required if agent_id is provided for remote execution.
             client: The MCPClient to use. If provided, connector is ignored.
             connectors: A list of MCP connectors to use if client is not provided.
             max_steps: The maximum number of steps to take.
@@ -71,7 +81,23 @@ class MCPAgent:
             additional_instructions: Extra instructions to append to the system prompt.
             disallowed_tools: List of tool names that should not be available to the agent.
             use_server_manager: Whether to use server manager mode instead of exposing all tools.
+            agent_id: Remote agent ID for remote execution. If provided, creates a remote agent.
+            api_key: API key for remote execution. If None, checks MCP_USE_API_KEY env var.
+            base_url: Base URL for remote API calls.
         """
+        # Handle remote execution
+        if agent_id is not None:
+            self._remote_agent = RemoteAgent(agent_id=agent_id, api_key=api_key, base_url=base_url)
+            self._is_remote = True
+            return
+
+        self._is_remote = False
+        self._remote_agent = None
+
+        # Validate requirements for local execution
+        if llm is None:
+            raise ValueError("llm is required for local execution. For remote execution, provide agent_id instead.")
+
         self.llm = llm
         self.client = client
         self.connectors = connectors or []
@@ -81,6 +107,7 @@ class MCPAgent:
         self._initialized = False
         self._conversation_history: list[BaseMessage] = []
         self.disallowed_tools = disallowed_tools or []
+        self.tools_used_names = tools_used_names or []
         self.use_server_manager = use_server_manager
         self.verbose = verbose
         # System prompt configuration
@@ -307,8 +334,8 @@ class MCPAgent:
 
     async def _consume_and_return(
         self,
-        generator: AsyncGenerator[tuple[AgentAction, str], str],
-    ) -> str:
+        generator: AsyncGenerator[tuple[AgentAction, str] | str | T, None],
+    ) -> tuple[str | T, int]:
         """Consume the generator and return the final result.
 
         This method manually iterates through the generator to consume the steps.
@@ -319,20 +346,24 @@ class MCPAgent:
             generator: The async generator that yields steps and a final result.
 
         Returns:
-            The final result from the generator.
+            A tuple of (final_result, steps_taken). final_result can be a string
+            for regular output or a Pydantic model instance for structured output.
         """
         final_result = ""
         steps_taken = 0
-        tools_used_names = []
         async for item in generator:
-            # If it's a string, it's the final result
+            # If it's a string, it's the final result (regular output)
             if isinstance(item, str):
                 final_result = item
                 break
+            # If it's not a tuple, it might be structured output (Pydantic model)
+            elif not isinstance(item, tuple):
+                final_result = item
+                break
             # Otherwise it's a step tuple, just consume it
-            steps_taken += 1
-            tools_used_names.append(item[0].tool)
-        return final_result, steps_taken, tools_used_names
+            else:
+                steps_taken += 1
+        return final_result, steps_taken
 
     async def stream(
         self,
@@ -341,7 +372,8 @@ class MCPAgent:
         manage_connector: bool = True,
         external_history: list[BaseMessage] | None = None,
         track_execution: bool = True,
-    ) -> AsyncGenerator[tuple[AgentAction, str] | str, None]:
+        output_schema: type[T] | None = None,
+    ) -> AsyncGenerator[tuple[AgentAction, str] | str | T, None]:
         """Run the agent and yield intermediate steps as an async generator.
 
         Args:
@@ -350,17 +382,48 @@ class MCPAgent:
             manage_connector: Whether to handle the connector lifecycle internally.
             external_history: Optional external history to use instead of the
                 internal conversation history.
+            track_execution: Whether to track execution for telemetry.
+            output_schema: Optional Pydantic BaseModel class for structured output.
+                If provided, the agent will attempt structured output at finish points
+                and continue execution if required information is missing.
 
         Yields:
-            Intermediate steps as (AgentAction, str) tuples, followed by the final result as a string.
+            Intermediate steps as (AgentAction, str) tuples, followed by the final result.
+            If output_schema is provided, yields structured output as instance of the schema.
         """
+        # Delegate to remote agent if in remote mode
+        if self._is_remote and self._remote_agent:
+            async for item in self._remote_agent.stream(
+                query, max_steps, manage_connector, external_history, track_execution, output_schema
+            ):
+                yield item
+            return
+
         result = ""
         initialized_here = False
         start_time = time.time()
-        tools_used_names = []
         steps_taken = 0
         success = False
 
+        # Schema-aware setup for structured output
+        structured_llm = None
+        schema_description = ""
+        if output_schema:
+            query = self._enhance_query_with_schema(query, output_schema)
+            structured_llm = self.llm.with_structured_output(output_schema)
+            # Get schema description for feedback
+            schema_fields = []
+            try:
+                for field_name, field_info in output_schema.model_fields.items():
+                    description = getattr(field_info, "description", "") or field_name
+                    required = not hasattr(field_info, "default") or field_info.default is None
+                    schema_fields.append(f"- {field_name}: {description} {'(required)' if required else '(optional)'}")
+
+                schema_description = "\n".join(schema_fields)
+            except Exception as e:
+                logger.warning(f"Could not extract schema details: {e}")
+                schema_description = f"Schema: {output_schema.__name__}"
+
         try:
             # Initialize if needed
             if manage_connector and not self._initialized:
@@ -449,7 +512,49 @@ class MCPAgent:
                     if isinstance(next_step_output, AgentFinish):
                         logger.info(f"✅ Agent finished at step {step_num + 1}")
                         result = next_step_output.return_values.get("output", "No output generated")
-                        break
+
+                        # If structured output is requested, attempt to create it
+                        if output_schema and structured_llm:
+                            try:
+                                logger.info("🔧 Attempting structured output...")
+                                structured_result = await self._attempt_structured_output(
+                                    result, structured_llm, output_schema, schema_description
+                                )
+
+                                # Add the final response to conversation history if memory is enabled
+                                if self.memory_enabled:
+                                    self.add_to_history(AIMessage(content=f"Structured result: {structured_result}"))
+
+                                logger.info("✅ Structured output successful")
+                                success = True
+                                yield structured_result
+                                return
+
+                            except Exception as e:
+                                logger.warning(f"⚠️ Structured output failed: {e}")
+                                # Continue execution to gather missing information
+                                missing_info_prompt = f"""
+                                The current result cannot be formatted into the required structure.
+                                Error: {str(e)}
+
+                                Current information: {result}
+
+                                Please continue working to gather the missing information needed for:
+                                {schema_description}
+
+                                Focus on finding the specific missing details.
+                                """
+
+                                # Add this as feedback and continue the loop
+                                inputs["input"] = missing_info_prompt
+                                if self.memory_enabled:
+                                    self.add_to_history(HumanMessage(content=missing_info_prompt))
+
+                                logger.info("🔄 Continuing execution to gather missing information...")
+                                continue
+                        else:
+                            # Regular execution without structured output
+                            break
 
                     # If it's actions/steps, add to intermediate steps and yield them
                     intermediate_steps.extend(next_step_output)
@@ -459,7 +564,7 @@ class MCPAgent:
                         yield agent_step
                         action, observation = agent_step
                         tool_name = action.tool
-                        tools_used_names.append(tool_name)
+                        self.tools_used_names.append(tool_name)
                         tool_input_str = str(action.tool_input)
                         # Truncate long inputs for readability
                         if len(tool_input_str) > 100:
@@ -498,15 +603,37 @@ class MCPAgent:
                 logger.warning(f"⚠️ Agent stopped after reaching max iterations ({steps})")
                 result = f"Agent stopped after reaching the maximum number of steps ({steps})."
 
-            # Add the final response to conversation history if memory is enabled
-            if self.memory_enabled:
+            # If structured output was requested but not achieved, attempt one final time
+            if output_schema and structured_llm and not success:
+                try:
+                    logger.info("🔧 Final attempt at structured output...")
+                    structured_result = await self._attempt_structured_output(
+                        result, structured_llm, output_schema, schema_description
+                    )
+
+                    # Add the final response to conversation history if memory is enabled
+                    if self.memory_enabled:
+                        self.add_to_history(AIMessage(content=f"Structured result: {structured_result}"))
+
+                    logger.info("✅ Final structured output successful")
+                    success = True
+                    yield structured_result
+                    return
+
+                except Exception as e:
+                    logger.error(f"❌ Final structured output attempt failed: {e}")
+                    raise RuntimeError(f"Failed to generate structured output after {steps} steps: {str(e)}") from e
+
+            if self.memory_enabled and not output_schema:
                 self.add_to_history(AIMessage(content=result))
 
             logger.info(f"🎉 Agent execution complete in {time.time() - start_time} seconds")
-            success = True
+            if not success:
+                success = True
 
-            # Yield the final result as a string
-            yield result
+            # Yield the final result (only for non-structured output)
+            if not output_schema:
+                yield result
 
         except Exception as e:
             logger.error(f"❌ Error running query: {e}")
@@ -548,8 +675,8 @@ class MCPAgent:
                     manage_connector=manage_connector,
                     external_history_used=external_history is not None,
                     steps_taken=steps_taken,
-                    tools_used_count=len(tools_used_names),
-                    tools_used_names=tools_used_names,
+                    tools_used_count=len(self.tools_used_names),
+                    tools_used_names=self.tools_used_names,
                     response=result,
                     execution_time_ms=execution_time_ms,
                     error_type=None if success else "execution_error",
@@ -567,11 +694,13 @@ class MCPAgent:
         max_steps: int | None = None,
         manage_connector: bool = True,
         external_history: list[BaseMessage] | None = None,
-    ) -> str:
+        output_schema: type[T] | None = None,
+    ) -> str | T:
         """Run a query using the MCP tools and return the final result.
 
         This method uses the streaming implementation internally and returns
-        the final result after consuming all intermediate steps.
+        the final result after consuming all intermediate steps. If output_schema
+        is provided, the agent will be schema-aware and return structured output.
 
         Args:
             query: The query to run.
@@ -582,19 +711,47 @@ class MCPAgent:
                 for managing the connector lifecycle.
             external_history: Optional external history to use instead of the
                 internal conversation history.
+            output_schema: Optional Pydantic BaseModel class for structured output.
+                If provided, the agent will attempt to return an instance of this model.
 
         Returns:
-            The result of running the query.
+            The result of running the query as a string, or if output_schema is provided,
+            an instance of the specified Pydantic model.
+
+        Example:
+            ```python
+            # Regular usage
+            result = await agent.run("What's the weather like?")
+
+            # Structured output usage
+            from pydantic import BaseModel, Field
+
+            class WeatherInfo(BaseModel):
+                temperature: float = Field(description="Temperature in Celsius")
+                condition: str = Field(description="Weather condition")
+
+            weather: WeatherInfo = await agent.run(
+                "What's the weather like?",
+                output_schema=WeatherInfo
+            )
+            ```
         """
+        # Delegate to remote agent if in remote mode
+        if self._is_remote and self._remote_agent:
+            return await self._remote_agent.run(query, max_steps, manage_connector, external_history, output_schema)
+
         success = True
         start_time = time.time()
-        generator = self.stream(query, max_steps, manage_connector, external_history, track_execution=False)
+
+        generator = self.stream(
+            query, max_steps, manage_connector, external_history, track_execution=False, output_schema=output_schema
+        )
         error = None
         steps_taken = 0
-        tools_used_names = []
         result = None
         try:
-            result, steps_taken, tools_used_names = await self._consume_and_return(generator)
+            result, steps_taken = await self._consume_and_return(generator)
+
         except Exception as e:
             success = False
             error = str(e)
@@ -618,15 +775,79 @@ class MCPAgent:
                 manage_connector=manage_connector,
                 external_history_used=external_history is not None,
                 steps_taken=steps_taken,
-                tools_used_count=len(tools_used_names),
-                tools_used_names=tools_used_names,
-                response=result,
+                tools_used_count=len(self.tools_used_names),
+                tools_used_names=self.tools_used_names,
+                response=str(result),
                 execution_time_ms=int((time.time() - start_time) * 1000),
                 error_type=error,
                 conversation_history_length=len(self._conversation_history),
             )
         return result
 
+    async def _attempt_structured_output(
+        self, raw_result: str, structured_llm, output_schema: type[T], schema_description: str
+    ) -> T:
+        """Attempt to create structured output from raw result with validation."""
+        format_prompt = f"""
+        Please format the following information according to the specified schema.
+        Extract and structure the relevant information from the content below.
+
+        Required schema fields:
+        {schema_description}
+
+        Content to format:
+        {raw_result}
+
+        Please provide the information in the requested structured format.
+        If any required information is missing, you must indicate this clearly.
+        """
+
+        structured_result = await structured_llm.ainvoke(format_prompt)
+
+        try:
+            for field_name, field_info in output_schema.model_fields.items():
+                required = not hasattr(field_info, "default") or field_info.default is None
+                if required:
+                    value = getattr(structured_result, field_name, None)
+                    if value is None or (isinstance(value, str) and not value.strip()):
+                        raise ValueError(f"Required field '{field_name}' is missing or empty")
+                    if isinstance(value, list) and len(value) == 0:
+                        raise ValueError(f"Required field '{field_name}' is an empty list")
+        except Exception as e:
+            logger.debug(f"Validation details: {e}")
+            raise  # Re-raise to trigger retry logic
+
+        return structured_result
+
+    def _enhance_query_with_schema(self, query: str, output_schema: type[T]) -> str:
+        """Enhance the query with schema information to make the agent aware of required fields."""
+        schema_fields = []
+
+        try:
+            for field_name, field_info in output_schema.model_fields.items():
+                description = getattr(field_info, "description", "") or field_name
+                required = not hasattr(field_info, "default") or field_info.default is None
+                schema_fields.append(f"- {field_name}: {description} {'(required)' if required else '(optional)'}")
+
+            schema_description = "\n".join(schema_fields)
+        except Exception as e:
+            logger.warning(f"Could not extract schema details: {e}")
+            schema_description = f"Schema: {output_schema.__name__}"
+
+        # Enhance the query with schema awareness
+        enhanced_query = f"""
+        {query}
+
+        IMPORTANT: Your response must include sufficient information to populate the following structured output:
+
+        {schema_description}
+
+        Make sure you gather ALL the required information during your task execution.
+        If any required information is missing, continue working to find it.
+        """
+
+        return enhanced_query
+
     async def _generate_response_chunks_async(
         self,
         query: str,
@@ -749,6 +970,11 @@ class MCPAgent:
 
     async def close(self) -> None:
         """Close the MCP connection with improved error handling."""
+        # Delegate to remote agent if in remote mode
+        if self._is_remote and self._remote_agent:
+            await self._remote_agent.close()
+            return
+
         logger.info("🔌 Closing agent and cleaning up resources...")
         try:
             # Clean up the agent first

mcp_use/agents/prompts/templates.py

@@ -17,27 +17,25 @@ Thought: I now know the final answer
 Final Answer: the final answer to the original input question"""
 
 
-SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE = """You are a helpful assistant designed to interact with MCP
- (Model Context Protocol) servers. You can manage connections to different servers and use the tools
- provided by the currently active server.
-
-Important: The available tools change depending on which server is active.
-If a request requires tools not listed below (e.g., file operations, web browsing,
- image manipulation), you MUST first connect to the appropriate server using
- 'connect_to_mcp_server'.
-Use 'list_mcp_servers' to find the relevant server if you are unsure.
-Only after successfully connecting and seeing the new tools listed in
-the response should you attempt to use those server-specific tools.
-Before attempting a task that requires specific tools, you should
-ensure you are connected to the correct server and aware of its
-available tools. If unsure, use 'list_mcp_servers' to see options
-or 'get_active_mcp_server' to check the current connection.
-
-When you connect to a server using 'connect_to_mcp_server',
- you will be informed about the new tools that become available.
-You can then use these server-specific tools in subsequent steps.
-
-Here are the tools *currently* available to you (this list includes server management tools and will
- change when you connect to a server):
+SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE = """You are a helpful assistant designed
+to interact with MCP (Model Context Protocol) servers. You can manage connections
+ to different servers and use the tools provided by the currently active server.
+
+Important: The available tools change dynamically based on which server is active.
+
+- When you connect to a server using 'connect_to_mcp_server', that server's tools are automatically added to
+your available tools with their full schemas
+- When you disconnect using 'disconnect_from_mcp_server', the server's tools are removed from your available tools
+- The tool list below will automatically update when you connect/disconnect from servers
+
+If a request requires tools not currently listed below (e.g., file operations, web browsing, image manipulation),
+you MUST first connect to the appropriate server using 'connect_to_mcp_server'. Use 'list_mcp_servers' to find
+available servers if you are unsure which one to connect to.
+
+After connecting to a server, you can immediately use its tools - they will be directly available to you with their
+proper schemas and validation. No additional steps are needed.
+
+Here are the tools currently available to you (this list dynamically updates when
+connecting/disconnecting from servers):
 {tool_descriptions}
 """

mcp_use/agents/remote.py

@@ -0,0 +1,239 @@
+"""
+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)
+
+
+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
+
+        # 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 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")
+
+        payload = {"query": query, "max_steps": max_steps or 10}
+
+        # Add structured output schema if provided
+        if output_schema is not None:
+            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}
+
+        url = f"{self.base_url}/api/v1/agents/{self.agent_id}/run"
+
+        try:
+            logger.info(f"🌐 Executing query on remote agent {self.agent_id}")
+            response = await self._client.post(url, json=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

@@ -28,6 +28,7 @@ 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,
@@ -43,6 +44,7 @@ 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] = {}
@@ -220,9 +222,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

@@ -80,6 +80,8 @@ 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,
         )

mcp_use/managers/__init__.py

@@ -6,16 +6,14 @@ from .tools import (
     ListServersTool,
     MCPServerTool,
     SearchToolsTool,
-    UseToolFromServerTool,
 )
 
 __all__ = [
     "ServerManager",
-    "ListServersTool",
+    "MCPServerTool",
     "ConnectServerTool",
-    "GetActiveServerTool",
     "DisconnectServerTool",
+    "GetActiveServerTool",
+    "ListServersTool",
     "SearchToolsTool",
-    "MCPServerTool",
-    "UseToolFromServerTool",
 ]

mcp_use/managers/server_manager.py

@@ -10,7 +10,6 @@ from .tools import (
     GetActiveServerTool,
     ListServersTool,
     SearchToolsTool,
-    UseToolFromServerTool,
 )
 
 
@@ -73,12 +72,21 @@ class ServerManager:
             except Exception as e:
                 logger.error(f"Error prefetching tools for server '{server_name}': {e}")
 
-    @property
-    def tools(self) -> list[BaseTool]:
-        """Get all server management tools.
+    def get_active_server_tools(self) -> list[BaseTool]:
+        """Get tools from the currently active server.
+
+        Returns:
+            List of tools from the active server, or empty list if no server is active
+        """
+        if self.active_server and self.active_server in self._server_tools:
+            return self._server_tools[self.active_server]
+        return []
+
+    def get_management_tools(self) -> list[BaseTool]:
+        """Get the server management tools.
 
         Returns:
-            list of LangChain tools for server management
+            List of server management tools
         """
         return [
             ListServersTool(self),
@@ -86,5 +94,36 @@ class ServerManager:
             GetActiveServerTool(self),
             DisconnectServerTool(self),
             SearchToolsTool(self),
-            UseToolFromServerTool(self),
         ]
+
+    def has_tool_changes(self, current_tool_names: set[str]) -> bool:
+        """Check if the available tools have changed.
+
+        Args:
+            current_tool_names: Set of currently known tool names
+
+        Returns:
+            True if tools have changed, False otherwise
+        """
+        new_tool_names = {tool.name for tool in self.tools}
+        return new_tool_names != current_tool_names
+
+    @property
+    def tools(self) -> list[BaseTool]:
+        """Get all server management tools and tools from the active server.
+
+        Returns:
+            list of LangChain tools for server management plus tools from active server
+        """
+        management_tools = self.get_management_tools()
+
+        # Add tools from the active server if available
+        if self.active_server and self.active_server in self._server_tools:
+            server_tools = self._server_tools[self.active_server]
+            logger.debug(f"Including {len(server_tools)} tools from active server '{self.active_server}'")
+            logger.debug(f"Server tools: {[tool.name for tool in server_tools]}")
+            return management_tools + server_tools
+        else:
+            logger.debug("No active server - returning only management tools")
+
+        return management_tools

mcp_use/managers/tools/__init__.py

@@ -4,14 +4,12 @@ from .disconnect_server import DisconnectServerTool
 from .get_active_server import GetActiveServerTool
 from .list_servers_tool import ListServersTool
 from .search_tools import SearchToolsTool
-from .use_tool import UseToolFromServerTool
 
 __all__ = [
     "MCPServerTool",
-    "ListServersTool",
     "ConnectServerTool",
-    "GetActiveServerTool",
     "DisconnectServerTool",
+    "GetActiveServerTool",
+    "ListServersTool",
     "SearchToolsTool",
-    "UseToolFromServerTool",
 ]

{mcp_use-1.3.7.dist-info → mcp_use-1.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.3.7
+Version: 1.3.8
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -17,7 +17,7 @@ Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: jsonschema-pydantic>=0.1.0
 Requires-Dist: langchain>=0.1.0
-Requires-Dist: mcp>=1.9.3
+Requires-Dist: mcp>=1.10.0
 Requires-Dist: posthog>=4.8.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
@@ -84,10 +84,9 @@ Description-Content-Type: text/markdown
 
 💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.
 
-- Visit the [mcp-use.com website](https://mcp-use.com/) to know how to build and deploy MCP agents.
+- If you want to get started quickly check out [mcp-use.com website](https://mcp-use.com/) to build and deploy agents with your favorite MCP servers.
 - Visit the [mcp-use docs](https://docs.mcp-use.com/) to get started with mcp-use library
-
-💬 Get started quickly - chat with your servers on our <b>hosted version</b>! [Try mcp-use chat (beta)](https://chat.mcp-use.com).
+- For the TypeScript version, visit [mcp-use-ts](https://github.com/mcp-use/mcp-use-ts)
 
 | Supports  | |
 | :--- | :--- |
@@ -812,45 +811,45 @@ Thanks to all our amazing contributors!
     <th width="400">Repository</th>
     <th>Stars</th>
   </tr>
+  <tr>
+    <td><img src="https://avatars.githubusercontent.com/u/38653995?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/patchy631/ai-engineering-hub"><strong>patchy631/ai-engineering-hub</strong></a></td>
+    <td>⭐ 15189</td>
+  </tr>
   <tr>
     <td><img src="https://avatars.githubusercontent.com/u/170207473?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/tavily-ai/meeting-prep-agent"><strong>tavily-ai/meeting-prep-agent</strong></a></td>
-    <td>⭐ 112</td>
+    <td>⭐ 129</td>
+  </tr>
+  <tr>
+    <td><img src="https://avatars.githubusercontent.com/u/187057607?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/hud-evals/hud-sdk"><strong>hud-evals/hud-sdk</strong></a></td>
+    <td>⭐ 75</td>
   </tr>
   <tr>
     <td><img src="https://avatars.githubusercontent.com/u/20041231?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/krishnaik06/MCP-CRASH-Course"><strong>krishnaik06/MCP-CRASH-Course</strong></a></td>
-    <td>⭐ 37</td>
+    <td>⭐ 58</td>
+  </tr>
+  <tr>
+    <td><img src="https://avatars.githubusercontent.com/u/54944174?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/larksuite/lark-samples"><strong>larksuite/lark-samples</strong></a></td>
+    <td>⭐ 31</td>
   </tr>
   <tr>
     <td><img src="https://avatars.githubusercontent.com/u/892404?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/truemagic-coder/solana-agent-app"><strong>truemagic-coder/solana-agent-app</strong></a></td>
-    <td>⭐ 29</td>
+    <td>⭐ 30</td>
   </tr>
   <tr>
     <td><img src="https://avatars.githubusercontent.com/u/8344498?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/schogini/techietalksai"><strong>schogini/techietalksai</strong></a></td>
-    <td>⭐ 21</td>
+    <td>⭐ 24</td>
   </tr>
   <tr>
     <td><img src="https://avatars.githubusercontent.com/u/201161342?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/autometa-dev/whatsapp-mcp-voice-agent"><strong>autometa-dev/whatsapp-mcp-voice-agent</strong></a></td>
-    <td>⭐ 18</td>
+    <td>⭐ 22</td>
   </tr>
   <tr>
     <td><img src="https://avatars.githubusercontent.com/u/100749943?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/Deniscartin/mcp-cli"><strong>Deniscartin/mcp-cli</strong></a></td>
-    <td>⭐ 17</td>
-  </tr>
-  <tr>
-    <td><img src="https://avatars.githubusercontent.com/u/6764390?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/elastic/genai-workshops"><strong>elastic/genai-workshops</strong></a></td>
-    <td>⭐ 9</td>
+    <td>⭐ 18</td>
   </tr>
   <tr>
     <td><img src="https://avatars.githubusercontent.com/u/6688805?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/innovaccer/Healthcare-MCP"><strong>innovaccer/Healthcare-MCP</strong></a></td>
-    <td>⭐ 6</td>
-  </tr>
-  <tr>
-    <td><img src="https://avatars.githubusercontent.com/u/205593730?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/Qingyon-AI/Revornix"><strong>Qingyon-AI/Revornix</strong></a></td>
-    <td>⭐ 5</td>
-  </tr>
-  <tr>
-    <td><img src="https://avatars.githubusercontent.com/u/68845761?s=40&v=4" width="20" height="20" style="vertical-align: middle; margin-right: 8px;"> <a href="https://github.com/entbappy/MCP-Tutorials"><strong>entbappy/MCP-Tutorials</strong></a></td>
-    <td>⭐ 5</td>
+    <td>⭐ 15</td>
   </tr>
 </table>
 

{mcp_use-1.3.7.dist-info → mcp_use-1.3.8.dist-info}/RECORD

@@ -1,17 +1,18 @@
 mcp_use/__init__.py,sha256=I3gFxw6Id45RksUBIZS1kxBW3ItjFXuAfoReJabpnW0,1055
-mcp_use/client.py,sha256=ka9gE_GQj9a1fcWfz-hrAzYwSN5I1Y1JXo2Tq0uRCOU,10718
-mcp_use/config.py,sha256=zLw8F9bBi4hMmKmjxMIS47GIlHWmP4r35A-_K5c7Kqk,2974
+mcp_use/client.py,sha256=dziKHIZIclLk64ycF4keegiVp93YKqSyGok7Rv4j8bE,10958
+mcp_use/config.py,sha256=J3ebF9dlQxui3pSONTFtVYO035E7d0CP4HAvN0INgE4,3103
 mcp_use/logging.py,sha256=CRtkPwR-bkXK_kQ0QOL86RikMWOHzEOi7A8VRHkNsZw,4270
 mcp_use/session.py,sha256=4kwcB_IkTt_3FiBSTI1H17KhL1W_6N5oai3HTxFrTH4,2496
 mcp_use/utils.py,sha256=QavJcVq2WxUUUCCpPCUeOB5bqIS0FFmpK-RAZkGc6aA,720
 mcp_use/adapters/__init__.py,sha256=-xCrgPThuX7x0PHGFDdjb7M-mgw6QV3sKu5PM7ShnRg,275
 mcp_use/adapters/base.py,sha256=U1z_UzojC-bytb4ZuKTRpEgEp-2F_BVBgqEXbUqLYB4,6901
 mcp_use/adapters/langchain_adapter.py,sha256=LdlpRyLORhl8NZvtAmisgPelXkhEbBErSNdGHb8SF18,10860
-mcp_use/agents/__init__.py,sha256=N3eVYP2PxqNO2KcQv5fY8UMUX2W3eLTNkkzuFIJ1DUA,261
+mcp_use/agents/__init__.py,sha256=FzkntihbAqzixWdWe99zIrrcIfd4N3YWltNniutG9VA,267
 mcp_use/agents/base.py,sha256=EN-dRbwOi9vIqofFg3jmi5yT2VKlwEr9Cwi1DZgB3eE,1591
-mcp_use/agents/mcpagent.py,sha256=K3gKlPvqIPiniifi46Xs82_D2YKNO-Vn4BTTH55LPbI,35753
+mcp_use/agents/mcpagent.py,sha256=Vh4VOxxh-6sJwK1tTtJgUWZcp1bd3hb_JnATc7x9sKk,46698
+mcp_use/agents/remote.py,sha256=_8TKP-hfr8NsexbpaEz8bK4LU-opILJMnTL7TbQBiY4,10575
 mcp_use/agents/prompts/system_prompt_builder.py,sha256=E86STmxcl2Ic763_114awNqFB2RyLrQlbvgRmJajQjI,4116
-mcp_use/agents/prompts/templates.py,sha256=AZKrGWuI516C-PmyOPvxDBibNdqJtN24sOHTGR06bi4,1933
+mcp_use/agents/prompts/templates.py,sha256=acg2Q-_uQDL-3q5ZUwwwFrP7wqqf-SEyq0XWDDHt69s,1906
 mcp_use/connectors/__init__.py,sha256=cUF4yT0bNr8qeLkSzg28SHueiV5qDaHEB1l1GZ2K0dc,536
 mcp_use/connectors/base.py,sha256=bCPOrSb3xzuxQRFpcLf7tCG1UmMFtr9IVM7br8JlbzI,13878
 mcp_use/connectors/http.py,sha256=8LVzXtVtdLVQH9xMIqPzKfPEmaO_cxzMIu4g4oGIung,7912
@@ -19,16 +20,15 @@ mcp_use/connectors/sandbox.py,sha256=RX8xssn0cIObW6CjOqY7ZrO_D9lTzCZKdRcJ5lQSmQg
 mcp_use/connectors/stdio.py,sha256=jTNhrsHxkRgSI9uAnj4bbFsBwe6zooc-oNcMXV_s9Xk,3378
 mcp_use/connectors/utils.py,sha256=zQ8GdNQx0Twz3by90BoU1RsWPf9wODGof4K3-NxPXeA,366
 mcp_use/connectors/websocket.py,sha256=G7ZeLJNPVl9AG6kCmiNJz1N2Ing_QxT7pSswigTKi8Y,9650
-mcp_use/managers/__init__.py,sha256=rzsJbOhtlmxNQLGcdmtmHaiExEXmiQiUuzPrAgKhAJw,439
-mcp_use/managers/server_manager.py,sha256=Ag1EUSxkG6-UG004vcvaZarPoDnUUMMX7BUeKReUWRI,3704
-mcp_use/managers/tools/__init__.py,sha256=JrA5iTRdtbgwROJE8pQ7GH1sYnqBRcgj4NzFVADKbQ4,510
+mcp_use/managers/__init__.py,sha256=FRTuJw5kYtY1Eo7wN9Aeqeqo1euiR5slvrx5Fl_SGvk,383
+mcp_use/managers/server_manager.py,sha256=8F6jEwZOoAfR1y1O7zk-BSZ1LVYcLZTSQZLRClhSE2I,5278
+mcp_use/managers/tools/__init__.py,sha256=zcpm4HXsp8NUMRJeyT6DdB8cgIMDs46pBfoTD-odhGU,437
 mcp_use/managers/tools/base_tool.py,sha256=Jbbp7SwmHKDk8jT_6yVIv7iNsn6KaV_PljWuhhLcbXg,509
 mcp_use/managers/tools/connect_server.py,sha256=MGYQCl11q-w6gSIYuT44dDk7ILV3Oh7kGAJ4fsNXbso,2923
 mcp_use/managers/tools/disconnect_server.py,sha256=Y3kJN31efzsjfJwxUhpBxS-bgU21DCfGbn_LgEbzyvI,1586
 mcp_use/managers/tools/get_active_server.py,sha256=tCaib76gYU3L5G82tEOTq4Io2cuCXWjOjPselb-92i8,964
 mcp_use/managers/tools/list_servers_tool.py,sha256=OPDSMNe-VuAhlUyhDnR4CiuZFpoMhnhWpAablwO5S0k,1897
 mcp_use/managers/tools/search_tools.py,sha256=4vso7ln-AfG6lQAMq9FA_CyeVtSEDYEWlHtdHtfnLps,12911
-mcp_use/managers/tools/use_tool.py,sha256=gMNjgJrI9XDitPyJglcJcAvowbEWkO5z57yt4DT2Lpc,6626
 mcp_use/observability/__init__.py,sha256=kTUcP0d6L5_3ktfldhdAk-3AWckzVHs7ztG-R6cye64,186
 mcp_use/observability/laminar.py,sha256=WWjmVXP55yCfAlqlayeuJmym1gdrv8is7UyrIp4Tbn0,839
 mcp_use/observability/langfuse.py,sha256=9vgJgnGtVpv_CbCyJqyRkzq2ELqPfYFIUGnpSbm2RCo,1334
@@ -43,7 +43,7 @@ mcp_use/telemetry/events.py,sha256=K5xqbmkum30r4gM2PWtTiUWGF8oZzGZw2DYwco1RfOQ,3
 mcp_use/telemetry/telemetry.py,sha256=ck2MDFMtooafriR1W_zi41dWq-0O-ucF89pCkdkyc9E,11724
 mcp_use/telemetry/utils.py,sha256=kDVTqt2oSeWNJbnTOlXOehr2yFO0PMyx2UGkrWkfJiw,1769
 mcp_use/types/sandbox.py,sha256=opJ9r56F1FvaqVvPovfAj5jZbsOexgwYx5wLgSlN8_U,712
-mcp_use-1.3.7.dist-info/METADATA,sha256=ZElQuSVQ92ph2WHTWsEPPPIFGpwHjMHa4MZ6gDNp-KY,30337
-mcp_use-1.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_use-1.3.7.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-1.3.7.dist-info/RECORD,,
+mcp_use-1.3.8.dist-info/METADATA,sha256=nqKWqFTWM-XqfsPrXXyn5Q6opaMyWz_oe3qfSZEfM3M,30356
+mcp_use-1.3.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.3.8.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.3.8.dist-info/RECORD,,

mcp_use/managers/tools/use_tool.py

@@ -1,154 +0,0 @@
-import json
-from typing import Any, ClassVar
-
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field
-
-from mcp_use.logging import logger
-
-from .base_tool import MCPServerTool
-
-
-class UseToolInput(BaseModel):
-    """Input for using a tool from a specific server"""
-
-    server_name: str = Field(description="The name of the MCP server containing the tool")
-    tool_name: str = Field(description="The name of the tool to execute")
-    tool_input: dict[str, Any] | str = Field(
-        description="The input to pass to the tool. Can be a dictionary of parameters or a string"
-    )
-
-
-class UseToolFromServerTool(MCPServerTool):
-    """Tool for directly executing a tool from a specific server."""
-
-    name: ClassVar[str] = "use_tool_from_server"
-    description: ClassVar[str] = (
-        "Execute a specific tool on a specific server without first connecting to it. "
-        "This is a direct execution shortcut that combines connection and tool execution "
-        "into a single step. Specify the server name, tool name, and the input to the tool."
-    )
-    args_schema: ClassVar[type[BaseModel]] = UseToolInput
-
-    async def _arun(self, server_name: str, tool_name: str, tool_input: dict[str, Any] | str) -> str:
-        """Execute a tool from a specific server."""
-        # Check if server exists
-        servers = self.server_manager.client.get_server_names()
-        if server_name not in servers:
-            available = ", ".join(servers) if servers else "none"
-            return f"Server '{server_name}' not found. Available servers: {available}"
-
-        # Connect to the server if not already connected or not the active server
-        is_connected = server_name == self.server_manager.active_server
-
-        if not is_connected:
-            try:
-                # Create or get session for this server
-                try:
-                    session = self.server_manager.client.get_session(server_name)
-                    logger.debug(f"Using existing session for server '{server_name}'")
-                except ValueError:
-                    logger.debug(f"Creating new session for server '{server_name}' for tool use")
-                    session = await self.server_manager.client.create_session(server_name)
-
-                # Check if we have tools for this server, if not get them
-                if server_name not in self.server_manager._server_tools:
-                    connector = session.connector
-                    self.server_manager._server_tools[
-                        server_name
-                    ] = await self.server_manager.adapter._create_tools_from_connectors([connector])
-                    self.server_manager.initialized_servers[server_name] = True
-            except Exception as e:
-                logger.error(f"Error connecting to server '{server_name}' for tool use: {e}")
-                return f"Failed to connect to server '{server_name}': {str(e)}"
-
-        # Get tools for the server
-        server_tools = self.server_manager._server_tools.get(server_name, [])
-        if not server_tools:
-            return f"No tools found for server '{server_name}'"
-
-        # Find the requested tool
-        target_tool = None
-        for tool in server_tools:
-            if tool.name == tool_name:
-                target_tool = tool
-                break
-
-        if not target_tool:
-            tool_names = [t.name for t in server_tools]
-            return f"Tool '{tool_name}' not found on server '{server_name}'. Available tools: {', '.join(tool_names)}"
-
-        # Execute the tool with the provided input
-        try:
-            # Parse the input based on target tool's schema
-            structured_input = self._parse_tool_input(target_tool, tool_input)
-            if structured_input is None:
-                return f"Could not parse input for tool '{tool_name}'. Please check the input format and try again."
-
-            # Store the previous active server
-            previous_active = self.server_manager.active_server
-
-            # Temporarily set this server as active
-            self.server_manager.active_server = server_name
-
-            # Execute the tool
-            logger.info(f"Executing tool '{tool_name}' on server '{server_name}'with input: {{structured_input}}")
-            result = await target_tool._arun(**structured_input)
-
-            # Restore the previous active server
-            self.server_manager.active_server = previous_active
-
-            return result
-
-        except Exception as e:
-            logger.error(f"Error executing tool '{tool_name}' on server '{server_name}': {e}")
-            return (
-                f"Error executing tool '{tool_name}' on server '{server_name}': {str(e)}. "
-                f"Make sure the input format is correct for this tool."
-            )
-
-    def _parse_tool_input(self, tool: BaseTool, input_data: dict[str, Any] | str) -> dict[str, Any]:
-        """
-        Parse the input data according to the tool's schema.
-
-        Args:
-            tool: The target tool
-            input_data: The input data, either a dictionary or a string
-
-        Returns:
-            A dictionary with properly structured input for the tool
-        """
-        # If input is already a dict, use it directly
-        if isinstance(input_data, dict):
-            return input_data
-
-        # Try to parse as JSON first
-        if isinstance(input_data, str):
-            try:
-                return json.loads(input_data)
-            except json.JSONDecodeError:
-                pass
-
-            # For string input, we need to determine which parameter name to use
-            if hasattr(tool, "args_schema") and tool.args_schema:
-                schema_cls = tool.args_schema
-                field_names = list(schema_cls.__fields__.keys())
-
-                # If schema has only one field, use that
-                if len(field_names) == 1:
-                    return {field_names[0]: input_data}
-
-                # Look for common input field names
-                for name in field_names:
-                    if name.lower() in ["input", "query", "url", tool.name.lower()]:
-                        return {name: input_data}
-
-                # Default to first field if we can't determine
-                return {field_names[0]: input_data}
-
-        # If we get here something went wrong
-        return None
-
-    def _run(self, server_name: str, tool_name: str, tool_input: dict[str, Any] | str) -> str:
-        """Synchronous version that raises a NotImplementedError."""
-        raise NotImplementedError("UseToolFromServerTool requires async execution. Use _arun instead.")