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

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,115 @@ 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}, "
+                        f"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"
+            f" {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,7 +79,7 @@ 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."
             )
 
@@ -289,3 +289,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

@@ -61,8 +61,8 @@ class StdioConnector(BaseConnector):
             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 +76,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] = {}
@@ -243,3 +243,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/session.py

@@ -7,8 +7,6 @@ which handles authentication, initialization, and tool discovery.
 
 from typing import Any
 
-from mcp.types import Tool
-
 from .connectors.base import BaseConnector
 
 
@@ -32,7 +30,6 @@ class MCPSession:
         """
         self.connector = connector
         self.session_info: dict[str, Any] | None = None
-        self.tools: list[Tool] = []
         self.auto_connect = auto_connect
 
     async def __aenter__(self) -> "MCPSession":
@@ -84,4 +81,4 @@ class MCPSession:
         Returns:
             True if the connector is connected, False otherwise.
         """
-        return hasattr(self.connector, "client") and self.connector.client is not None
+        return self.connector.is_connected

mcp_use/task_managers/__init__.py

@@ -8,12 +8,13 @@ through different transport mechanisms.
 from .base import ConnectionManager
 from .sse import SseConnectionManager
 from .stdio import StdioConnectionManager
+from .streamable_http import StreamableHttpConnectionManager
 from .websocket import WebSocketConnectionManager
 
 __all__ = [
     "ConnectionManager",
-    "HttpConnectionManager",
     "StdioConnectionManager",
     "WebSocketConnectionManager",
     "SseConnectionManager",
+    "StreamableHttpConnectionManager",
 ]

mcp_use/task_managers/base.py

@@ -70,9 +70,7 @@ class ConnectionManager(Generic[T], ABC):
         self._exception = None
 
         # Create a task to establish and maintain the connection
-        self._task = asyncio.create_task(
-            self._connection_task(), name=f"{self.__class__.__name__}_task"
-        )
+        self._task = asyncio.create_task(self._connection_task(), name=f"{self.__class__.__name__}_task")
 
         # Wait for the connection to be ready or fail
         await self._ready_event.wait()
@@ -105,6 +103,14 @@ class ConnectionManager(Generic[T], ABC):
         await self._done_event.wait()
         logger.debug(f"{self.__class__.__name__} task completed")
 
+    def get_streams(self) -> T | None:
+        """Get the current connection streams.
+
+        Returns:
+            The current connection (typically a tuple of read_stream, write_stream) or None if not connected.
+        """
+        return self._connection
+
     async def _connection_task(self) -> None:
         """Run the connection task.
 
@@ -137,7 +143,7 @@ class ConnectionManager(Generic[T], ABC):
             self._ready_event.set()
 
         finally:
-            # Close the connection if it was establishedSUPABASE_URL
+            # Close the connection if it was established
             if self._connection is not None:
                 try:
                     await self._close_connection()

mcp_use/task_managers/streamable_http.py

@@ -0,0 +1,81 @@
+"""
+Streamable HTTP connection management for MCP implementations.
+
+This module provides a connection manager for streamable HTTP-based MCP connections
+that ensures proper task isolation and resource cleanup.
+"""
+
+from datetime import timedelta
+from typing import Any
+
+from mcp.client.streamable_http import streamablehttp_client
+
+from ..logging import logger
+from .base import ConnectionManager
+
+
+class StreamableHttpConnectionManager(ConnectionManager[tuple[Any, Any]]):
+    """Connection manager for streamable HTTP-based MCP connections.
+
+    This class handles the proper task isolation for HTTP streaming connections
+    to prevent the "cancel scope in different task" error. It runs the http_stream_client
+    in a dedicated task and manages its lifecycle.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        timeout: float = 5,
+        read_timeout: float = 60 * 5,
+    ):
+        """Initialize a new streamable HTTP connection manager.
+
+        Args:
+            url: The HTTP endpoint URL
+            headers: Optional HTTP headers
+            timeout: Timeout for HTTP operations in seconds
+            read_timeout: Timeout for HTTP read operations in seconds
+        """
+        super().__init__()
+        self.url = url
+        self.headers = headers or {}
+        self.timeout = timedelta(seconds=timeout)
+        self.read_timeout = timedelta(seconds=read_timeout)
+        self._http_ctx = None
+
+    async def _establish_connection(self) -> tuple[Any, Any]:
+        """Establish a streamable HTTP connection.
+
+        Returns:
+            A tuple of (read_stream, write_stream)
+
+        Raises:
+            Exception: If connection cannot be established.
+        """
+        # Create the context manager
+        self._http_ctx = streamablehttp_client(
+            url=self.url,
+            headers=self.headers,
+            timeout=self.timeout,
+            sse_read_timeout=self.read_timeout,
+        )
+
+        # Enter the context manager. Ignoring the session id callback
+        read_stream, write_stream, _ = await self._http_ctx.__aenter__()
+
+        # Return the streams
+        return (read_stream, write_stream)
+
+    async def _close_connection(self) -> None:
+        """Close the streamable HTTP connection."""
+
+        if self._http_ctx:
+            # Exit the context manager
+            try:
+                await self._http_ctx.__aexit__(None, None, None)
+            except Exception as e:
+                # Only log if it's not a normal connection termination
+                logger.debug(f"Streamable HTTP context cleanup: {e}")
+            finally:
+                self._http_ctx = None

mcp_use/task_managers/websocket.py

@@ -22,14 +22,17 @@ class WebSocketConnectionManager(ConnectionManager[tuple[Any, Any]]):
     def __init__(
         self,
         url: str,
+        headers: dict[str, str] | None = None,
     ):
         """Initialize a new WebSocket connection manager.
 
         Args:
             url: The WebSocket URL to connect to
+            headers: Optional HTTP headers
         """
         super().__init__()
         self.url = url
+        self.headers = headers or {}
 
     async def _establish_connection(self) -> tuple[Any, Any]:
         """Establish a WebSocket connection.
@@ -42,6 +45,8 @@ class WebSocketConnectionManager(ConnectionManager[tuple[Any, Any]]):
         """
         logger.debug(f"Connecting to WebSocket: {self.url}")
         # Create the context manager
+        # Note: The current MCP websocket_client implementation doesn't support headers
+        # If headers need to be passed, this would need to be updated when MCP supports it
         self._ws_ctx = websocket_client(self.url)
 
         # Enter the context manager

mcp_use/telemetry/events.py

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+
+class BaseTelemetryEvent(ABC):
+    """Base class for all telemetry events"""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Event name for tracking"""
+        pass
+
+    @property
+    @abstractmethod
+    def properties(self) -> dict[str, Any]:
+        """Event properties to send with the event"""
+        pass
+
+
+@dataclass
+class MCPAgentExecutionEvent(BaseTelemetryEvent):
+    """Comprehensive event for tracking complete MCP agent execution"""
+
+    # Execution method and context
+    execution_method: str  # "run" or "astream"
+    query: str  # The actual user query
+    success: bool
+
+    # Agent configuration
+    model_provider: str
+    model_name: str
+    server_count: int
+    server_identifiers: list[dict[str, str]]
+    total_tools_available: int
+    tools_available_names: list[str]
+    max_steps_configured: int
+    memory_enabled: bool
+    use_server_manager: bool
+
+    # Execution PARAMETERS
+    max_steps_used: int | None
+    manage_connector: bool
+    external_history_used: bool
+
+    # Execution results
+    steps_taken: int | None = None
+    tools_used_count: int | None = None
+    tools_used_names: list[str] | None = None
+    response: str | None = None  # The actual response
+    execution_time_ms: int | None = None
+    error_type: str | None = None
+
+    # Context
+    conversation_history_length: int | None = None
+
+    @property
+    def name(self) -> str:
+        return "mcp_agent_execution"
+
+    @property
+    def properties(self) -> dict[str, Any]:
+        return {
+            # Core execution info
+            "execution_method": self.execution_method,
+            "query": self.query,
+            "query_length": len(self.query),
+            "success": self.success,
+            # Agent configuration
+            "model_provider": self.model_provider,
+            "model_name": self.model_name,
+            "server_count": self.server_count,
+            "server_identifiers": self.server_identifiers,
+            "total_tools_available": self.total_tools_available,
+            "tools_available_names": self.tools_available_names,
+            "max_steps_configured": self.max_steps_configured,
+            "memory_enabled": self.memory_enabled,
+            "use_server_manager": self.use_server_manager,
+            # Execution parameters (always include, even if None)
+            "max_steps_used": self.max_steps_used,
+            "manage_connector": self.manage_connector,
+            "external_history_used": self.external_history_used,
+            # Execution results (always include, even if None)
+            "steps_taken": self.steps_taken,
+            "tools_used_count": self.tools_used_count,
+            "tools_used_names": self.tools_used_names,
+            "response": self.response,
+            "response_length": len(self.response) if self.response else None,
+            "execution_time_ms": self.execution_time_ms,
+            "error_type": self.error_type,
+            "conversation_history_length": self.conversation_history_length,
+        }