mcp-use 1.2.11__py3-none-any.whl → 1.2.13__py3-none-any.whl

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/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/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/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/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/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

mcp_use/task_managers/sse.py

@@ -66,12 +66,9 @@ class SseConnectionManager(ConnectionManager[tuple[Any, Any]]):
         # Return the streams
         return (read_stream, write_stream)
 
-    async def _close_connection(self, connection: tuple[Any, Any]) -> None:
-        """Close the SSE connection.
+    async def _close_connection(self) -> None:
+        """Close the SSE connection."""
 
-        Args:
-            connection: The connection to close (ignored, we use the context manager)
-        """
         if self._sse_ctx:
             # Exit the context manager
             try:

mcp_use/task_managers/stdio.py

@@ -57,12 +57,8 @@ class StdioConnectionManager(ConnectionManager[tuple[Any, Any]]):
         # Return the streams
         return (read_stream, write_stream)
 
-    async def _close_connection(self, connection: tuple[Any, Any]) -> None:
-        """Close the stdio connection.
-
-        Args:
-            connection: The connection to close (ignored, we use the context manager)
-        """
+    async def _close_connection(self) -> None:
+        """Close the stdio connection."""
         if self._stdio_ctx:
             # Exit the context manager
             try:

mcp_use/task_managers/websocket.py

@@ -4,14 +4,15 @@ WebSocket connection management for MCP implementations.
 This module provides a connection manager for WebSocket-based MCP connections.
 """
 
-import websockets
-from websockets.client import ClientConnection
+from typing import Any
+
+from mcp.client.websocket import websocket_client
 
 from ..logging import logger
 from .base import ConnectionManager
 
 
-class WebSocketConnectionManager(ConnectionManager[ClientConnection]):
+class WebSocketConnectionManager(ConnectionManager[tuple[Any, Any]]):
     """Connection manager for WebSocket-based MCP connections.
 
     This class handles the lifecycle of WebSocket connections, ensuring proper
@@ -21,19 +22,16 @@ class WebSocketConnectionManager(ConnectionManager[ClientConnection]):
     def __init__(
         self,
         url: str,
-        headers: dict[str, str] | None = None,
     ):
         """Initialize a new WebSocket connection manager.
 
         Args:
             url: The WebSocket URL to connect to
-            headers: Optional headers to include in the WebSocket connection
         """
         super().__init__()
         self.url = url
-        self.headers = headers or {}
 
-    async def _establish_connection(self) -> ClientConnection:
+    async def _establish_connection(self) -> tuple[Any, Any]:
         """Establish a WebSocket connection.
 
         Returns:
@@ -43,21 +41,23 @@ class WebSocketConnectionManager(ConnectionManager[ClientConnection]):
             Exception: If connection cannot be established
         """
         logger.debug(f"Connecting to WebSocket: {self.url}")
-        try:
-            ws = await websockets.connect(self.url, extra_headers=self.headers)
-            return ws
-        except Exception as e:
-            logger.error(f"Failed to connect to WebSocket: {e}")
-            raise
-
-    async def _close_connection(self, connection: ClientConnection) -> None:
-        """Close the WebSocket connection.
-
-        Args:
-            connection: The WebSocket connection to close
-        """
-        try:
-            logger.debug("Closing WebSocket connection")
-            await connection.close()
-        except Exception as e:
-            logger.warning(f"Error closing WebSocket connection: {e}")
+        # Create the context manager
+        self._ws_ctx = websocket_client(self.url)
+
+        # Enter the context manager
+        read_stream, write_stream = await self._ws_ctx.__aenter__()
+
+        # Return the streams
+        return (read_stream, write_stream)
+
+    async def _close_connection(self) -> None:
+        """Close the WebSocket connection."""
+        if self._ws_ctx:
+            # Exit the context manager
+            try:
+                logger.debug("Closing WebSocket connection")
+                await self._ws_ctx.__aexit__(None, None, None)
+            except Exception as e:
+                logger.warning(f"Error closing WebSocket connection: {e}")
+            finally:
+                self._ws_ctx = None

{mcp_use-1.2.11.dist-info → mcp_use-1.2.13.dist-info}/METADATA

@@ -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.dist-info → mcp_use-1.2.13.dist-info}/RECORD

@@ -1,18 +1,18 @@
 mcp_use/__init__.py,sha256=FikKagS6u8mugJOeslN3xfSA-tBLhjOywZSEcQ-y23g,1006
-mcp_use/client.py,sha256=hLaebFjVPiTDQbFnj6TN7hKctMXDFm-jqsQcQ5GaY0c,8320
+mcp_use/client.py,sha256=3mEiAtGlC28iv0zeEtQcMI6cfTlllyjSvS0dwuoVBrw,8317
 mcp_use/config.py,sha256=O9V4pa-shZ2mPokRTrd7KZQ2GpuTcYBGUslefl1fosw,1653
 mcp_use/logging.py,sha256=UhQdMx0H0q08-ZPjY_hAJVErkEUAkU1oahHqwdfdK_U,4274
-mcp_use/session.py,sha256=Z4EZTUnQUX0QyGMzkJIrMRTX4SDk6qQUoBld408LIJE,3449
+mcp_use/session.py,sha256=IPVzYASFMZx7-xpK4X_MR5chcsIwGvcs6vYXiO1hutM,2604
 mcp_use/adapters/__init__.py,sha256=-xCrgPThuX7x0PHGFDdjb7M-mgw6QV3sKu5PM7ShnRg,275
-mcp_use/adapters/base.py,sha256=ixLHXp8FWdyZPx7Kh6s-4jEVs3qT4DWrApSLXfqzNws,6141
-mcp_use/adapters/langchain_adapter.py,sha256=s8IHPPtqqXMmWQfeBqwESs3SZA6_ECSiGRwdTOIWki0,6417
+mcp_use/adapters/base.py,sha256=bPVjHERySX6Vw16mEmgFaJuy4Yc_sM8JPtOAqJrP6Rg,7164
+mcp_use/adapters/langchain_adapter.py,sha256=nrsOYDQu-nlLw14f2uNHM-pH8l-yQfZelWXZLhBSMeQ,11008
 mcp_use/agents/__init__.py,sha256=N3eVYP2PxqNO2KcQv5fY8UMUX2W3eLTNkkzuFIJ1DUA,261
 mcp_use/agents/base.py,sha256=bfuldi_89AbSbNc8KeTiCArRT9V62CNxHOWYkLHWjyA,1605
 mcp_use/agents/mcpagent.py,sha256=xZr-ihW5CW2wKAi0Gi-9GIXlJE0MGu-18xR8vi-Fu6Q,27025
 mcp_use/agents/prompts/system_prompt_builder.py,sha256=GH5Pvl49IBpKpZA9YTI83xMsdYSkRN_hw4LFHkKtxbg,4122
 mcp_use/agents/prompts/templates.py,sha256=AZKrGWuI516C-PmyOPvxDBibNdqJtN24sOHTGR06bi4,1933
 mcp_use/connectors/__init__.py,sha256=jnd-7pPPJMb0UNJ6aD9lInj5Tlamc8lA_mFyG8RWJpo,385
-mcp_use/connectors/base.py,sha256=5V8XHh3K-_zMBG22c6cxHynLyZps7M8FTIMt29OJa8o,5599
+mcp_use/connectors/base.py,sha256=uJFU80kIpr0bVRAHDXTWRziIwdb_5Yjf2HsDNokZw-M,7731
 mcp_use/connectors/http.py,sha256=2ZG5JxcK1WZ4jkTfTir6bEQLMxXBTPHyi0s42RHGeFs,2837
 mcp_use/connectors/stdio.py,sha256=MTzsqmVVihACUKngE-g5BignK3jAFds2CFv3aSzbJfs,2608
 mcp_use/connectors/websocket.py,sha256=LeU53YI3zjbwKq5GzFRziqA_z9Dn5qACiNyxWDrn2ns,9540
@@ -27,11 +27,11 @@ mcp_use/managers/tools/list_servers_tool.py,sha256=OPDSMNe-VuAhlUyhDnR4CiuZFpoMh
 mcp_use/managers/tools/search_tools.py,sha256=sT2fe66IyOeASTGjdTsjyzSpqkIGKLVXBF8wXUtWXd4,12055
 mcp_use/managers/tools/use_tool.py,sha256=r7k7uMYzrk353qw7M5h1utu_IR2G85uMZkrNcg2RyZA,6824
 mcp_use/task_managers/__init__.py,sha256=4dgW5N61iiPLpwjU2rrn_uqrL8mmDJFDaF9Lukzk65A,486
-mcp_use/task_managers/base.py,sha256=ksNdxTwq8N-zqymxVoKGnWXq9iqkLYC61uB91o6Mh-4,4888
-mcp_use/task_managers/sse.py,sha256=WysmjwqRI3meXMZY_F4y9tSBMvSiUZfTJQfitM5l6jQ,2529
-mcp_use/task_managers/stdio.py,sha256=DEISpXv4mo3d5a-WT8lkWbrXJwUh7QW0nMT_IM3fHGg,2269
-mcp_use/task_managers/websocket.py,sha256=ZbCqdGgzCRtsXzRGFws-f2OzH8cPAkN4sJNDwEpRmCc,1915
-mcp_use-1.2.11.dist-info/METADATA,sha256=HudT6j4l5spNbzm-JTfi-Eo3yfwf6fFeG4T1-lV-ZaE,20199
-mcp_use-1.2.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_use-1.2.11.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-1.2.11.dist-info/RECORD,,
+mcp_use/task_managers/base.py,sha256=xBrS9_GdlR0tr6sKN5pyMGUrQVGKRD6Qlk6hhOFcxRE,4806
+mcp_use/task_managers/sse.py,sha256=nLKt99OiqoJxFT62zCeNwSZUmdPPg4SD7M1pCEPOa3c,2391
+mcp_use/task_managers/stdio.py,sha256=MJcW03lUZUs_HEUxwFPaqy7m8QLbmdn6LagpcfZdjc8,2130
+mcp_use/task_managers/websocket.py,sha256=POB4YwCff6IJ0vj4eGpYqfDwLiqA0_fEUS4hbborGa4,1848
+mcp_use-1.2.13.dist-info/METADATA,sha256=Jhij8qlF_RqgiiRlVSVZYIlP6TgGYjcr3j_2LLSe0bo,20966
+mcp_use-1.2.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.2.13.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.2.13.dist-info/RECORD,,