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

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)
 
     @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
 
@@ -145,24 +152,123 @@ 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 +276,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 +289,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 {}})

mcp_use/connectors/http.py

@@ -2,20 +2,21 @@
 HTTP connector for MCP implementations.
 
 This module provides a connector for communicating with MCP implementations
-through HTTP APIs with SSE for transport.
+through HTTP APIs with SSE or Streamable HTTP for transport.
 """
 
+import httpx
 from mcp import ClientSession
 
 from ..logging import logger
-from ..task_managers import SseConnectionManager
+from ..task_managers import ConnectionManager, SseConnectionManager, StreamableHttpConnectionManager
 from .base import BaseConnector
 
 
 class HttpConnector(BaseConnector):
-    """Connector for MCP implementations using HTTP transport with SSE.
+    """Connector for MCP implementations using HTTP transport with SSE or streamable HTTP.
 
-    This connector uses HTTP/SSE to communicate with remote MCP implementations,
+    This connector uses HTTP/SSE or streamable HTTP to communicate with remote MCP implementations,
     using a connection manager to handle the proper lifecycle management.
     """
 
@@ -45,38 +46,107 @@ class HttpConnector(BaseConnector):
         self.timeout = timeout
         self.sse_read_timeout = sse_read_timeout
 
+    async def _setup_client(self, connection_manager: ConnectionManager) -> None:
+        """Set up the client session with the provided connection manager."""
+
+        self._connection_manager = connection_manager
+        read_stream, write_stream = await self._connection_manager.start()
+        self.client_session = ClientSession(read_stream, write_stream, sampling_callback=None)
+        await self.client_session.__aenter__()
+
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
         if self._connected:
             logger.debug("Already connected to MCP implementation")
             return
 
-        logger.debug(f"Connecting to MCP implementation via HTTP/SSE: {self.base_url}")
-        try:
-            # Create the SSE connection URL
-            sse_url = f"{self.base_url}"
-
-            # Create and start the connection manager
-            self._connection_manager = SseConnectionManager(
-                sse_url, self.headers, self.timeout, self.sse_read_timeout
-            )
-            read_stream, write_stream = await self._connection_manager.start()
+        # Try streamable HTTP first (new transport), fall back to SSE (old transport)
+        # This implements backwards compatibility per MCP specification
+        self.transport_type = None
+        connection_manager = None
 
-            # Create the client session
-            self.client = ClientSession(read_stream, write_stream, sampling_callback=None)
-            await self.client.__aenter__()
-
-            # Mark as connected
-            self._connected = True
-            logger.debug(
-                f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}"
+        try:
+            # First, try the new streamable HTTP transport
+            logger.debug(f"Attempting streamable HTTP connection to: {self.base_url}")
+            connection_manager = StreamableHttpConnectionManager(
+                self.base_url, self.headers, self.timeout, self.sse_read_timeout
             )
 
-        except Exception as e:
-            logger.error(f"Failed to connect to MCP implementation via HTTP/SSE: {e}")
-
-            # Clean up any resources if connection failed
-            await self._cleanup_resources()
-
-            # Re-raise the original exception
-            raise
+            # Test if this is a streamable HTTP server by attempting initialization
+            read_stream, write_stream = await connection_manager.start()
+
+            # Test if this actually works by trying to create a client session and initialize it
+            test_client = ClientSession(read_stream, write_stream, sampling_callback=None)
+            await test_client.__aenter__()
+
+            try:
+                # Try to initialize - this is where streamable HTTP vs SSE difference should show up
+                await test_client.initialize()
+
+                # If we get here, streamable HTTP works
+
+                self.client_session = test_client
+                self.transport_type = "streamable HTTP"
+
+            except Exception as init_error:
+                # Clean up the test client
+                try:
+                    await test_client.__aexit__(None, None, None)
+                except Exception:
+                    pass
+                raise init_error
+
+        except Exception as streamable_error:
+            logger.debug(f"Streamable HTTP failed: {streamable_error}")
+
+            # Clean up the failed streamable HTTP connection manager
+            if connection_manager:
+                try:
+                    await connection_manager.close()
+                except Exception:
+                    pass
+
+            # Check if this is a 4xx error that indicates we should try SSE fallback
+            should_fallback = False
+            if isinstance(streamable_error, httpx.HTTPStatusError):
+                if streamable_error.response.status_code in [404, 405]:
+                    should_fallback = True
+            elif "405 Method Not Allowed" in str(streamable_error) or "404 Not Found" in str(streamable_error):
+                should_fallback = True
+            else:
+                # For other errors, still try fallback but they might indicate
+                # real connectivity issues
+                should_fallback = True
+
+            if should_fallback:
+                try:
+                    # Fall back to the old SSE transport
+                    logger.debug(f"Attempting SSE fallback connection to: {self.base_url}")
+                    connection_manager = SseConnectionManager(
+                        self.base_url, self.headers, self.timeout, self.sse_read_timeout
+                    )
+
+                    read_stream, write_stream = await connection_manager.start()
+
+                    # Create the client session for SSE
+                    self.client_session = ClientSession(read_stream, write_stream, sampling_callback=None)
+                    await self.client_session.__aenter__()
+                    self.transport_type = "SSE"
+
+                except Exception as sse_error:
+                    logger.error(
+                        f"Both transport methods failed. Streamable HTTP: {streamable_error}, SSE: {sse_error}"
+                    )
+                    raise sse_error
+            else:
+                raise streamable_error
+
+        # Store the successful connection manager and mark as connected
+        self._connection_manager = connection_manager
+        self._connected = True
+        logger.debug(f"Successfully connected to MCP implementation via {self.transport_type}: {self.base_url}")
+
+    @property
+    def public_identifier(self) -> str:
+        """Get the identifier for the connector."""
+        return {"type": self.transport_type, "base_url": self.base_url}

mcp_use/connectors/sandbox.py

@@ -79,14 +79,12 @@ class SandboxConnector(BaseConnector):
         self.api_key = _e2b_options.get("api_key") or os.environ.get("E2B_API_KEY")
         if not self.api_key:
             raise ValueError(
-                "E2B API key is required. Provide it via 'e2b_options.api_key' "
+                "E2B API key is required. Provide it via 'sandbox_options.api_key' "
                 "or the E2B_API_KEY environment variable."
             )
 
         self.sandbox_template_id = _e2b_options.get("sandbox_template_id", "base")
-        self.supergateway_cmd_parts = _e2b_options.get(
-            "supergateway_command", "npx -y supergateway"
-        )
+        self.supergateway_cmd_parts = _e2b_options.get("supergateway_command", "npx -y supergateway")
 
         self.sandbox: Sandbox | None = None
         self.process: CommandHandle | None = None
@@ -138,10 +136,7 @@ class SandboxConnector(BaseConnector):
                         async with session.get(ping_url, timeout=2) as response:
                             if response.status == 200:
                                 elapsed = time.time() - start_time
-                                logger.info(
-                                    f"Server is ready! "
-                                    f"SSE endpoint responded with 200 after {elapsed:.1f}s"
-                                )
+                                logger.info(f"Server is ready! SSE endpoint responded with 200 after {elapsed:.1f}s")
                                 return True
                     except Exception:
                         # If sse endpoint doesn't work, try the base URL
@@ -149,8 +144,7 @@ class SandboxConnector(BaseConnector):
                             if response.status < 500:  # Accept any non-server error
                                 elapsed = time.time() - start_time
                                 logger.info(
-                                    f"Server is ready! Base URL responded with "
-                                    f"{response.status} after {elapsed:.1f}s"
+                                    f"Server is ready! Base URL responded with {response.status} after {elapsed:.1f}s"
                                 )
                                 return True
             except Exception:
@@ -220,9 +214,7 @@ class SandboxConnector(BaseConnector):
             sse_url = f"{self.base_url}/sse"
 
             # Create and start the connection manager
-            self._connection_manager = SseConnectionManager(
-                sse_url, self.headers, self.timeout, self.sse_read_timeout
-            )
+            self._connection_manager = SseConnectionManager(sse_url, self.headers, self.timeout, self.sse_read_timeout)
             read_stream, write_stream = await self._connection_manager.start()
 
             # Create the client session
@@ -231,9 +223,7 @@ class SandboxConnector(BaseConnector):
 
             # Mark as connected
             self._connected = True
-            logger.debug(
-                f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}"
-            )
+            logger.debug(f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}")
 
         except Exception as e:
             logger.error(f"Failed to connect to MCP implementation: {e}")
@@ -289,3 +279,8 @@ class SandboxConnector(BaseConnector):
         await self._cleanup_resources()
         self._connected = False
         logger.debug("Disconnected from MCP implementation")
+
+    @property
+    def public_identifier(self) -> str:
+        """Get the identifier for the connector."""
+        return {"type": "sandbox", "command": self.user_command, "args": self.user_args}

mcp_use/connectors/stdio.py

@@ -52,17 +52,15 @@ class StdioConnector(BaseConnector):
         logger.debug(f"Connecting to MCP implementation: {self.command}")
         try:
             # Create server parameters
-            server_params = StdioServerParameters(
-                command=self.command, args=self.args, env=self.env
-            )
+            server_params = StdioServerParameters(command=self.command, args=self.args, env=self.env)
 
             # Create and start the connection manager
             self._connection_manager = StdioConnectionManager(server_params, self.errlog)
             read_stream, write_stream = await self._connection_manager.start()
 
             # Create the client session
-            self.client = ClientSession(read_stream, write_stream, sampling_callback=None)
-            await self.client.__aenter__()
+            self.client_session = ClientSession(read_stream, write_stream, sampling_callback=None)
+            await self.client_session.__aenter__()
 
             # Mark as connected
             self._connected = True
@@ -76,3 +74,8 @@ class StdioConnector(BaseConnector):
 
             # Re-raise the original exception
             raise
+
+    @property
+    def public_identifier(self) -> str:
+        """Get the identifier for the connector."""
+        return {"type": "stdio", "command&args": f"{self.command} {' '.join(self.args)}"}

mcp_use/connectors/websocket.py

@@ -11,7 +11,7 @@ import uuid
 from typing import Any
 
 from mcp.types import Tool
-from websockets.client import WebSocketClientProtocol
+from websockets import ClientConnection
 
 from ..logging import logger
 from ..task_managers import ConnectionManager, WebSocketConnectionManager
@@ -44,7 +44,7 @@ class WebSocketConnector(BaseConnector):
         if auth_token:
             self.headers["Authorization"] = f"Bearer {auth_token}"
 
-        self.ws: WebSocketClientProtocol | None = None
+        self.ws: ClientConnection | None = None
         self._connection_manager: ConnectionManager | None = None
         self._receiver_task: asyncio.Task | None = None
         self.pending_requests: dict[str, asyncio.Future] = {}
@@ -64,9 +64,7 @@ class WebSocketConnector(BaseConnector):
             self.ws = await self._connection_manager.start()
 
             # Start the message receiver task
-            self._receiver_task = asyncio.create_task(
-                self._receive_messages(), name="websocket_receiver_task"
-            )
+            self._receiver_task = asyncio.create_task(self._receive_messages(), name="websocket_receiver_task")
 
             # Mark as connected
             self._connected = True
@@ -243,3 +241,8 @@ class WebSocketConnector(BaseConnector):
         """Send a raw request to the MCP implementation."""
         logger.debug(f"Sending request: {method} with params: {params}")
         return await self._send_request(method, params)
+
+    @property
+    def public_identifier(self) -> str:
+        """Get the identifier for the connector."""
+        return {"type": "websocket", "url": self.url}

mcp_use/logging.py

@@ -12,7 +12,7 @@ import sys
 from langchain.globals import set_debug as langchain_set_debug
 
 # Global debug flag - can be set programmatically or from environment
-MCP_USE_DEBUG = False
+MCP_USE_DEBUG = 1
 
 
 class Logger:

mcp_use/managers/server_manager.py

@@ -49,19 +49,13 @@ class ServerManager:
                 session = None
                 try:
                     session = self.client.get_session(server_name)
-                    logger.debug(
-                        f"Using existing session for server '{server_name}' to prefetch tools."
-                    )
+                    logger.debug(f"Using existing session for server '{server_name}' to prefetch tools.")
                 except ValueError:
                     try:
                         session = await self.client.create_session(server_name)
-                        logger.debug(
-                            f"Temporarily created session for '{server_name}' to prefetch tools"
-                        )
+                        logger.debug(f"Temporarily created session for '{server_name}' to prefetch tools")
                     except Exception:
-                        logger.warning(
-                            f"Could not create session for '{server_name}' during prefetch"
-                        )
+                        logger.warning(f"Could not create session for '{server_name}' during prefetch")
                         continue
 
                 # Fetch tools if session is available
@@ -70,17 +64,12 @@ class ServerManager:
                     tools = await self.adapter._create_tools_from_connectors([connector])
 
                     # Check if this server's tools have changed
-                    if (
-                        server_name not in self._server_tools
-                        or self._server_tools[server_name] != tools
-                    ):
+                    if server_name not in self._server_tools or self._server_tools[server_name] != tools:
                         self._server_tools[server_name] = tools  # Cache tools
                         self.initialized_servers[server_name] = True  # Mark as initialized
                         logger.debug(f"Prefetched {len(tools)} tools for server '{server_name}'.")
                     else:
-                        logger.debug(
-                            f"Tools for server '{server_name}' unchanged, using cached version."
-                        )
+                        logger.debug(f"Tools for server '{server_name}' unchanged, using cached version.")
             except Exception as e:
                 logger.error(f"Error prefetching tools for server '{server_name}': {e}")
 

mcp_use/managers/tools/disconnect_server.py

@@ -17,9 +17,7 @@ class DisconnectServerTool(MCPServerTool):
     """Tool for disconnecting from the currently active MCP server."""
 
     name: ClassVar[str] = "disconnect_from_mcp_server"
-    description: ClassVar[str] = (
-        "Disconnect from the currently active MCP (Model Context Protocol) server"
-    )
+    description: ClassVar[str] = "Disconnect from the currently active MCP (Model Context Protocol) server"
     args_schema: ClassVar[type[BaseModel]] = DisconnectServerInput
 
     def _run(self, **kwargs) -> str:

mcp_use/managers/tools/get_active_server.py

@@ -21,10 +21,7 @@ class GetActiveServerTool(MCPServerTool):
     def _run(self, **kwargs) -> str:
         """Get the currently active MCP server."""
         if not self.server_manager.active_server:
-            return (
-                "No MCP server is currently active. "
-                "Use connect_to_mcp_server to connect to a server."
-            )
+            return "No MCP server is currently active. Use connect_to_mcp_server to connect to a server."
         return f"Currently active MCP server: {self.server_manager.active_server}"
 
     async def _arun(self, **kwargs) -> str: