mcp-use 1.3.12__py3-none-any.whl → 1.3.13__py3-none-any.whl

mcp_use/session.py

@@ -1,154 +1,18 @@
-"""
-Session manager for MCP connections.
+# mcp_use/session.py
+import warnings
 
-This module provides a session manager for MCP connections,
-which handles authentication, initialization, and tool discovery.
-"""
+from typing_extensions import deprecated
 
-from datetime import timedelta
-from typing import Any
+from mcp_use.client.session import MCPSession as _MCPSession
 
-from mcp.types import CallToolResult, GetPromptResult, Prompt, ReadResourceResult, Resource, Tool
-from pydantic import AnyUrl
+warnings.warn(
+    "mcp_use.session.MCPSession is deprecated. "
+    "Use mcp_use.client.session.MCPSession. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-from .connectors.base import BaseConnector
 
-
-class MCPSession:
-    """Session manager for MCP connections.
-
-    This class manages the lifecycle of an MCP connection, including
-    authentication, initialization, and tool discovery.
-    """
-
-    def __init__(
-        self,
-        connector: BaseConnector,
-        auto_connect: bool = True,
-    ) -> None:
-        """Initialize a new MCP session.
-
-        Args:
-            connector: The connector to use for communicating with the MCP implementation.
-            auto_connect: Whether to automatically connect to the MCP implementation.
-        """
-        self.connector = connector
-        self.session_info: dict[str, Any] | None = None
-        self.auto_connect = auto_connect
-
-    async def __aenter__(self) -> "MCPSession":
-        """Enter the async context manager.
-
-        Returns:
-            The session instance.
-        """
-        await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
-        """Exit the async context manager.
-
-        Args:
-            exc_type: The exception type, if an exception was raised.
-            exc_val: The exception value, if an exception was raised.
-            exc_tb: The exception traceback, if an exception was raised.
-        """
-        await self.disconnect()
-
-    async def connect(self) -> None:
-        """Connect to the MCP implementation."""
-        await self.connector.connect()
-
-    async def disconnect(self) -> None:
-        """Disconnect from the MCP implementation."""
-        await self.connector.disconnect()
-
-    async def initialize(self) -> dict[str, Any]:
-        """Initialize the MCP session and discover available tools.
-
-        Returns:
-            The session information returned by the MCP implementation.
-        """
-        # Make sure we're connected
-        if not self.is_connected and self.auto_connect:
-            await self.connect()
-
-        # Initialize the session
-        self.session_info = await self.connector.initialize()
-
-        return self.session_info
-
-    @property
-    def is_connected(self) -> bool:
-        """Check if the connector is connected.
-
-        Returns:
-            True if the connector is connected, False otherwise.
-        """
-        return self.connector.is_connected
-
-    # Convenience methods for MCP operations
-    async def call_tool(
-        self, name: str, arguments: dict[str, Any], read_timeout_seconds: timedelta | None = None
-    ) -> CallToolResult:
-        """Call an MCP tool.
-
-        Args:
-            name: The name of the tool to call.
-            arguments: The arguments to pass to the tool.
-            read_timeout_seconds: Optional timeout for the tool call.
-
-        Returns:
-            The result of the tool call.
-
-        Raises:
-            RuntimeError: If the connection is lost and cannot be reestablished.
-        """
-        return await self.connector.call_tool(name, arguments, read_timeout_seconds)
-
-    async def list_tools(self) -> list[Tool]:
-        """List all available tools from the MCP server.
-
-        Returns:
-            List of available tools.
-        """
-        return await self.connector.list_tools()
-
-    async def list_resources(self) -> list[Resource]:
-        """List all available resources from the MCP server.
-
-        Returns:
-            List of available resources.
-        """
-        return await self.connector.list_resources()
-
-    async def read_resource(self, uri: AnyUrl) -> ReadResourceResult:
-        """Read a resource by URI.
-
-        Args:
-            uri: The URI of the resource to read.
-
-        Returns:
-            The resource content.
-        """
-        return await self.connector.read_resource(uri)
-
-    async def list_prompts(self) -> list[Prompt]:
-        """List all available prompts from the MCP server.
-
-        Returns:
-            List of available prompts.
-        """
-        return await self.connector.list_prompts()
-
-    async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> GetPromptResult:
-        """Get a prompt by name.
-
-        Args:
-            name: The name of the prompt to get.
-            arguments: Optional arguments for the prompt.
-
-        Returns:
-            The prompt result with messages.
-        """
-        return await self.connector.get_prompt(name, arguments)
+@deprecated("Use mcp_use.client.session.MCPSession")
+class MCPSession(_MCPSession): ...

mcp_use/task_managers/__init__.py

@@ -1,20 +1,48 @@
-"""
-Connectors for various MCP transports.
-
-This module provides interfaces for connecting to MCP implementations
-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",
-    "StdioConnectionManager",
-    "WebSocketConnectionManager",
-    "SseConnectionManager",
-    "StreamableHttpConnectionManager",
-]
+# mcp_use/task_managers/__init__.py
+import warnings
+
+from typing_extensions import deprecated
+
+from mcp_use.client.task_managers import (
+    ConnectionManager as _ConnectionManager,
+)
+from mcp_use.client.task_managers import (
+    SseConnectionManager as _SseConnectionManager,
+)
+from mcp_use.client.task_managers import (
+    StdioConnectionManager as _StdioConnectionManager,
+)
+from mcp_use.client.task_managers import (
+    StreamableHttpConnectionManager as _StreamableHttpConnectionManager,
+)
+from mcp_use.client.task_managers import (
+    WebSocketConnectionManager as _WebSocketConnectionManager,
+)
+
+warnings.warn(
+    "mcp_use.task_managers is deprecated. "
+    "Use mcp_use.client.task_managers. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+
+@deprecated("Use mcp_use.client.task_managers.ConnectionManager")
+class ConnectionManager(_ConnectionManager): ...
+
+
+@deprecated("Use mcp_use.client.task_managers.StdioConnectionManager")
+class StdioConnectionManager(_StdioConnectionManager): ...
+
+
+@deprecated("Use mcp_use.client.task_managers.WebSocketConnectionManager")
+class WebSocketConnectionManager(_WebSocketConnectionManager): ...
+
+
+@deprecated("Use mcp_use.client.task_managers.SseConnectionManager")
+class SseConnectionManager(_SseConnectionManager): ...
+
+
+@deprecated("Use mcp_use.client.task_managers.StreamableHttpConnectionManager")
+class StreamableHttpConnectionManager(_StreamableHttpConnectionManager): ...

mcp_use/task_managers/base.py

@@ -1,145 +1,18 @@
-"""
-Connection management for MCP implementations.
+# mcp_use/task_managers/base.py
+import warnings
 
-This module provides an abstract base class for different types of connection
-managers used in MCP connectors.
-"""
+from typing_extensions import deprecated
 
-import asyncio
-from abc import ABC, abstractmethod
-from typing import Generic, TypeVar
+from mcp_use.client.task_managers.base import ConnectionManager as _ConnectionManager
 
-from ..logging import logger
+warnings.warn(
+    "mcp_use.task_managers.base is deprecated. "
+    "Use mcp_use.client.task_managers.base. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-# Type variable for connection types
-T = TypeVar("T")
 
-
-class ConnectionManager(Generic[T], ABC):
-    """Abstract base class for connection managers.
-
-    This class defines the interface for different types of connection managers
-    used with MCP connectors.
-    """
-
-    def __init__(self) -> None:
-        """Initialize a new connection manager."""
-        self._ready_event = asyncio.Event()
-        self._done_event = asyncio.Event()
-        self._stop_event = asyncio.Event()
-        self._exception: Exception | None = None
-        self._connection: T | None = None
-        self._task: asyncio.Task[None] | None = None
-
-    @abstractmethod
-    async def _establish_connection(self) -> T:
-        """Establish the connection.
-
-        This method should be implemented by subclasses to establish
-        the specific type of connection needed.
-
-        Returns:
-            The established connection.
-
-        Raises:
-            Exception: If connection cannot be established.
-        """
-        pass
-
-    @abstractmethod
-    async def _close_connection(self) -> None:
-        """Close the connection.
-
-        This method should be implemented by subclasses to close
-        the specific type of connection.
-
-        """
-        pass
-
-    async def start(self) -> T:
-        """Start the connection manager and establish a connection.
-
-        Returns:
-            The established connection.
-
-        Raises:
-            Exception: If connection cannot be established.
-        """
-        # Reset state
-        self._ready_event.clear()
-        self._done_event.clear()
-        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")
-
-        # Wait for the connection to be ready or fail
-        await self._ready_event.wait()
-
-        # If there was an exception, raise it
-        if self._exception:
-            raise self._exception
-
-        # Return the connection
-        if self._connection is None:
-            raise RuntimeError("Connection was not established")
-        return self._connection
-
-    async def stop(self) -> None:
-        """Stop the connection manager and close the connection."""
-        # Signal stop to the connection task instead of cancelling it, avoids
-        # propagating CancelledError to unrelated tasks.
-        if self._task and not self._task.done():
-            logger.debug(f"Signaling stop to {self.__class__.__name__} task")
-            self._stop_event.set()
-            # Wait for it to finish gracefully
-            await self._task
-
-        # Ensure cleanup completed
-        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.
-
-        This task establishes and maintains the connection until cancelled.
-        """
-        logger.debug(f"Starting {self.__class__.__name__} task")
-        try:
-            # Establish the connection
-            self._connection = await self._establish_connection()
-            logger.debug(f"{self.__class__.__name__} connected successfully")
-
-            # Signal that the connection is ready
-            self._ready_event.set()
-
-            # Wait until stop is requested
-            await self._stop_event.wait()
-
-        except Exception as e:
-            # Store the exception
-            self._exception = e
-            logger.error(f"Error in {self.__class__.__name__} task: {e}")
-
-            # Signal that the connection is ready (with error)
-            self._ready_event.set()
-
-        finally:
-            # Close the connection if it was established
-            if self._connection is not None:
-                try:
-                    await self._close_connection()
-                except Exception as e:
-                    logger.warning(f"Error closing connection in {self.__class__.__name__}: {e}")
-                self._connection = None
-
-            # Signal that the connection is done
-            self._done_event.set()
+@deprecated("Use mcp_use.client.task_managers.base.ConnectionManager")
+class ConnectionManager(_ConnectionManager): ...

mcp_use/task_managers/sse.py

@@ -1,84 +1,18 @@
-"""
-SSE connection management for MCP implementations.
+# mcp_use/task_managers/sse.py
+import warnings
 
-This module provides a connection manager for SSE-based MCP connections
-that ensures proper task isolation and resource cleanup.
-"""
+from typing_extensions import deprecated
 
-from typing import Any
+from mcp_use.client.task_managers.sse import SseConnectionManager as _SseConnectionManager
 
-import httpx
-from mcp.client.sse import sse_client
+warnings.warn(
+    "mcp_use.task_managers.sse is deprecated. "
+    "Use mcp_use.client.task_managers.sse. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-from ..logging import logger
-from .base import ConnectionManager
 
-
-class SseConnectionManager(ConnectionManager[tuple[Any, Any]]):
-    """Connection manager for SSE-based MCP connections.
-
-    This class handles the proper task isolation for sse_client context managers
-    to prevent the "cancel scope in different task" error. It runs the sse_client
-    in a dedicated task and manages its lifecycle.
-    """
-
-    def __init__(
-        self,
-        url: str,
-        headers: dict[str, str] | None = None,
-        timeout: float = 5,
-        sse_read_timeout: float = 60 * 5,
-        auth: httpx.Auth | None = None,
-    ):
-        """Initialize a new SSE connection manager.
-
-        Args:
-            url: The SSE endpoint URL
-            headers: Optional HTTP headers
-            timeout: Timeout for HTTP operations in seconds
-            sse_read_timeout: Timeout for SSE read operations in seconds
-            auth: Optional httpx.Auth instance for authentication
-        """
-        super().__init__()
-        self.url = url
-        self.headers = headers or {}
-        self.timeout = timeout
-        self.sse_read_timeout = sse_read_timeout
-        self.auth = auth
-        self._sse_ctx = None
-
-    async def _establish_connection(self) -> tuple[Any, Any]:
-        """Establish an SSE connection.
-
-        Returns:
-            A tuple of (read_stream, write_stream)
-
-        Raises:
-            Exception: If connection cannot be established.
-        """
-        # Create the context manager
-        self._sse_ctx = sse_client(
-            url=self.url,
-            headers=self.headers,
-            timeout=self.timeout,
-            sse_read_timeout=self.sse_read_timeout,
-            auth=self.auth,
-        )
-
-        # Enter the context manager
-        read_stream, write_stream = await self._sse_ctx.__aenter__()
-
-        # Return the streams
-        return (read_stream, write_stream)
-
-    async def _close_connection(self) -> None:
-        """Close the SSE connection."""
-
-        if self._sse_ctx:
-            # Exit the context manager
-            try:
-                await self._sse_ctx.__aexit__(None, None, None)
-            except Exception as e:
-                logger.warning(f"Error closing SSE context: {e}")
-            finally:
-                self._sse_ctx = None
+@deprecated("Use mcp_use.client.task_managers.sse.SseConnectionManager")
+class SseConnectionManager(_SseConnectionManager): ...

mcp_use/task_managers/stdio.py

@@ -1,69 +1,18 @@
-"""
-StdIO connection management for MCP implementations.
+# mcp_use/task_managers/stdio.py
+import warnings
 
-This module provides a connection manager for stdio-based MCP connections
-that ensures proper task isolation and resource cleanup.
-"""
+from typing_extensions import deprecated
 
-import sys
-from typing import Any, TextIO
+from mcp_use.client.task_managers.stdio import StdioConnectionManager as _StdioConnectionManager
 
-from mcp import StdioServerParameters
-from mcp.client.stdio import stdio_client
+warnings.warn(
+    "mcp_use.task_managers.stdio is deprecated. "
+    "Use mcp_use.client.task_managers.stdio. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-from ..logging import logger
-from .base import ConnectionManager
 
-
-class StdioConnectionManager(ConnectionManager[tuple[Any, Any]]):
-    """Connection manager for stdio-based MCP connections.
-
-    This class handles the proper task isolation for stdio_client context managers
-    to prevent the "cancel scope in different task" error. It runs the stdio_client
-    in a dedicated task and manages its lifecycle.
-    """
-
-    def __init__(
-        self,
-        server_params: StdioServerParameters,
-        errlog: TextIO = sys.stderr,
-    ):
-        """Initialize a new stdio connection manager.
-
-        Args:
-            server_params: The parameters for the stdio server
-            errlog: The error log stream
-        """
-        super().__init__()
-        self.server_params = server_params
-        self.errlog = errlog
-        self._stdio_ctx = None
-
-    async def _establish_connection(self) -> tuple[Any, Any]:
-        """Establish a stdio connection.
-
-        Returns:
-            A tuple of (read_stream, write_stream)
-
-        Raises:
-            Exception: If connection cannot be established.
-        """
-        # Create the context manager
-        self._stdio_ctx = stdio_client(self.server_params, self.errlog)
-
-        # Enter the context manager
-        read_stream, write_stream = await self._stdio_ctx.__aenter__()
-
-        # Return the streams
-        return (read_stream, write_stream)
-
-    async def _close_connection(self) -> None:
-        """Close the stdio connection."""
-        if self._stdio_ctx:
-            # Exit the context manager
-            try:
-                await self._stdio_ctx.__aexit__(None, None, None)
-            except Exception as e:
-                logger.warning(f"Error closing stdio context: {e}")
-            finally:
-                self._stdio_ctx = None
+@deprecated("Use mcp_use.client.task_managers.stdio.StdioConnectionManager")
+class StdioConnectionManager(_StdioConnectionManager): ...

mcp_use/task_managers/streamable_http.py

@@ -1,86 +1,20 @@
-"""
-Streamable HTTP connection management for MCP implementations.
+# mcp_use/task_managers/streamable_http.py
+import warnings
 
-This module provides a connection manager for streamable HTTP-based MCP connections
-that ensures proper task isolation and resource cleanup.
-"""
+from typing_extensions import deprecated
 
-from datetime import timedelta
-from typing import Any
+from mcp_use.client.task_managers.streamable_http import (
+    StreamableHttpConnectionManager as _StreamableHttpConnectionManager,
+)
 
-import httpx
-from mcp.client.streamable_http import streamablehttp_client
+warnings.warn(
+    "mcp_use.task_managers.streamable_http is deprecated. "
+    "Use mcp_use.client.task_managers.streamable_http. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-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,
-        auth: httpx.Auth | None = None,
-    ):
-        """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
-            auth: Optional httpx.Auth instance for authentication
-        """
-        super().__init__()
-        self.url = url
-        self.headers = headers or {}
-        self.timeout = timedelta(seconds=timeout)
-        self.read_timeout = timedelta(seconds=read_timeout)
-        self.auth = auth
-        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,
-            auth=self.auth,
-        )
-
-        # 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
+@deprecated("Use mcp_use.client.task_managers.streamable_http.StreamableHttpConnectionManager")
+class StreamableHttpConnectionManager(_StreamableHttpConnectionManager): ...