mcp-use 1.2.11__tar.gz → 1.2.13__tar.gz

{mcp_use-1.2.11 → mcp_use-1.2.13}/.github/workflows/publish.yml

@@ -1,11 +1,12 @@
 name: Check Version Bump and Publish to PyPI
 
 on:
-  push:
+  workflow_run:
+    workflows: ["Python Tests"]
     branches:
       - main
-    paths:
-      - 'pyproject.toml'
+    types:
+      - completed
 
 # Required for PyPI trusted publishing
 permissions:
@@ -14,11 +15,14 @@ permissions:
 
 jobs:
   check-version-and-publish:
+    # Only proceed if the referenced workflow completed successfully
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
         with:
-          fetch-depth: 0  # This fetches all history for comparing versions
+          fetch-depth: 0
+          ref: ${{ github.event.workflow_run.head_sha }}
 
       - name: Set up Python
         uses: actions/setup-python@v4

mcp_use-1.2.11/.github/workflows/tests.yml → mcp_use-1.2.13/.github/workflows/unittests.yml

@@ -28,4 +28,4 @@ jobs:
           ruff check .
       - name: Test with pytest
         run: |
-          pytest
+          pytest tests/unit

{mcp_use-1.2.11 → mcp_use-1.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.2.11
+Version: 1.2.13
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -39,23 +39,39 @@ Provides-Extra: search
 Requires-Dist: fastembed>=0.0.1; extra == 'search'
 Description-Content-Type: text/markdown
 
-<picture>
-  <img alt="" src="./static/image.jpg"  width="full">
-</picture>
+<div align="center" style="margin: 0 auto; max-width: 80%;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="static/logo_white.svg">
+    <source media="(prefers-color-scheme: light)" srcset="static/logo_black.svg">
+    <img alt="mcp use logo" src="./static/logo-white.svg" width="80%" style="margin: 20px auto;">
+  </picture>
+</div>
 
 <h1 align="center">Unified MCP Client Library </h1>
-
-[![](https://img.shields.io/pypi/dw/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![PyPI Downloads](https://img.shields.io/pypi/dm/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![PyPI Version](https://img.shields.io/pypi/v/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![Python Versions](https://img.shields.io/pypi/pyversions/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![Documentation](https://img.shields.io/badge/docs-mcp--use.io-blue)](https://docs.mcp-use.io)
-[![Website](https://img.shields.io/badge/website-mcp--use.io-blue)](https://mcp-use.io)
-[![License](https://img.shields.io/github/license/pietrozullo/mcp-use)](https://github.com/pietrozullo/mcp-use/blob/main/LICENSE)
-[![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
-[![GitHub stars](https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social)](https://github.com/pietrozullo/mcp-use/stargazers)
-[![Twitter Follow](https://img.shields.io/twitter/follow/Pietro?style=social)](https://x.com/pietrozullo)
-
+<p align="center">
+    <a href="https://pypi.org/project/mcp_use/" alt="PyPI Version">
+        <img src="https://img.shields.io/pypi/v/mcp_use.svg"/></a>
+    <a href="https://pypi.org/project/mcp_use/" alt="PyPI Downloads">
+        <img src="https://static.pepy.tech/badge/mcp-use" /></a>
+    <a href="https://pypi.org/project/mcp_use/" alt="Python Versions">
+        <img src="https://img.shields.io/pypi/pyversions/mcp_use.svg" /></a>
+    <a href="https://docs.mcp-use.io" alt="Documentation">
+        <img src="https://img.shields.io/badge/docs-mcp--use.io-blue" /></a>
+    <a href="https://mcp-use.io" alt="Website">
+        <img src="https://img.shields.io/badge/website-mcp--use.io-blue" /></a>
+    <a href="https://github.com/pietrozullo/mcp-use/blob/main/LICENSE" alt="License">
+        <img src="https://img.shields.io/github/license/pietrozullo/mcp-use" /></a>
+    <a href="https://github.com/astral-sh/ruff" alt="Code style: Ruff">
+        <img src="https://img.shields.io/badge/code%20style-ruff-000000.svg" /></a>
+    <a href="https://github.com/pietrozullo/mcp-use/stargazers" alt="GitHub stars">
+        <img src="https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social" /></a>
+    </p>
+    <p align="center">
+    <a href="https://x.com/pietrozullo" alt="Twitter Follow">
+        <img src="https://img.shields.io/twitter/follow/Pietro?style=social" /></a>
+    <a href="https://discord.gg/XkNkSkMz3V" alt="Discord">
+        <img src="https://dcbadge.limes.pink/api/server/https://discord.gg/XkNkSkMz3V?style=flat" /></a>
+</p>
 🌐 MCP-Use is the open source way to connect **any LLM to any MCP server** and build custom agents that have tool access, without using closed source or application clients.
 
 💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.

{mcp_use-1.2.11 → mcp_use-1.2.13}/README.md

@@ -1,20 +1,36 @@
-<picture>
-  <img alt="" src="./static/image.jpg"  width="full">
-</picture>
+<div align="center" style="margin: 0 auto; max-width: 80%;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="static/logo_white.svg">
+    <source media="(prefers-color-scheme: light)" srcset="static/logo_black.svg">
+    <img alt="mcp use logo" src="./static/logo-white.svg" width="80%" style="margin: 20px auto;">
+  </picture>
+</div>
 
 <h1 align="center">Unified MCP Client Library </h1>
-
-[![](https://img.shields.io/pypi/dw/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![PyPI Downloads](https://img.shields.io/pypi/dm/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![PyPI Version](https://img.shields.io/pypi/v/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![Python Versions](https://img.shields.io/pypi/pyversions/mcp_use.svg)](https://pypi.org/project/mcp_use/)
-[![Documentation](https://img.shields.io/badge/docs-mcp--use.io-blue)](https://docs.mcp-use.io)
-[![Website](https://img.shields.io/badge/website-mcp--use.io-blue)](https://mcp-use.io)
-[![License](https://img.shields.io/github/license/pietrozullo/mcp-use)](https://github.com/pietrozullo/mcp-use/blob/main/LICENSE)
-[![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
-[![GitHub stars](https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social)](https://github.com/pietrozullo/mcp-use/stargazers)
-[![Twitter Follow](https://img.shields.io/twitter/follow/Pietro?style=social)](https://x.com/pietrozullo)
-
+<p align="center">
+    <a href="https://pypi.org/project/mcp_use/" alt="PyPI Version">
+        <img src="https://img.shields.io/pypi/v/mcp_use.svg"/></a>
+    <a href="https://pypi.org/project/mcp_use/" alt="PyPI Downloads">
+        <img src="https://static.pepy.tech/badge/mcp-use" /></a>
+    <a href="https://pypi.org/project/mcp_use/" alt="Python Versions">
+        <img src="https://img.shields.io/pypi/pyversions/mcp_use.svg" /></a>
+    <a href="https://docs.mcp-use.io" alt="Documentation">
+        <img src="https://img.shields.io/badge/docs-mcp--use.io-blue" /></a>
+    <a href="https://mcp-use.io" alt="Website">
+        <img src="https://img.shields.io/badge/website-mcp--use.io-blue" /></a>
+    <a href="https://github.com/pietrozullo/mcp-use/blob/main/LICENSE" alt="License">
+        <img src="https://img.shields.io/github/license/pietrozullo/mcp-use" /></a>
+    <a href="https://github.com/astral-sh/ruff" alt="Code style: Ruff">
+        <img src="https://img.shields.io/badge/code%20style-ruff-000000.svg" /></a>
+    <a href="https://github.com/pietrozullo/mcp-use/stargazers" alt="GitHub stars">
+        <img src="https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social" /></a>
+    </p>
+    <p align="center">
+    <a href="https://x.com/pietrozullo" alt="Twitter Follow">
+        <img src="https://img.shields.io/twitter/follow/Pietro?style=social" /></a>
+    <a href="https://discord.gg/XkNkSkMz3V" alt="Discord">
+        <img src="https://dcbadge.limes.pink/api/server/https://discord.gg/XkNkSkMz3V?style=flat" /></a>
+</p>
 🌐 MCP-Use is the open source way to connect **any LLM to any MCP server** and build custom agents that have tool access, without using closed source or application clients.
 
 💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.

{mcp_use-1.2.11 → mcp_use-1.2.13}/mcp_use/adapters/base.py

@@ -5,7 +5,9 @@ This module provides the abstract base class that all MCP tool adapters should i
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, TypeVar
+from typing import TypeVar
+
+from mcp.types import Prompt, Resource, Tool
 
 from ..client import MCPClient
 from ..connectors.base import BaseConnector
@@ -90,13 +92,13 @@ class BaseAdapter(ABC):
             return self._connector_tool_map[connector]
 
         # Create tools for this connector
-        connector_tools = []
 
         # Make sure the connector is initialized and has tools
         success = await self._ensure_connector_initialized(connector)
         if not success:
             return []
 
+        connector_tools = []
         # Now create tools for each MCP tool
         for tool in connector.tools:
             # Convert the tool and add it to the list if conversion was successful
@@ -104,6 +106,23 @@ class BaseAdapter(ABC):
             if converted_tool:
                 connector_tools.append(converted_tool)
 
+        # Convert resources to tools so that agents can access resource content directly
+        resources_list = connector.resources or []
+        if resources_list:
+            for resource in resources_list:
+                converted_resource = self._convert_resource(resource, connector)
+                if converted_resource:
+                    connector_tools.append(converted_resource)
+
+        # Convert prompts to tools so that agents can retrieve prompt content
+        prompts_list = connector.prompts or []
+        if prompts_list:
+            for prompt in prompts_list:
+                converted_prompt = self._convert_prompt(prompt, connector)
+                if converted_prompt:
+                    connector_tools.append(converted_prompt)
+        # ------------------------------
+
         # Store the tools for this connector
         self._connector_tool_map[connector] = connector_tools
 
@@ -116,16 +135,18 @@ class BaseAdapter(ABC):
         return connector_tools
 
     @abstractmethod
-    def _convert_tool(self, mcp_tool: dict[str, Any], connector: BaseConnector) -> T:
-        """Convert an MCP tool to the target framework's tool format.
+    def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> T:
+        """Convert an MCP tool to the target framework's tool format."""
+        pass
 
-        Args:
-            mcp_tool: The MCP tool to convert.
-            connector: The connector that provides this tool.
+    @abstractmethod
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> T:
+        """Convert an MCP resource to the target framework's resource format."""
+        pass
 
-        Returns:
-            A tool in the target framework's format.
-        """
+    @abstractmethod
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> T:
+        """Convert an MCP prompt to the target framework's prompt format."""
         pass
 
     async def _create_tools_from_connectors(self, connectors: list[BaseConnector]) -> list[T]:

{mcp_use-1.2.11 → mcp_use-1.2.13}/mcp_use/adapters/langchain_adapter.py

@@ -4,12 +4,21 @@ LangChain adapter for MCP tools.
 This module provides utilities to convert MCP tools to LangChain tools.
 """
 
+import re
 from typing import Any, NoReturn
 
 from jsonschema_pydantic import jsonschema_to_pydantic
 from langchain_core.tools import BaseTool, ToolException
-from mcp.types import CallToolResult, EmbeddedResource, ImageContent, TextContent
-from pydantic import BaseModel
+from mcp.types import (
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    Prompt,
+    ReadResourceRequestParams,
+    Resource,
+    TextContent,
+)
+from pydantic import BaseModel, Field, create_model
 
 from ..connectors.base import BaseConnector
 from ..logging import logger
@@ -162,3 +171,104 @@ class LangChainAdapter(BaseAdapter):
                     raise
 
         return McpToLangChainAdapter()
+
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> BaseTool:
+        """Convert an MCP resource to LangChain's tool format.
+
+        Each resource becomes an async tool that returns its content when called.
+        The tool takes **no** arguments because the resource URI is fixed.
+        """
+
+        def _sanitize(name: str) -> str:
+            return re.sub(r"[^A-Za-z0-9_]+", "_", name).lower().strip("_")
+
+        class ResourceTool(BaseTool):
+            name: str = _sanitize(mcp_resource.name or f"resource_{mcp_resource.uri}")
+            description: str = (
+                mcp_resource.description
+                or f"Return the content of the resource located at URI {mcp_resource.uri}."
+            )
+            args_schema: type[BaseModel] = ReadResourceRequestParams
+            tool_connector: BaseConnector = connector
+            handle_tool_error: bool = True
+
+            def _run(self, **kwargs: Any) -> NoReturn:
+                raise NotImplementedError("Resource tools only support async operations")
+
+            async def _arun(self, **kwargs: Any) -> Any:
+                logger.debug(f'Resource tool: "{self.name}" called')
+                try:
+                    result = await self.tool_connector.read_resource(mcp_resource.uri)
+                    for content in result.contents:
+                        # Attempt to decode bytes if necessary
+                        if isinstance(content, bytes):
+                            content_decoded = content.decode()
+                        else:
+                            content_decoded = str(content)
+
+                    return content_decoded
+                except Exception as e:
+                    if self.handle_tool_error:
+                        return f"Error reading resource: {str(e)}"
+                    raise
+
+        return ResourceTool()
+
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> BaseTool:
+        """Convert an MCP prompt to LangChain's tool format.
+
+        The resulting tool executes `get_prompt` on the connector with the prompt's name and
+        the user-provided arguments (if any). The tool returns the decoded prompt content.
+        """
+        prompt_arguments = mcp_prompt.arguments
+
+        # Sanitize the prompt name to create a valid Python identifier for the model name
+        base_model_name = re.sub(r"[^a-zA-Z0-9_]", "_", mcp_prompt.name)
+        if not base_model_name or base_model_name[0].isdigit():
+            base_model_name = "PromptArgs_" + base_model_name
+        dynamic_model_name = f"{base_model_name}_InputSchema"
+
+        if prompt_arguments:
+            field_definitions_for_create: dict[str, Any] = {}
+            for arg in prompt_arguments:
+                param_type: type = getattr(arg, "type", str)
+                if arg.required:
+                    field_definitions_for_create[arg.name] = (
+                        param_type,
+                        Field(description=arg.description),
+                    )
+                else:
+                    field_definitions_for_create[arg.name] = (
+                        param_type | None,
+                        Field(None, description=arg.description),
+                    )
+
+            InputSchema = create_model(
+                dynamic_model_name, **field_definitions_for_create, __base__=BaseModel
+            )
+        else:
+            # Create an empty Pydantic model if there are no arguments
+            InputSchema = create_model(dynamic_model_name, __base__=BaseModel)
+
+        class PromptTool(BaseTool):
+            name: str = mcp_prompt.name
+            description: str = mcp_prompt.description
+
+            args_schema: type[BaseModel] = InputSchema
+            tool_connector: BaseConnector = connector
+            handle_tool_error: bool = True
+
+            def _run(self, **kwargs: Any) -> NoReturn:
+                raise NotImplementedError("Prompt tools only support async operations")
+
+            async def _arun(self, **kwargs: Any) -> Any:
+                logger.debug(f'Prompt tool: "{self.name}" called with args: {kwargs}')
+                try:
+                    result = await self.tool_connector.get_prompt(self.name, kwargs)
+                    return result.messages
+                except Exception as e:
+                    if self.handle_tool_error:
+                        return f"Error fetching prompt: {str(e)}"
+                    raise
+
+        return PromptTool()

{mcp_use-1.2.11 → mcp_use-1.2.13}/mcp_use/client.py

@@ -6,6 +6,7 @@ and sessions from configuration.
 """
 
 import json
+import warnings
 from typing import Any
 
 from .config import create_connector_from_config, load_config_file
@@ -115,12 +116,12 @@ class MCPClient:
             The created MCPSession.
 
         Raises:
-            ValueError: If no servers are configured or the specified server doesn't exist.
+            ValueError: If the specified server doesn't exist.
         """
         # Get server config
         servers = self.config.get("mcpServers", {})
         if not servers:
-            logger.warning("No MCP servers defined in config")
+            warnings.warn("No MCP servers defined in config", UserWarning, stacklevel=2)
             return None
 
         if server_name not in servers:
@@ -153,13 +154,13 @@ class MCPClient:
         Returns:
             The created MCPSession. If server_name is None, returns the first created session.
 
-        Raises:
-            ValueError: If no servers are configured or the specified server doesn't exist.
+        Warns:
+            Warning: If no servers are configured.
         """
         # Get server config
         servers = self.config.get("mcpServers", {})
         if not servers:
-            logger.warning("No MCP servers defined in config")
+            warnings.warn("No MCP servers defined in config", UserWarning, stacklevel=2)
             return {}
 
         # Create sessions for all servers

{mcp_use-1.2.11 → mcp_use-1.2.13}/mcp_use/connectors/base.py

@@ -9,7 +9,8 @@ from abc import ABC, abstractmethod
 from typing import Any
 
 from mcp import ClientSession
-from mcp.types import CallToolResult, Tool
+from mcp.shared.exceptions import McpError
+from mcp.types import CallToolResult, GetPromptResult, Prompt, ReadResourceResult, Resource, Tool
 
 from ..logging import logger
 from ..task_managers import ConnectionManager
@@ -26,6 +27,8 @@ class BaseConnector(ABC):
         self.client: 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
 
     @abstractmethod
@@ -74,6 +77,8 @@ class BaseConnector(ABC):
 
         # Reset tools
         self._tools = None
+        self._resources = None
+        self._prompts = None
 
         if errors:
             logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
@@ -88,21 +93,58 @@ class BaseConnector(ABC):
         # Initialize the session
         result = await self.client.initialize()
 
-        # Get available tools
-        tools_result = await self.client.list_tools()
-        self._tools = tools_result.tools
-
-        logger.debug(f"MCP session initialized with {len(self._tools)} tools")
+        server_capabilities = result.capabilities
+
+        if server_capabilities.tools:
+            # Get available tools
+            tools_result = await self.list_tools()
+            self._tools = tools_result or []
+        else:
+            self._tools = []
+
+        if server_capabilities.resources:
+            # Get available resources
+            resources_result = await self.list_resources()
+            self._resources = resources_result or []
+        else:
+            self._resources = []
+
+        if server_capabilities.prompts:
+            # Get available prompts
+            prompts_result = await self.list_prompts()
+            self._prompts = prompts_result or []
+        else:
+            self._prompts = []
+
+        logger.debug(
+            f"MCP session initialized with {len(self._tools)} tools, "
+            f"{len(self._resources)} resources, "
+            f"and {len(self._prompts)} prompts"
+        )
 
         return result
 
     @property
     def tools(self) -> list[Tool]:
         """Get the list of available tools."""
-        if not self._tools:
+        if self._tools is None:
             raise RuntimeError("MCP client is not initialized")
         return self._tools
 
+    @property
+    def resources(self) -> list[Resource]:
+        """Get the list of available resources."""
+        if self._resources is None:
+            raise RuntimeError("MCP client is not initialized")
+        return self._resources
+
+    @property
+    def prompts(self) -> list[Prompt]:
+        """Get the list of available prompts."""
+        if self._prompts is None:
+            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:
@@ -113,43 +155,64 @@ class BaseConnector(ABC):
         logger.debug(f"Tool '{name}' called with result: {result}")
         return result
 
-    async def list_resources(self) -> list[dict[str, Any]]:
+    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")
+
+        logger.debug("Listing tools")
+        try:
+            result = await self.client.list_tools()
+            return result.tools
+        except McpError as e:
+            logger.error(f"Error listing tools: {e}")
+            return []
+
+    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")
 
         logger.debug("Listing resources")
-        resources = await self.client.list_resources()
-        return resources
-
-    async def read_resource(self, uri: str) -> tuple[bytes, str]:
+        try:
+            result = await self.client.list_resources()
+            return result.resources
+        except McpError as e:
+            logger.error(f"Error listing resources: {e}")
+            return []
+
+    async def read_resource(self, uri: str) -> ReadResourceResult:
         """Read a resource by URI."""
         if not self.client:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug(f"Reading resource: {uri}")
-        resource = await self.client.read_resource(uri)
-        return resource.content, resource.mimeType
+        result = await self.client.read_resource(uri)
+        return result
 
-    async def list_prompts(self) -> list[dict[str, Any]]:
+    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")
 
         logger.debug("Listing prompts")
-        prompts = await self.client.list_prompts()
-        return prompts
+        try:
+            result = await self.client.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
-    ) -> tuple[bytes, str]:
+    ) -> GetPromptResult:
         """Get a prompt by name."""
         if not self.client:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug(f"Getting prompt: {name}")
-        prompt = await self.client.get_prompt(name, arguments)
-        return prompt
+        result = await self.client.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."""

{mcp_use-1.2.11 → mcp_use-1.2.13}/mcp_use/session.py

@@ -7,6 +7,8 @@ which handles authentication, initialization, and tool discovery.
 
 from typing import Any
 
+from mcp.types import Tool
+
 from .connectors.base import BaseConnector
 
 
@@ -30,7 +32,7 @@ class MCPSession:
         """
         self.connector = connector
         self.session_info: dict[str, Any] | None = None
-        self.tools: list[dict[str, Any]] = []
+        self.tools: list[Tool] = []
         self.auto_connect = auto_connect
 
     async def __aenter__(self) -> "MCPSession":
@@ -73,9 +75,6 @@ class MCPSession:
         # Initialize the session
         self.session_info = await self.connector.initialize()
 
-        # Discover available tools
-        await self.discover_tools()
-
         return self.session_info
 
     @property
@@ -86,28 +85,3 @@ class MCPSession:
             True if the connector is connected, False otherwise.
         """
         return hasattr(self.connector, "client") and self.connector.client is not None
-
-    async def discover_tools(self) -> list[dict[str, Any]]:
-        """Discover available tools from the MCP implementation.
-
-        Returns:
-            The list of available tools in MCP format.
-        """
-        self.tools = self.connector.tools
-        return self.tools
-
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
-        """Call an MCP tool with the given arguments.
-
-        Args:
-            name: The name of the tool to call.
-            arguments: The arguments to pass to the tool.
-
-        Returns:
-            The result of the tool call.
-        """
-        # Make sure we're connected
-        if not self.is_connected and self.auto_connect:
-            await self.connect()
-
-        return await self.connector.call_tool(name, arguments)

{mcp_use-1.2.11 → mcp_use-1.2.13}/mcp_use/task_managers/base.py

@@ -46,14 +46,12 @@ class ConnectionManager(Generic[T], ABC):
         pass
 
     @abstractmethod
-    async def _close_connection(self, connection: T) -> None:
+    async def _close_connection(self) -> None:
         """Close the connection.
 
         This method should be implemented by subclasses to close
         the specific type of connection.
 
-        Args:
-            connection: The connection to close.
         """
         pass
 
@@ -139,10 +137,10 @@ class ConnectionManager(Generic[T], ABC):
             self._ready_event.set()
 
         finally:
-            # Close the connection if it was established
+            # Close the connection if it was establishedSUPABASE_URL
             if self._connection is not None:
                 try:
-                    await self._close_connection(self._connection)
+                    await self._close_connection()
                 except Exception as e:
                     logger.warning(f"Error closing connection in {self.__class__.__name__}: {e}")
                 self._connection = None