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

mcp_use/connectors/stdio.py

@@ -1,109 +1,18 @@
-"""
-StdIO connector for MCP implementations.
+# mcp_use/connectors/stdio.py
+import warnings
 
-This module provides a connector for communicating with MCP implementations
-through the standard input/output streams.
-"""
+from typing_extensions import deprecated
 
-import sys
+from mcp_use.client.connectors.stdio import StdioConnector as _StdioConnector
 
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.session import ElicitationFnT, LoggingFnT, MessageHandlerFnT, SamplingFnT
+warnings.warn(
+    "mcp_use.connectors.stdio is deprecated. "
+    "Use mcp_use.client.connectors.stdio. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-from ..logging import logger
-from ..middleware import CallbackClientSession, Middleware
-from ..task_managers import StdioConnectionManager
-from .base import BaseConnector
 
-
-class StdioConnector(BaseConnector):
-    """Connector for MCP implementations using stdio transport.
-
-    This connector uses the stdio transport to communicate with MCP implementations
-    that are executed as child processes. It uses a connection manager to handle
-    the proper lifecycle management of the stdio client.
-    """
-
-    def __init__(
-        self,
-        command: str = "npx",
-        args: list[str] | None = None,
-        env: dict[str, str] | None = None,
-        errlog=sys.stderr,
-        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,
-    ):
-        """Initialize a new stdio connector.
-
-        Args:
-            command: The command to execute.
-            args: Optional command line arguments.
-            env: Optional environment variables.
-            errlog: Stream to write error output to.
-            sampling_callback: Optional callback to sample the client.
-            elicitation_callback: Optional callback to elicit the client.
-        """
-        super().__init__(
-            sampling_callback=sampling_callback,
-            elicitation_callback=elicitation_callback,
-            message_handler=message_handler,
-            logging_callback=logging_callback,
-            middleware=middleware,
-        )
-        self.command = command
-        self.args = args or []  # Ensure args is never None
-        self.env = env
-        self.errlog = errlog
-
-    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: {self.command}")
-        try:
-            # Create server parameters
-            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
-            raw_client_session = ClientSession(
-                read_stream,
-                write_stream,
-                sampling_callback=self.sampling_callback,
-                elicitation_callback=self.elicitation_callback,
-                message_handler=self._internal_message_handler,
-                logging_callback=self.logging_callback,
-                client_info=self.client_info,
-            )
-            await raw_client_session.__aenter__()
-
-            # Wrap with middleware
-            self.client_session = CallbackClientSession(
-                raw_client_session, self.public_identifier, self.middleware_manager
-            )
-
-            # Mark as connected
-            self._connected = True
-            logger.debug(f"Successfully connected to MCP implementation: {self.command}")
-
-        except Exception as e:
-            logger.error(f"Failed to connect to MCP implementation: {e}")
-
-            # Clean up any resources if connection failed
-            await self._cleanup_resources()
-
-            # Re-raise the original exception
-            raise
-
-    @property
-    def public_identifier(self) -> str:
-        """Get the identifier for the connector."""
-        return f"stdio:{self.command} {' '.join(self.args)}"
+@deprecated("Use mcp_use.client.connectors.stdio.StdioConnector")
+class StdioConnector(_StdioConnector): ...

mcp_use/connectors/utils.py

@@ -1,13 +1,20 @@
+# mcp_use/connectors/utils.py
+import warnings
 from typing import Any
 
+from typing_extensions import deprecated
 
-def is_stdio_server(server_config: dict[str, Any]) -> bool:
-    """Check if the server configuration is for a stdio server.
+from mcp_use.client.connectors.utils import is_stdio_server as _is_stdio_server
+
+warnings.warn(
+    "mcp_use.connectors.utils is deprecated. "
+    "Use mcp_use.client.connectors.utils. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-    Args:
-        server_config: The server configuration section
 
-    Returns:
-        True if the server is a stdio server, False otherwise
-    """
-    return "command" in server_config and "args" in server_config
+@deprecated("Use mcp_use.client.connectors.utils.is_stdio_server")
+def is_stdio_server(server_config: dict[str, Any]) -> bool:
+    return _is_stdio_server(server_config)

mcp_use/connectors/websocket.py

@@ -1,257 +1,18 @@
-"""
-WebSocket connector for MCP implementations.
+# mcp_use/connectors/websocket.py
+import warnings
 
-This module provides a connector for communicating with MCP implementations
-through WebSocket connections.
-"""
+from typing_extensions import deprecated
 
-import asyncio
-import json
-import uuid
-from typing import Any
+from mcp_use.client.connectors.websocket import WebSocketConnector as _WebSocketConnector
 
-import httpx
-from mcp.types import Tool
-from websockets import ClientConnection
+warnings.warn(
+    "mcp_use.connectors.websocket is deprecated. "
+    "Use mcp_use.client.connectors.websocket. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-from ..logging import logger
-from ..task_managers import ConnectionManager, WebSocketConnectionManager
-from .base import BaseConnector
 
-
-class WebSocketConnector(BaseConnector):
-    """Connector for MCP implementations using WebSocket transport.
-
-    This connector uses WebSockets to communicate with remote MCP implementations,
-    using a connection manager to handle the proper lifecycle management.
-    """
-
-    def __init__(
-        self,
-        url: str,
-        headers: dict[str, str] | None = None,
-        auth: str | dict[str, Any] | httpx.Auth | None = None,
-    ):
-        """Initialize a new WebSocket connector.
-
-        Args:
-            url: The WebSocket URL to connect to.
-            headers: Optional additional headers.
-            auth: Authentication method - can be:
-                - A string token: Use Bearer token authentication
-                - A dict: Not supported for WebSocket (will log warning)
-                - An httpx.Auth object: Not supported for WebSocket (will log warning)
-        """
-        self.url = url
-        self.headers = headers or {}
-
-        # Handle authentication - WebSocket only supports bearer tokens
-        # An auth field it's not needed
-        if auth is not None:
-            if isinstance(auth, str):
-                self.headers["Authorization"] = f"Bearer {auth}"
-            else:
-                logger.warning("WebSocket connector only supports bearer token authentication")
-
-        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] = {}
-        self._tools: list[Tool] | None = None
-        self._connected = False
-
-    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 WebSocket: {self.url}")
-        try:
-            # Create and start the connection manager
-            self._connection_manager = WebSocketConnectionManager(self.url, self.headers)
-            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")
-
-            # Mark as connected
-            self._connected = True
-            logger.debug(f"Successfully connected to MCP implementation via WebSocket: {self.url}")
-
-        except Exception as e:
-            logger.error(f"Failed to connect to MCP implementation via WebSocket: {e}")
-
-            # Clean up any resources if connection failed
-            await self._cleanup_resources()
-
-            # Re-raise the original exception
-            raise
-
-    async def _receive_messages(self) -> None:
-        """Continuously receive and process messages from the WebSocket."""
-        if not self.ws:
-            raise RuntimeError("WebSocket is not connected")
-
-        try:
-            async for message in self.ws:
-                # Parse the message
-                data = json.loads(message)
-
-                # Check if this is a response to a pending request
-                request_id = data.get("id")
-                if request_id and request_id in self.pending_requests:
-                    future = self.pending_requests.pop(request_id)
-                    if "result" in data:
-                        future.set_result(data["result"])
-                    elif "error" in data:
-                        future.set_exception(Exception(data["error"]))
-
-                    logger.debug(f"Received response for request {request_id}")
-                else:
-                    logger.debug(f"Received message: {data}")
-        except Exception as e:
-            logger.error(f"Error in WebSocket message receiver: {e}")
-            # If the websocket connection was closed or errored,
-            # reject all pending requests
-            for future in self.pending_requests.values():
-                if not future.done():
-                    future.set_exception(e)
-
-    async def disconnect(self) -> None:
-        """Close the connection to the MCP implementation."""
-        if not self._connected:
-            logger.debug("Not connected to MCP implementation")
-            return
-
-        logger.debug("Disconnecting from MCP implementation")
-        await self._cleanup_resources()
-        self._connected = False
-        logger.debug("Disconnected from MCP implementation")
-
-    async def _cleanup_resources(self) -> None:
-        """Clean up all resources associated with this connector."""
-        errors = []
-
-        # First cancel the receiver task
-        if self._receiver_task and not self._receiver_task.done():
-            try:
-                logger.debug("Cancelling WebSocket receiver task")
-                self._receiver_task.cancel()
-                try:
-                    await self._receiver_task
-                except asyncio.CancelledError:
-                    logger.debug("WebSocket receiver task cancelled successfully")
-                except Exception as e:
-                    logger.warning(f"Error during WebSocket receiver task cancellation: {e}")
-            except Exception as e:
-                error_msg = f"Error cancelling WebSocket receiver task: {e}"
-                logger.warning(error_msg)
-                errors.append(error_msg)
-            finally:
-                self._receiver_task = None
-
-        # Reject any pending requests
-        if self.pending_requests:
-            logger.debug(f"Rejecting {len(self.pending_requests)} pending requests")
-            for future in self.pending_requests.values():
-                if not future.done():
-                    future.set_exception(ConnectionError("WebSocket disconnected"))
-            self.pending_requests.clear()
-
-        # Then stop the connection manager
-        if self._connection_manager:
-            try:
-                logger.debug("Stopping connection manager")
-                await self._connection_manager.stop()
-            except Exception as e:
-                error_msg = f"Error stopping connection manager: {e}"
-                logger.warning(error_msg)
-                errors.append(error_msg)
-            finally:
-                self._connection_manager = None
-                self.ws = None
-
-        # Reset tools
-        self._tools = None
-
-        if errors:
-            logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
-
-    async def _send_request(self, method: str, params: dict[str, Any] | None = None) -> Any:
-        """Send a request and wait for a response."""
-        if not self.ws:
-            raise RuntimeError("WebSocket is not connected")
-
-        # Create a request ID
-        request_id = str(uuid.uuid4())
-
-        # Create a future to receive the response
-        future = asyncio.Future()
-        self.pending_requests[request_id] = future
-
-        # Send the request
-        await self.ws.send(json.dumps({"id": request_id, "method": method, "params": params or {}}))
-
-        logger.debug(f"Sent request {request_id} method: {method}")
-
-        # Wait for the response
-        try:
-            return await future
-        except Exception as e:
-            # Remove the request from pending requests
-            self.pending_requests.pop(request_id, None)
-            logger.error(f"Error waiting for response to request {request_id}: {e}")
-            raise
-
-    async def initialize(self) -> dict[str, Any]:
-        """Initialize the MCP session and return session information."""
-        logger.debug("Initializing MCP session")
-        result = await self._send_request("initialize")
-
-        # Get available tools
-        tools_result = await self.list_tools()
-        self._tools = [Tool(**tool) for tool in tools_result]
-
-        logger.debug(f"MCP session initialized with {len(self._tools)} tools")
-        return result
-
-    async def list_tools(self) -> list[dict[str, Any]]:
-        """List all available tools from the MCP implementation."""
-        logger.debug("Listing tools")
-        result = await self._send_request("tools/list")
-        return result.get("tools", [])
-
-    @property
-    def tools(self) -> list[Tool]:
-        """Get the list of available tools."""
-        if not self._tools:
-            raise RuntimeError("MCP client is not initialized")
-        return self._tools
-
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
-        """Call an MCP tool with the given arguments."""
-        logger.debug(f"Calling tool '{name}' with arguments: {arguments}")
-        return await self._send_request("tools/call", {"name": name, "arguments": arguments})
-
-    async def list_resources(self) -> list[dict[str, Any]]:
-        """List all available resources from the MCP implementation."""
-        logger.debug("Listing resources")
-        result = await self._send_request("resources/list")
-        return result
-
-    async def read_resource(self, uri: str) -> tuple[bytes, str]:
-        """Read a resource by URI."""
-        logger.debug(f"Reading resource: {uri}")
-        result = await self._send_request("resources/read", {"uri": uri})
-        return result.get("content", b""), result.get("mimeType", "")
-
-    async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
-        """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 f"websocket:{self.url}"
+@deprecated("Use mcp_use.client.connectors.websocket.WebSocketConnector")
+class WebSocketConnector(_WebSocketConnector): ...

mcp_use/exceptions.py

@@ -1,31 +1,46 @@
-"""MCP-use exceptions."""
+# mcp_use/exceptions.py
+import warnings
 
+from typing_extensions import deprecated
 
-class MCPError(Exception):
-    """Base exception for MCP-use."""
+from mcp_use.client.exceptions import (
+    ConfigurationError as _ConfigurationError,
+)
+from mcp_use.client.exceptions import (
+    ConnectionError as _ConnectionError,
+)
+from mcp_use.client.exceptions import (
+    MCPError as _MCPError,
+)
+from mcp_use.client.exceptions import (
+    OAuthAuthenticationError as _OAuthAuthenticationError,
+)
+from mcp_use.client.exceptions import (
+    OAuthDiscoveryError as _OAuthDiscoveryError,
+)
 
-    pass
+warnings.warn(
+    "mcp_use.exceptions is deprecated. Use mcp_use.client.exceptions. This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
 
-class OAuthDiscoveryError(MCPError):
-    """OAuth discovery auth metadata error"""
+@deprecated("Use mcp_use.client.exceptions.MCPError")
+class MCPError(_MCPError): ...
 
-    pass
 
+@deprecated("Use mcp_use.client.exceptions.OAuthDiscoveryError")
+class OAuthDiscoveryError(_OAuthDiscoveryError): ...
 
-class OAuthAuthenticationError(MCPError):
-    """OAuth authentication-related errors"""
 
-    pass
+@deprecated("Use mcp_use.client.exceptions.OAuthAuthenticationError")
+class OAuthAuthenticationError(_OAuthAuthenticationError): ...
 
 
-class ConnectionError(MCPError):
-    """Connection-related errors."""
+@deprecated("Use mcp_use.client.exceptions.ConnectionError")
+class ConnectionError(_ConnectionError): ...
 
-    pass
 
-
-class ConfigurationError(MCPError):
-    """Configuration-related errors."""
-
-    pass
+@deprecated("Use mcp_use.client.exceptions.ConfigurationError")
+class ConfigurationError(_ConfigurationError): ...

mcp_use/managers/__init__.py

@@ -1,19 +1,58 @@
-from .server_manager import ServerManager
-from .tools import (
-    ConnectServerTool,
-    DisconnectServerTool,
-    GetActiveServerTool,
-    ListServersTool,
-    MCPServerTool,
-    SearchToolsTool,
+# mcp_use/managers/__init__.py
+import warnings
+
+from typing_extensions import deprecated
+
+from mcp_use.agents.managers.server_manager import ServerManager as _ServerManager
+from mcp_use.agents.managers.tools import (
+    ConnectServerTool as _ConnectServerTool,
+)
+from mcp_use.agents.managers.tools import (
+    DisconnectServerTool as _DisconnectServerTool,
+)
+from mcp_use.agents.managers.tools import (
+    GetActiveServerTool as _GetActiveServerTool,
+)
+from mcp_use.agents.managers.tools import (
+    ListServersTool as _ListServersTool,
+)
+from mcp_use.agents.managers.tools import (
+    MCPServerTool as _MCPServerTool,
 )
+from mcp_use.agents.managers.tools import (
+    SearchToolsTool as _SearchToolsTool,
+)
+
+warnings.warn(
+    "mcp_use.managers is deprecated. Use mcp_use.agents.managers. This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+
+@deprecated("Use mcp_use.agents.managers.server_manager.ServerManager")
+class ServerManager(_ServerManager): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.MCPServerTool")
+class MCPServerTool(_MCPServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.ConnectServerTool")
+class ConnectServerTool(_ConnectServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.DisconnectServerTool")
+class DisconnectServerTool(_DisconnectServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.GetActiveServerTool")
+class GetActiveServerTool(_GetActiveServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.ListServersTool")
+class ListServersTool(_ListServersTool): ...
+
 
-__all__ = [
-    "ServerManager",
-    "MCPServerTool",
-    "ConnectServerTool",
-    "DisconnectServerTool",
-    "GetActiveServerTool",
-    "ListServersTool",
-    "SearchToolsTool",
-]
+@deprecated("Use mcp_use.agents.managers.tools.SearchToolsTool")
+class SearchToolsTool(_SearchToolsTool): ...

mcp_use/managers/base.py

@@ -1,36 +1,18 @@
-from abc import ABC, abstractmethod
+# mcp_use/managers/base.py
+import warnings
 
-from langchain_core.tools import BaseTool
+from typing_extensions import deprecated
 
+from mcp_use.agents.managers.base import BaseServerManager as _BaseServerManager
 
-class BaseServerManager(ABC):
-    """Abstract base class for server managers.
+warnings.warn(
+    "mcp_use.managers.base is deprecated. "
+    "Use mcp_use.agents.managers.base. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-    This class defines the interface for server managers that can be used with MCPAgent.
-    Custom server managers should inherit from this class and implement the required methods.
-    """
 
-    @abstractmethod
-    async def initialize(self) -> None:
-        """Initialize the server manager."""
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def tools(self) -> list[BaseTool]:
-        """Get all server management tools and tools from the active server.
-
-        Returns:
-            list of LangChain tools for server management plus tools from active server
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def has_tool_changes(self, current_tool_names: set[str]) -> bool:
-        """Check if the available tools have changed.
-        Args:
-            current_tool_names: Set of currently known tool names
-        Returns:
-            True if tools have changed, False otherwise
-        """
-        raise NotImplementedError
+@deprecated("Use mcp_use.agents.managers.base.BaseServerManager")
+class BaseServerManager(_BaseServerManager): ...