mcp-use 1.3.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

mcp_use/agents/mcpagent.py

@@ -6,6 +6,7 @@ to provide a simple interface for using MCP tools with different LLMs.
 """
 
 import logging
+import time
 from collections.abc import AsyncIterator
 
 from langchain.agents import AgentExecutor, create_tool_calling_agent
@@ -22,6 +23,8 @@ from langchain_core.utils.input import get_color_mapping
 
 from mcp_use.client import MCPClient
 from mcp_use.connectors.base import BaseConnector
+from mcp_use.telemetry.posthog import Telemetry
+from mcp_use.telemetry.utils import extract_model_info
 
 from ..adapters.langchain_adapter import LangChainAdapter
 from ..logging import logger
@@ -93,6 +96,9 @@ class MCPAgent:
         # Create the adapter for tool conversion
         self.adapter = LangChainAdapter(disallowed_tools=self.disallowed_tools)
 
+        # Initialize telemetry
+        self.telemetry = Telemetry()
+
         # Initialize server manager if requested
         self.server_manager = None
         if self.use_server_manager:
@@ -104,6 +110,9 @@ class MCPAgent:
         self._agent_executor: AgentExecutor | None = None
         self._system_message: SystemMessage | None = None
 
+        # Track model info for telemetry
+        self._model_provider, self._model_name = extract_model_info(self.llm)
+
     async def initialize(self) -> None:
         """Initialize the MCP client and agent."""
         logger.info("🚀 Initializing MCP agent and connecting to services...")
@@ -130,6 +139,7 @@ class MCPAgent:
                 if not self._sessions:
                     logger.info("🔄 No active sessions found, creating new ones...")
                     self._sessions = await self.client.create_all_sessions()
+                    self.connectors = [session.connector for session in self._sessions.values()]
                     logger.info(f"✅ Created {len(self._sessions)} new sessions")
 
                 # Create LangChain tools directly from the client using the adapter
@@ -141,7 +151,7 @@ class MCPAgent:
                 connectors_to_use = self.connectors
                 logger.info(f"🔗 Connecting to {len(connectors_to_use)} direct connectors...")
                 for connector in connectors_to_use:
-                    if not hasattr(connector, "client") or connector.client is None:
+                    if not hasattr(connector, "client_session") or connector.client_session is None:
                         await connector.connect()
 
                 # Create LangChain tools using the adapter with connectors
@@ -374,13 +384,58 @@ class MCPAgent:
             async for chunk in agent.astream("hello"):
                 print(chunk, end="|", flush=True)
         """
-        async for chunk in self._generate_response_chunks_async(
-            query=query,
-            max_steps=max_steps,
-            manage_connector=manage_connector,
-            external_history=external_history,
-        ):
-            yield chunk
+        start_time = time.time()
+        success = False
+        chunk_count = 0
+        total_response_length = 0
+
+        try:
+            async for chunk in self._generate_response_chunks_async(
+                query=query,
+                max_steps=max_steps,
+                manage_connector=manage_connector,
+                external_history=external_history,
+            ):
+                chunk_count += 1
+                if isinstance(chunk, str):
+                    total_response_length += len(chunk)
+                yield chunk
+            success = True
+        finally:
+            # Track comprehensive execution data for streaming
+            execution_time_ms = int((time.time() - start_time) * 1000)
+
+            server_count = 0
+            if self.client:
+                server_count = len(self.client.get_all_active_sessions())
+            elif self.connectors:
+                server_count = len(self.connectors)
+
+            conversation_history_length = (
+                len(self._conversation_history) if self.memory_enabled else 0
+            )
+
+            self.telemetry.track_agent_execution(
+                execution_method="astream",
+                query=query,
+                success=success,
+                model_provider=self._model_provider,
+                model_name=self._model_name,
+                server_count=server_count,
+                server_identifiers=[connector.public_identifier for connector in self.connectors],
+                total_tools_available=len(self._tools) if self._tools else 0,
+                tools_available_names=[tool.name for tool in self._tools],
+                max_steps_configured=self.max_steps,
+                memory_enabled=self.memory_enabled,
+                use_server_manager=self.use_server_manager,
+                max_steps_used=max_steps,
+                manage_connector=manage_connector,
+                external_history_used=external_history is not None,
+                response=f"[STREAMED RESPONSE - {total_response_length} chars]",
+                execution_time_ms=execution_time_ms,
+                error_type=None if success else "streaming_error",
+                conversation_history_length=conversation_history_length,
+            )
 
     async def run(
         self,
@@ -409,6 +464,10 @@ class MCPAgent:
         """
         result = ""
         initialized_here = False
+        start_time = time.time()
+        tools_used_names = []
+        steps_taken = 0
+        success = False
 
         try:
             # Initialize if needed
@@ -464,6 +523,7 @@ class MCPAgent:
             logger.info(f"🏁 Starting agent execution with max_steps={steps}")
 
             for step_num in range(steps):
+                steps_taken = step_num + 1
                 # --- Check for tool updates if using server manager ---
                 if self.use_server_manager and self.server_manager:
                     current_tools = self.server_manager.tools
@@ -510,9 +570,10 @@ class MCPAgent:
                     # If it's actions/steps, add to intermediate steps
                     intermediate_steps.extend(next_step_output)
 
-                    # Log tool calls
+                    # Log tool calls and track tool usage
                     for action, output in next_step_output:
                         tool_name = action.tool
+                        tools_used_names.append(tool_name)
                         tool_input_str = str(action.tool_input)
                         # Truncate long inputs for readability
                         if len(tool_input_str) > 100:
@@ -555,7 +616,8 @@ class MCPAgent:
             if self.memory_enabled:
                 self.add_to_history(AIMessage(content=result))
 
-            logger.info("🎉 Agent execution complete")
+            logger.info(f"🎉 Agent execution complete in {time.time() - start_time} seconds")
+            success = True
             return result
 
         except Exception as e:
@@ -566,6 +628,43 @@ class MCPAgent:
             raise
 
         finally:
+            # Track comprehensive execution data
+            execution_time_ms = int((time.time() - start_time) * 1000)
+
+            server_count = 0
+            if self.client:
+                server_count = len(self.client.get_all_active_sessions())
+            elif self.connectors:
+                server_count = len(self.connectors)
+
+            conversation_history_length = (
+                len(self._conversation_history) if self.memory_enabled else 0
+            )
+            self.telemetry.track_agent_execution(
+                execution_method="run",
+                query=query,
+                success=success,
+                model_provider=self._model_provider,
+                model_name=self._model_name,
+                server_count=server_count,
+                server_identifiers=[connector.public_identifier for connector in self.connectors],
+                total_tools_available=len(self._tools) if self._tools else 0,
+                tools_available_names=[tool.name for tool in self._tools],
+                max_steps_configured=self.max_steps,
+                memory_enabled=self.memory_enabled,
+                use_server_manager=self.use_server_manager,
+                max_steps_used=max_steps,
+                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,
+                execution_time_ms=execution_time_ms,
+                error_type=None if success else "execution_error",
+                conversation_history_length=conversation_history_length,
+            )
+
             # Clean up if necessary (e.g., if not using client-managed sessions)
             if manage_connector and not self.client and not initialized_here:
                 logger.info("🧹 Closing agent after query completion")

mcp_use/client.py

@@ -9,10 +9,11 @@ import json
 import warnings
 from typing import Any
 
+from mcp_use.types.sandbox import SandboxOptions
+
 from .config import create_connector_from_config, load_config_file
 from .logging import logger
 from .session import MCPSession
-from .types.clientoptions import ClientOptions
 
 
 class MCPClient:
@@ -25,17 +26,20 @@ class MCPClient:
     def __init__(
         self,
         config: str | dict[str, Any] | None = None,
-        options: ClientOptions | None = None,
+        sandbox: bool = False,
+        sandbox_options: SandboxOptions | None = None,
     ) -> None:
         """Initialize a new MCP client.
 
         Args:
             config: Either a dict containing configuration or a path to a JSON config file.
                    If None, an empty configuration is used.
-            options: Configuration options for the client.
+            sandbox: Whether to use sandboxed execution mode for running MCP servers.
+            sandbox_options: Optional sandbox configuration options.
         """
         self.config: dict[str, Any] = {}
-        self.options = options or {}
+        self.sandbox = sandbox
+        self.sandbox_options = sandbox_options
         self.sessions: dict[str, MCPSession] = {}
         self.active_sessions: list[str] = []
 
@@ -47,24 +51,35 @@ class MCPClient:
                 self.config = config
 
     @classmethod
-    def from_dict(cls, config: dict[str, Any], options: ClientOptions | None = None) -> "MCPClient":
+    def from_dict(
+        cls,
+        config: dict[str, Any],
+        sandbox: bool = False,
+        sandbox_options: SandboxOptions | None = None,
+    ) -> "MCPClient":
         """Create a MCPClient from a dictionary.
 
         Args:
             config: The configuration dictionary.
-            options: Optional client configuration options.
+            sandbox: Whether to use sandboxed execution mode for running MCP servers.
+            sandbox_options: Optional sandbox configuration options.
         """
-        return cls(config=config, options=options)
+        return cls(config=config, sandbox=sandbox, sandbox_options=sandbox_options)
 
     @classmethod
-    def from_config_file(cls, filepath: str, options: ClientOptions | None = None) -> "MCPClient":
+    def from_config_file(
+        cls, filepath: str, sandbox: bool = False, sandbox_options: SandboxOptions | None = None
+    ) -> "MCPClient":
         """Create a MCPClient from a configuration file.
 
         Args:
             filepath: The path to the configuration file.
-            options: Optional client configuration options.
+            sandbox: Whether to use sandboxed execution mode for running MCP servers.
+            sandbox_options: Optional sandbox configuration options.
         """
-        return cls(config=load_config_file(filepath), options=options)
+        return cls(
+            config=load_config_file(filepath), sandbox=sandbox, sandbox_options=sandbox_options
+        )
 
     def add_server(
         self,
@@ -137,7 +152,9 @@ class MCPClient:
         server_config = servers[server_name]
 
         # Create connector with options
-        connector = create_connector_from_config(server_config, options=self.options)
+        connector = create_connector_from_config(
+            server_config, sandbox=self.sandbox, sandbox_options=self.sandbox_options
+        )
 
         # Create the session
         session = MCPSession(connector)

mcp_use/config.py

@@ -7,6 +7,8 @@ This module provides functionality to load MCP configuration from JSON files.
 import json
 from typing import Any
 
+from mcp_use.types.sandbox import SandboxOptions
+
 from .connectors import (
     BaseConnector,
     HttpConnector,
@@ -15,7 +17,6 @@ from .connectors import (
     WebSocketConnector,
 )
 from .connectors.utils import is_stdio_server
-from .types.clientoptions import ClientOptions
 
 
 def load_config_file(filepath: str) -> dict[str, Any]:
@@ -33,24 +34,23 @@ def load_config_file(filepath: str) -> dict[str, Any]:
 
 def create_connector_from_config(
     server_config: dict[str, Any],
-    options: ClientOptions | None = None,
+    sandbox: bool = False,
+    sandbox_options: SandboxOptions | None = None,
 ) -> BaseConnector:
     """Create a connector based on server configuration.
     This function can be called with just the server_config parameter:
     create_connector_from_config(server_config)
     Args:
         server_config: The server configuration section
-        options: Optional client configuration options including sandboxing preferences.
-                 If None, default client options will be used.
+        sandbox: Whether to use sandboxed execution mode for running MCP servers.
+        sandbox_options: Optional sandbox configuration options.
 
     Returns:
         A configured connector instance
     """
-    # Use default options if none provided
-    options = options or {"is_sandboxed": False}
 
     # Stdio connector (command-based)
-    if is_stdio_server(server_config) and not options.get("is_sandboxed", False):
+    if is_stdio_server(server_config) and not sandbox:
         return StdioConnector(
             command=server_config["command"],
             args=server_config["args"],
@@ -58,12 +58,12 @@ def create_connector_from_config(
         )
 
     # Sandboxed connector
-    elif is_stdio_server(server_config) and options.get("is_sandboxed", False):
+    elif is_stdio_server(server_config) and sandbox:
         return SandboxConnector(
             command=server_config["command"],
             args=server_config["args"],
             env=server_config.get("env", None),
-            e2b_options=options.get("sandbox_options", {}),
+            e2b_options=sandbox_options,
         )
 
     # HTTP connector

mcp_use/connectors/base.py

@@ -24,18 +24,25 @@ class BaseConnector(ABC):
 
     def __init__(self):
         """Initialize base connector with common attributes."""
-        self.client: ClientSession | None = None
+        self.client_session: ClientSession | None = None
         self._connection_manager: ConnectionManager | None = None
         self._tools: list[Tool] | None = None
         self._resources: list[Resource] | None = None
         self._prompts: list[Prompt] | None = None
         self._connected = False
+        self.auto_reconnect = True  # Whether to automatically reconnect on connection loss (not configurable for now), may be made configurable through the connector_config
 
     @abstractmethod
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
         pass
 
+    @property
+    @abstractmethod
+    def public_identifier(self) -> str:
+        """Get the identifier for the connector."""
+        pass
+
     async def disconnect(self) -> None:
         """Close the connection to the MCP implementation."""
         if not self._connected:
@@ -52,16 +59,16 @@ class BaseConnector(ABC):
         errors = []
 
         # First close the client session
-        if self.client:
+        if self.client_session:
             try:
                 logger.debug("Closing client session")
-                await self.client.__aexit__(None, None, None)
+                await self.client_session.__aexit__(None, None, None)
             except Exception as e:
                 error_msg = f"Error closing client session: {e}"
                 logger.warning(error_msg)
                 errors.append(error_msg)
             finally:
-                self.client = None
+                self.client_session = None
 
         # Then stop the connection manager
         if self._connection_manager:
@@ -85,13 +92,13 @@ class BaseConnector(ABC):
 
     async def initialize(self) -> dict[str, Any]:
         """Initialize the MCP session and return session information."""
-        if not self.client:
+        if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug("Initializing MCP session")
 
         # Initialize the session
-        result = await self.client.initialize()
+        result = await self.client_session.initialize()
 
         server_capabilities = result.capabilities
 
@@ -116,11 +123,7 @@ class BaseConnector(ABC):
         else:
             self._prompts = []
 
-        logger.debug(
-            f"MCP session initialized with {len(self._tools)} tools, "
-            f"{len(self._resources)} resources, "
-            f"and {len(self._prompts)} prompts"
-        )
+        logger.debug(f"MCP session initialized with {len(self._tools)} tools, " f"{len(self._resources)} resources, " f"and {len(self._prompts)} prompts")
 
         return result
 
@@ -145,24 +148,121 @@ class BaseConnector(ABC):
             raise RuntimeError("MCP client is not initialized")
         return self._prompts
 
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
-        """Call an MCP tool with the given arguments."""
-        if not self.client:
+    @property
+    def is_connected(self) -> bool:
+        """Check if the connector is actually connected and the connection is alive.
+
+        This property checks not only the connected flag but also verifies that
+        the underlying connection manager and streams are still active.
+
+        Returns:
+            True if the connector is connected and the connection is alive, False otherwise.
+        """
+
+        # Check if we have a client session
+        if not self.client_session:
+            # Update the connected flag since we don't have a client session
+            self._connected = False
+            return False
+
+        # First check the basic connected flag
+        if not self._connected:
+            return False
+
+        # Check if we have a connection manager and if its task is still running
+        if self._connection_manager:
+            try:
+                # Check if the connection manager task is done (indicates disconnection)
+                if hasattr(self._connection_manager, "_task") and self._connection_manager._task:
+                    if self._connection_manager._task.done():
+                        logger.debug("Connection manager task is done, marking as disconnected")
+                        self._connected = False
+                        return False
+
+                # For HTTP-based connectors, also check if streams are still open
+                # Use the get_streams method to get the current connection
+                streams = self._connection_manager.get_streams()
+                if streams:
+                    # Connection should be a tuple of (read_stream, write_stream)
+                    if isinstance(streams, tuple) and len(streams) == 2:
+                        read_stream, write_stream = streams
+                        # Check if streams are closed using getattr with default value
+                        if getattr(read_stream, "_closed", False):
+                            logger.debug("Read stream is closed, marking as disconnected")
+                            self._connected = False
+                            return False
+                        if getattr(write_stream, "_closed", False):
+                            logger.debug("Write stream is closed, marking as disconnected")
+                            self._connected = False
+                            return False
+
+            except Exception as e:
+                # If we can't check the connection state, assume disconnected for safety
+                logger.debug(f"Error checking connection state: {e}, marking as disconnected")
+                self._connected = False
+                return False
+
+        return True
+
+    async def _ensure_connected(self) -> None:
+        """Ensure the connector is connected, reconnecting if necessary.
+
+        Raises:
+            RuntimeError: If connection cannot be established and auto_reconnect is False.
+        """
+        if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
+        if not self.is_connected:
+            if self.auto_reconnect:
+                logger.debug("Connection lost, attempting to reconnect...")
+                try:
+                    await self.connect()
+                    logger.debug("Reconnection successful")
+                except Exception as e:
+                    raise RuntimeError(f"Failed to reconnect to MCP server: {e}") from e
+            else:
+                raise RuntimeError("Connection to MCP server has been lost. " "Auto-reconnection is disabled. Please reconnect manually.")
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
+        """Call an MCP tool with automatic reconnection handling.
+
+        Args:
+            name: The name of the tool to call.
+            arguments: The arguments to pass to the tool.
+
+        Returns:
+            The result of the tool call.
+
+        Raises:
+            RuntimeError: If the connection is lost and cannot be reestablished.
+        """
+
+        # Ensure we're connected
+        await self._ensure_connected()
+
         logger.debug(f"Calling tool '{name}' with arguments: {arguments}")
-        result = await self.client.call_tool(name, arguments)
-        logger.debug(f"Tool '{name}' called with result: {result}")
-        return result
+        try:
+            result = await self.client_session.call_tool(name, arguments)
+            logger.debug(f"Tool '{name}' called with result: {result}")
+            return result
+        except Exception as e:
+            # Check if the error might be due to connection loss
+            if not self.is_connected:
+                raise RuntimeError(f"Tool call '{name}' failed due to connection loss: {e}") from e
+            else:
+                # Re-raise the original error if it's not connection-related
+                raise
 
     async def list_tools(self) -> list[Tool]:
         """List all available tools from the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug("Listing tools")
         try:
-            result = await self.client.list_tools()
+            result = await self.client_session.list_tools()
             return result.tools
         except McpError as e:
             logger.error(f"Error listing tools: {e}")
@@ -170,12 +270,12 @@ class BaseConnector(ABC):
 
     async def list_resources(self) -> list[Resource]:
         """List all available resources from the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug("Listing resources")
         try:
-            result = await self.client.list_resources()
+            result = await self.client_session.list_resources()
             return result.resources
         except McpError as e:
             logger.error(f"Error listing resources: {e}")
@@ -183,41 +283,39 @@ class BaseConnector(ABC):
 
     async def read_resource(self, uri: str) -> ReadResourceResult:
         """Read a resource by URI."""
-        if not self.client:
+        if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug(f"Reading resource: {uri}")
-        result = await self.client.read_resource(uri)
+        result = await self.client_session.read_resource(uri)
         return result
 
     async def list_prompts(self) -> list[Prompt]:
         """List all available prompts from the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug("Listing prompts")
         try:
-            result = await self.client.list_prompts()
+            result = await self.client_session.list_prompts()
             return result.prompts
         except McpError as e:
             logger.error(f"Error listing prompts: {e}")
             return []
 
-    async def get_prompt(
-        self, name: str, arguments: dict[str, Any] | None = None
-    ) -> GetPromptResult:
+    async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> GetPromptResult:
         """Get a prompt by name."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug(f"Getting prompt: {name}")
-        result = await self.client.get_prompt(name, arguments)
+        result = await self.client_session.get_prompt(name, arguments)
         return result
 
     async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
         """Send a raw request to the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug(f"Sending request: {method} with params: {params}")
-        return await self.client.request({"method": method, "params": params or {}})
+        return await self.client_session.request({"method": method, "params": params or {}})