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

mcp_use/client.py

@@ -1,350 +1,18 @@
-"""
-Client for managing MCP servers and sessions.
-
-This module provides a high-level client that manages MCP servers, connectors,
-and sessions from configuration.
-"""
-
-import json
+# mcp_use/client.py
 import warnings
-from typing import Any
-
-from mcp.client.session import ElicitationFnT, LoggingFnT, MessageHandlerFnT, SamplingFnT
-
-from mcp_use.types.sandbox import SandboxOptions
-
-from .config import create_connector_from_config, load_config_file
-from .logging import logger
-from .middleware import Middleware, default_logging_middleware
-from .session import MCPSession
-
-
-class MCPClient:
-    """Client for managing MCP servers and sessions.
-
-    This class provides a unified interface for working with MCP servers,
-    handling configuration, connector creation, and session management.
-    """
-
-    def __init__(
-        self,
-        config: str | dict[str, Any] | None = None,
-        allowed_servers: list[str] | None = None,
-        sandbox: bool = False,
-        sandbox_options: SandboxOptions | None = None,
-        sampling_callback: SamplingFnT | None = None,
-        elicitation_callback: ElicitationFnT | None = None,
-        message_handler: MessageHandlerFnT | None = None,
-        logging_callback: LoggingFnT | None = None,
-        middleware: list[Middleware] | 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.
-            sandbox: Whether to use sandboxed execution mode for running MCP servers.
-            sandbox_options: Optional sandbox configuration options.
-            sampling_callback: Optional sampling callback function.
-        """
-        self.config: dict[str, Any] = {}
-        self.allowed_servers: list[str] = allowed_servers
-        self.sandbox = sandbox
-        self.sandbox_options = sandbox_options
-        self.sessions: dict[str, MCPSession] = {}
-        self.active_sessions: list[str] = []
-        self.sampling_callback = sampling_callback
-        self.elicitation_callback = elicitation_callback
-        self.message_handler = message_handler
-        self.logging_callback = logging_callback
-        # Add default logging middleware if no middleware provided, or prepend it to existing middleware
-        default_middleware = [default_logging_middleware]
-        if middleware:
-            self.middleware = default_middleware + middleware
-        else:
-            self.middleware = default_middleware
-        # Load configuration if provided
-        if config is not None:
-            if isinstance(config, str):
-                self.config = load_config_file(config)
-            else:
-                self.config = config
-
-    @classmethod
-    def from_dict(
-        cls,
-        config: dict[str, Any],
-        sandbox: bool = False,
-        sandbox_options: SandboxOptions | None = None,
-        sampling_callback: SamplingFnT | None = None,
-        elicitation_callback: ElicitationFnT | None = None,
-        message_handler: MessageHandlerFnT | None = None,
-        logging_callback: LoggingFnT | None = None,
-    ) -> "MCPClient":
-        """Create a MCPClient from a dictionary.
-
-        Args:
-            config: The configuration dictionary.
-            sandbox: Whether to use sandboxed execution mode for running MCP servers.
-            sandbox_options: Optional sandbox configuration options.
-            sampling_callback: Optional sampling callback function.
-            elicitation_callback: Optional elicitation callback function.
-        """
-        return cls(
-            config=config,
-            sandbox=sandbox,
-            sandbox_options=sandbox_options,
-            sampling_callback=sampling_callback,
-            elicitation_callback=elicitation_callback,
-            message_handler=message_handler,
-            logging_callback=logging_callback,
-        )
-
-    @classmethod
-    def from_config_file(
-        cls,
-        filepath: str,
-        sandbox: bool = False,
-        sandbox_options: SandboxOptions | None = None,
-        sampling_callback: SamplingFnT | None = None,
-        elicitation_callback: ElicitationFnT | None = None,
-        message_handler: MessageHandlerFnT | None = None,
-        logging_callback: LoggingFnT | None = None,
-    ) -> "MCPClient":
-        """Create a MCPClient from a configuration file.
-
-        Args:
-            filepath: The path to the configuration file.
-            sandbox: Whether to use sandboxed execution mode for running MCP servers.
-            sandbox_options: Optional sandbox configuration options.
-            sampling_callback: Optional sampling callback function.
-            elicitation_callback: Optional elicitation callback function.
-        """
-        return cls(
-            config=load_config_file(filepath),
-            sandbox=sandbox,
-            sandbox_options=sandbox_options,
-            sampling_callback=sampling_callback,
-            elicitation_callback=elicitation_callback,
-            message_handler=message_handler,
-            logging_callback=logging_callback,
-        )
-
-    def add_server(
-        self,
-        name: str,
-        server_config: dict[str, Any],
-    ) -> None:
-        """Add a server configuration.
-
-        Args:
-            name: The name to identify this server.
-            server_config: The server configuration.
-        """
-        if "mcpServers" not in self.config:
-            self.config["mcpServers"] = {}
-
-        self.config["mcpServers"][name] = server_config
-
-    def remove_server(self, name: str) -> None:
-        """Remove a server configuration.
-
-        Args:
-            name: The name of the server to remove.
-        """
-        if "mcpServers" in self.config and name in self.config["mcpServers"]:
-            del self.config["mcpServers"][name]
-
-            # If we removed an active session, remove it from active_sessions
-            if name in self.active_sessions:
-                self.active_sessions.remove(name)
-
-    def add_middleware(self, middleware: Middleware) -> None:
-        """Add a middleware.
-
-        Args:
-            middleware: The middleware to add
-        """
-        if len(self.sessions) == 0 and middleware not in self.middleware:
-            self.middleware.append(middleware)
-            return
-
-        if middleware not in self.middleware:
-            self.middleware.append(middleware)
-            for session in self.sessions.values():
-                session.connector.middleware_manager.add_middleware(middleware)
-
-    def get_server_names(self) -> list[str]:
-        """Get the list of configured server names.
-
-        Returns:
-            List of server names.
-        """
-        return list(self.config.get("mcpServers", {}).keys())
-
-    def save_config(self, filepath: str) -> None:
-        """Save the current configuration to a file.
-
-        Args:
-            filepath: The path to save the configuration to.
-        """
-        with open(filepath, "w") as f:
-            json.dump(self.config, f, indent=2)
-
-    async def create_session(self, server_name: str, auto_initialize: bool = True) -> MCPSession:
-        """Create a session for the specified server.
-
-        Args:
-            server_name: The name of the server to create a session for.
-            auto_initialize: Whether to automatically initialize the session.
-
-        Returns:
-            The created MCPSession.
-
-        Raises:
-            ValueError: If the specified server doesn't exist.
-        """
-        # Get server config
-        servers = self.config.get("mcpServers", {})
-        if not servers:
-            warnings.warn("No MCP servers defined in config", UserWarning, stacklevel=2)
-            return None
-
-        if server_name not in servers:
-            raise ValueError(f"Server '{server_name}' not found in config")
-
-        server_config = servers[server_name]
-
-        # Create connector with options and client-level auth
-        connector = create_connector_from_config(
-            server_config,
-            sandbox=self.sandbox,
-            sandbox_options=self.sandbox_options,
-            sampling_callback=self.sampling_callback,
-            elicitation_callback=self.elicitation_callback,
-            message_handler=self.message_handler,
-            logging_callback=self.logging_callback,
-            middleware=self.middleware,
-        )
-
-        # Create the session
-        session = MCPSession(connector)
-        if auto_initialize:
-            await session.initialize()
-        self.sessions[server_name] = session
-
-        # Add to active sessions
-        if server_name not in self.active_sessions:
-            self.active_sessions.append(server_name)
-
-        return session
-
-    async def create_all_sessions(
-        self,
-        auto_initialize: bool = True,
-    ) -> dict[str, MCPSession]:
-        """Create sessions for all configured servers.
-
-        Args:
-            auto_initialize: Whether to automatically initialize the sessions.
-
-        Returns:
-            Dictionary mapping server names to their MCPSession instances.
-
-        Warns:
-            UserWarning: If no servers are configured.
-        """
-        # Get server config
-        servers = self.config.get("mcpServers", {})
-        if not servers:
-            warnings.warn("No MCP servers defined in config", UserWarning, stacklevel=2)
-            return {}
-
-        # Create sessions only for allowed servers if applicable else create for all servers
-        for name in servers:
-            if self.allowed_servers is None or name in self.allowed_servers:
-                await self.create_session(name, auto_initialize)
-
-        return self.sessions
-
-    def get_session(self, server_name: str) -> MCPSession:
-        """Get an existing session.
-
-        Args:
-            server_name: The name of the server to get the session for.
-                        If None, uses the first active session.
-
-        Returns:
-            The MCPSession for the specified server.
-
-        Raises:
-            ValueError: If no active sessions exist or the specified session doesn't exist.
-        """
-        if server_name not in self.sessions:
-            raise ValueError(f"No session exists for server '{server_name}'")
-
-        return self.sessions[server_name]
-
-    def get_all_active_sessions(self) -> dict[str, MCPSession]:
-        """Get all active sessions.
-
-        Returns:
-            Dictionary mapping server names to their MCPSession instances.
-        """
-        return {name: self.sessions[name] for name in self.active_sessions if name in self.sessions}
-
-    async def close_session(self, server_name: str) -> None:
-        """Close a session.
-
-        Args:
-            server_name: The name of the server to close the session for.
-                        If None, uses the first active session.
-
-        Raises:
-            ValueError: If no active sessions exist or the specified session doesn't exist.
-        """
-        # Check if the session exists
-        if server_name not in self.sessions:
-            logger.warning(f"No session exists for server '{server_name}', nothing to close")
-            return
-
-        # Get the session
-        session = self.sessions[server_name]
-
-        try:
-            # Disconnect from the session
-            logger.debug(f"Closing session for server '{server_name}'")
-            await session.disconnect()
-        except Exception as e:
-            logger.error(f"Error closing session for server '{server_name}': {e}")
-        finally:
-            # Remove the session regardless of whether disconnect succeeded
-            del self.sessions[server_name]
 
-            # Remove from active_sessions
-            if server_name in self.active_sessions:
-                self.active_sessions.remove(server_name)
+from typing_extensions import deprecated
 
-    async def close_all_sessions(self) -> None:
-        """Close all active sessions.
+from mcp_use.client.client import MCPClient as _MCPClient
 
-        This method ensures all sessions are closed even if some fail.
-        """
-        # Get a list of all session names first to avoid modification during iteration
-        server_names = list(self.sessions.keys())
-        errors = []
+warnings.warn(
+    "mcp_use.client.MCPClient is deprecated. "
+    "Use mcp_use.client.client.MCPClient. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-        for server_name in server_names:
-            try:
-                logger.debug(f"Closing session for server '{server_name}'")
-                await self.close_session(server_name)
-            except Exception as e:
-                error_msg = f"Failed to close session for server '{server_name}': {e}"
-                logger.error(error_msg)
-                errors.append(error_msg)
 
-        # Log summary if there were errors
-        if errors:
-            logger.error(f"Encountered {len(errors)} errors while closing sessions")
-        else:
-            logger.debug("All sessions closed successfully")
+@deprecated("Use mcp_use.client.client.MCPClient")
+class MCPClient(_MCPClient): ...

mcp_use/config.py

@@ -1,104 +1,27 @@
-"""
-Configuration loader for MCP session.
+# mcp_use/config.py
+import warnings
 
-This module provides functionality to load MCP configuration from JSON files.
-"""
+from typing_extensions import deprecated
 
-import json
-from typing import Any
+from mcp_use.client.config import (
+    create_connector_from_config as _create_connector_from_config,
+)
+from mcp_use.client.config import (
+    load_config_file as _load_config_file,
+)
 
-from mcp.client.session import ElicitationFnT, LoggingFnT, MessageHandlerFnT, SamplingFnT
+warnings.warn(
+    "mcp_use.config is deprecated. Use mcp_use.client.config. This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-from mcp_use.types.sandbox import SandboxOptions
 
-from .connectors import BaseConnector, HttpConnector, SandboxConnector, StdioConnector, WebSocketConnector
-from .connectors.utils import is_stdio_server
-from .middleware import Middleware
+@deprecated("Use mcp_use.client.config.load_config_file")
+def load_config_file(*args, **kwargs):
+    return _load_config_file(*args, **kwargs)
 
 
-def load_config_file(filepath: str) -> dict[str, Any]:
-    """Load a configuration file.
-
-    Args:
-        filepath: Path to the configuration file
-
-    Returns:
-        The parsed configuration
-    """
-    with open(filepath) as f:
-        return json.load(f)
-
-
-def create_connector_from_config(
-    server_config: dict[str, Any],
-    sandbox: bool = False,
-    sandbox_options: SandboxOptions | None = None,
-    sampling_callback: SamplingFnT | None = None,
-    elicitation_callback: ElicitationFnT | None = None,
-    message_handler: MessageHandlerFnT | None = None,
-    logging_callback: LoggingFnT | None = None,
-    middleware: list[Middleware] | 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
-        sandbox: Whether to use sandboxed execution mode for running MCP servers.
-        sandbox_options: Optional sandbox configuration options.
-        sampling_callback: Optional sampling callback function.
-    Returns:
-        A configured connector instance
-    """
-
-    # Stdio connector (command-based)
-    if is_stdio_server(server_config) and not sandbox:
-        return StdioConnector(
-            command=server_config["command"],
-            args=server_config["args"],
-            env=server_config.get("env", None),
-            sampling_callback=sampling_callback,
-            elicitation_callback=elicitation_callback,
-            message_handler=message_handler,
-            logging_callback=logging_callback,
-            middleware=middleware,
-        )
-
-    # Sandboxed connector
-    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=sandbox_options,
-            sampling_callback=sampling_callback,
-            elicitation_callback=elicitation_callback,
-            message_handler=message_handler,
-            logging_callback=logging_callback,
-            middleware=middleware,
-        )
-
-    # HTTP connector
-    elif "url" in server_config:
-        return HttpConnector(
-            base_url=server_config["url"],
-            headers=server_config.get("headers", None),
-            auth=server_config.get("auth", {}),
-            timeout=server_config.get("timeout", 5),
-            sse_read_timeout=server_config.get("sse_read_timeout", 60 * 5),
-            sampling_callback=sampling_callback,
-            elicitation_callback=elicitation_callback,
-            message_handler=message_handler,
-            logging_callback=logging_callback,
-            middleware=middleware,
-        )
-
-    # WebSocket connector
-    elif "ws_url" in server_config:
-        return WebSocketConnector(
-            url=server_config["ws_url"],
-            headers=server_config.get("headers", None),
-            auth=server_config.get("auth", {}),
-        )
-
-    raise ValueError("Cannot determine connector type from config")
+@deprecated("Use mcp_use.client.config.create_connector_from_config")
+def create_connector_from_config(*args, **kwargs):
+    return _create_connector_from_config(*args, **kwargs)

mcp_use/connectors/__init__.py

@@ -1,20 +1,46 @@
-"""
-Connectors for various MCP transports.
-
-This module provides interfaces for connecting to MCP implementations
-through different transport mechanisms.
-"""
-
-from .base import BaseConnector  # noqa: F401
-from .http import HttpConnector  # noqa: F401
-from .sandbox import SandboxConnector  # noqa: F401
-from .stdio import StdioConnector  # noqa: F401
-from .websocket import WebSocketConnector  # noqa: F401
-
-__all__ = [
-    "BaseConnector",
-    "StdioConnector",
-    "HttpConnector",
-    "WebSocketConnector",
-    "SandboxConnector",
-]
+# mcp_use/connectors/__init__.py
+import warnings
+
+from typing_extensions import deprecated
+
+from mcp_use.client.connectors import (
+    BaseConnector as _BaseConnector,
+)
+from mcp_use.client.connectors import (
+    HttpConnector as _HttpConnector,
+)
+from mcp_use.client.connectors import (
+    SandboxConnector as _SandboxConnector,
+)
+from mcp_use.client.connectors import (
+    StdioConnector as _StdioConnector,
+)
+from mcp_use.client.connectors import (
+    WebSocketConnector as _WebSocketConnector,
+)
+
+warnings.warn(
+    "mcp_use.connectors is deprecated. Use mcp_use.client.connectors. This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+
+@deprecated("Use mcp_use.client.connectors.BaseConnector")
+class BaseConnector(_BaseConnector): ...
+
+
+@deprecated("Use mcp_use.client.connectors.StdioConnector")
+class StdioConnector(_StdioConnector): ...
+
+
+@deprecated("Use mcp_use.client.connectors.HttpConnector")
+class HttpConnector(_HttpConnector): ...
+
+
+@deprecated("Use mcp_use.client.connectors.WebSocketConnector")
+class WebSocketConnector(_WebSocketConnector): ...
+
+
+@deprecated("Use mcp_use.client.connectors.SandboxConnector")
+class SandboxConnector(_SandboxConnector): ...