mcp-use 1.2.5__py3-none-any.whl → 1.2.6__py3-none-any.whl

mcp_use/adapters/__init__.py

@@ -1,5 +1,10 @@
 """
-MCP adapters for various frameworks.
+Adapters for converting MCP tools to different frameworks.
 
-This package contains adapters to convert MCP tools to different agent frameworks.
+This package provides adapters for converting MCP tools to different frameworks.
 """
+
+from .base import BaseAdapter
+from .langchain_adapter import LangChainAdapter
+
+__all__ = ["BaseAdapter", "LangChainAdapter"]

mcp_use/adapters/base.py

@@ -0,0 +1,178 @@
+"""
+Base adapter interface for MCP tools.
+
+This module provides the abstract base class that all MCP tool adapters should inherit from.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, TypeVar
+
+from ..client import MCPClient
+from ..connectors.base import BaseConnector
+from ..logging import logger
+
+# Generic type for the tools created by the adapter
+T = TypeVar("T")
+
+
+class BaseAdapter(ABC):
+    """Abstract base class for converting MCP tools to other framework formats.
+
+    This class defines the common interface that all adapter implementations
+    should follow to ensure consistency across different frameworks.
+    """
+
+    def __init__(self, disallowed_tools: list[str] | None = None) -> None:
+        """Initialize a new adapter.
+
+        Args:
+            disallowed_tools: list of tool names that should not be available.
+        """
+        self.disallowed_tools = disallowed_tools or []
+        self._connector_tool_map: dict[BaseConnector, list[T]] = {}
+
+    @classmethod
+    async def create_tools(
+        cls, client: "MCPClient", disallowed_tools: list[str] | None = None
+    ) -> list[T]:
+        """Create tools from an MCPClient instance.
+
+        This is the recommended way to create tools from an MCPClient, as it handles
+        session creation and connector extraction automatically.
+
+        Args:
+            client: The MCPClient to extract tools from.
+            disallowed_tools: Optional list of tool names to exclude.
+
+        Returns:
+            A list of tools in the target framework's format.
+
+        Example:
+            ```python
+            from mcp_use.client import MCPClient
+            from mcp_use.adapters import YourAdapter
+
+            client = MCPClient.from_config_file("config.json")
+            tools = await YourAdapter.create_tools(client)
+            ```
+        """
+        # Create the adapter
+        adapter = cls(disallowed_tools=disallowed_tools)
+
+        # Ensure we have active sessions
+        if not client.active_sessions:
+            logger.info("No active sessions found, creating new ones...")
+            await client.create_all_sessions()
+
+        # Get all active sessions
+        sessions = client.get_all_active_sessions()
+
+        # Extract connectors from sessions
+        connectors = [session.connector for session in sessions.values()]
+
+        # Create tools from connectors
+        return await adapter._create_tools_from_connectors(connectors)
+
+    async def load_tools_for_connector(self, connector: BaseConnector) -> list[T]:
+        """Dynamically load tools for a specific connector.
+
+        Args:
+            connector: The connector to load tools for.
+
+        Returns:
+            The list of tools that were loaded in the target framework's format.
+        """
+        # Check if we already have tools for this connector
+        if connector in self._connector_tool_map:
+            logger.debug(
+                f"Returning {len(self._connector_tool_map[connector])} existing tools for connector"
+            )
+            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 []
+
+        # 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
+            converted_tool = self._convert_tool(tool, connector)
+            if converted_tool:
+                connector_tools.append(converted_tool)
+
+        # Store the tools for this connector
+        self._connector_tool_map[connector] = connector_tools
+
+        # Log available tools for debugging
+        logger.debug(
+            f"Loaded {len(connector_tools)} new tools for connector: "
+            f"{[getattr(tool, 'name', str(tool)) for tool in connector_tools]}"
+        )
+
+        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.
+
+        Args:
+            mcp_tool: The MCP tool to convert.
+            connector: The connector that provides this tool.
+
+        Returns:
+            A tool in the target framework's format.
+        """
+        pass
+
+    async def _create_tools_from_connectors(self, connectors: list[BaseConnector]) -> list[T]:
+        """Create tools from MCP tools in all provided connectors.
+
+        Args:
+            connectors: list of MCP connectors to create tools from.
+
+        Returns:
+            A list of tools in the target framework's format.
+        """
+        tools = []
+        for connector in connectors:
+            # Create tools for this connector
+            connector_tools = await self.load_tools_for_connector(connector)
+            tools.extend(connector_tools)
+
+        # Log available tools for debugging
+        logger.debug(f"Available tools: {len(tools)}")
+        return tools
+
+    def _check_connector_initialized(self, connector: BaseConnector) -> bool:
+        """Check if a connector is initialized and has tools.
+
+        Args:
+            connector: The connector to check.
+
+        Returns:
+            True if the connector is initialized and has tools, False otherwise.
+        """
+        return hasattr(connector, "tools") and connector.tools
+
+    async def _ensure_connector_initialized(self, connector: BaseConnector) -> bool:
+        """Ensure a connector is initialized.
+
+        Args:
+            connector: The connector to initialize.
+
+        Returns:
+            True if initialization succeeded, False otherwise.
+        """
+        if not self._check_connector_initialized(connector):
+            logger.debug("Connector doesn't have tools, initializing it")
+            try:
+                await connector.initialize()
+                return True
+            except Exception as e:
+                logger.error(f"Error initializing connector: {e}")
+                return False
+        return True

mcp_use/adapters/langchain_adapter.py

@@ -13,65 +13,19 @@ from pydantic import BaseModel
 
 from ..connectors.base import BaseConnector
 from ..logging import logger
+from .base import BaseAdapter
 
 
-def _parse_mcp_tool_result(tool_result: CallToolResult) -> str:
-    """Parse the content of a CallToolResult into a string.
-
-    Args:
-        tool_result: The result object from calling an MCP tool.
-
-    Returns:
-        A string representation of the tool result content.
-
-    Raises:
-        ToolException: If the tool execution failed, returned no content,
-                       or contained unexpected content types.
-    """
-    if tool_result.isError:
-        raise ToolException(f"Tool execution failed: {tool_result.content}")
-
-    if not tool_result.content:
-        raise ToolException("Tool execution returned no content")
-
-    decoded_result = ""
-    for item in tool_result.content:
-        match item.type:
-            case "text":
-                item: TextContent
-                decoded_result += item.text
-            case "image":
-                item: ImageContent
-                decoded_result += item.data  # Assuming data is string-like or base64
-            case "resource":
-                resource: EmbeddedResource = item.resource
-                if hasattr(resource, "text"):
-                    decoded_result += resource.text
-                elif hasattr(resource, "blob"):
-                    # Assuming blob needs decoding or specific handling; adjust as needed
-                    decoded_result += (
-                        resource.blob.decode()
-                        if isinstance(resource.blob, bytes)
-                        else str(resource.blob)
-                    )
-                else:
-                    raise ToolException(f"Unexpected resource type: {resource.type}")
-            case _:
-                raise ToolException(f"Unexpected content type: {item.type}")
-
-    return decoded_result
-
-
-class LangChainAdapter:
+class LangChainAdapter(BaseAdapter):
     """Adapter for converting MCP tools to LangChain tools."""
 
     def __init__(self, disallowed_tools: list[str] | None = None) -> None:
         """Initialize a new LangChain adapter.
 
         Args:
-            disallowed_tools: List of tool names that should not be available.
+            disallowed_tools: list of tool names that should not be available.
         """
-        self.disallowed_tools = disallowed_tools or []
+        super().__init__(disallowed_tools)
         self._connector_tool_map: dict[BaseConnector, list[BaseTool]] = {}
 
     def fix_schema(self, schema: dict) -> dict:
@@ -91,122 +45,117 @@ class LangChainAdapter:
                 schema[key] = self.fix_schema(value)  # Apply recursively
         return schema
 
-    async def load_tools_for_connector(self, connector: BaseConnector) -> list[BaseTool]:
-        """Dynamically load tools for a specific connector.
+    def _parse_mcp_tool_result(self, tool_result: CallToolResult) -> str:
+        """Parse the content of a CallToolResult into a string.
+
+        Args:
+            tool_result: The result object from calling an MCP tool.
+
+        Returns:
+            A string representation of the tool result content.
+
+        Raises:
+            ToolException: If the tool execution failed, returned no content,
+                        or contained unexpected content types.
+        """
+        if tool_result.isError:
+            raise ToolException(f"Tool execution failed: {tool_result.content}")
+
+        if not tool_result.content:
+            raise ToolException("Tool execution returned no content")
+
+        decoded_result = ""
+        for item in tool_result.content:
+            match item.type:
+                case "text":
+                    item: TextContent
+                    decoded_result += item.text
+                case "image":
+                    item: ImageContent
+                    decoded_result += item.data  # Assuming data is string-like or base64
+                case "resource":
+                    resource: EmbeddedResource = item.resource
+                    if hasattr(resource, "text"):
+                        decoded_result += resource.text
+                    elif hasattr(resource, "blob"):
+                        # Assuming blob needs decoding or specific handling; adjust as needed
+                        decoded_result += (
+                            resource.blob.decode()
+                            if isinstance(resource.blob, bytes)
+                            else str(resource.blob)
+                        )
+                    else:
+                        raise ToolException(f"Unexpected resource type: {resource.type}")
+                case _:
+                    raise ToolException(f"Unexpected content type: {item.type}")
+
+        return decoded_result
+
+    def _convert_tool(self, mcp_tool: dict[str, Any], connector: BaseConnector) -> BaseTool:
+        """Convert an MCP tool to LangChain's tool format.
 
         Args:
-            connector: The connector to load tools for.
+            mcp_tool: The MCP tool to convert.
+            connector: The connector that provides this tool.
 
         Returns:
-            The list of tools that were loaded.
+            A LangChain BaseTool.
         """
-        # Check if we already have tools for this connector
-        if connector in self._connector_tool_map:
-            logger.debug(
-                f"Returning {len(self._connector_tool_map[connector])} existing tools for connector"
+        # Skip disallowed tools
+        if mcp_tool.name in self.disallowed_tools:
+            return None
+
+        # This is a dynamic class creation, we need to work with the self reference
+        adapter_self = self
+
+        class McpToLangChainAdapter(BaseTool):
+            name: str = mcp_tool.name or "NO NAME"
+            description: str = mcp_tool.description or ""
+            # Convert JSON schema to Pydantic model for argument validation
+            args_schema: type[BaseModel] = jsonschema_to_pydantic(
+                adapter_self.fix_schema(mcp_tool.inputSchema)  # Apply schema conversion
             )
-            return self._connector_tool_map[connector]
-
-        # Create tools for this connector
-        connector_tools = []
-
-        # Make sure the connector is initialized and has tools
-        if not hasattr(connector, "tools") or not connector.tools:
-            logger.debug("Connector doesn't have tools, initializing it")
-            try:
-                await connector.initialize()
-            except Exception as e:
-                logger.error(f"Error initializing connector: {e}")
-                return []
-
-        # Now create tools for each MCP tool
-        for tool in connector.tools:
-            # Skip disallowed tools
-            if tool.name in self.disallowed_tools:
-                continue
-
-            class McpToLangChainAdapter(BaseTool):
-                name: str = tool.name or "NO NAME"
-                description: str = tool.description or ""
-                # Convert JSON schema to Pydantic model for argument validation
-                args_schema: type[BaseModel] = jsonschema_to_pydantic(
-                    self.fix_schema(tool.inputSchema)  # Apply schema conversion
-                )
-                tool_connector: BaseConnector = connector  # Renamed variable to avoid name conflict
-                handle_tool_error: bool = True
-
-                def _run(self, **kwargs: Any) -> NoReturn:
-                    """Synchronous run method that always raises an error.
-
-                    Raises:
-                        NotImplementedError: Always raises this error because MCP tools
-                            only support async operations.
-                    """
-                    raise NotImplementedError("MCP tools only support async operations")
-
-                async def _arun(self, **kwargs: Any) -> Any:
-                    """Asynchronously execute the tool with given arguments.
-
-                    Args:
-                        kwargs: The arguments to pass to the tool.
-
-                    Returns:
-                        The result of the tool execution.
-
-                    Raises:
-                        ToolException: If tool execution fails.
-                    """
-                    logger.debug(f'MCP tool: "{self.name}" received input: {kwargs}')
+            tool_connector: BaseConnector = connector  # Renamed variable to avoid name conflict
+            handle_tool_error: bool = True
 
-                    try:
-                        tool_result: CallToolResult = await self.tool_connector.call_tool(
-                            self.name, kwargs
-                        )
-                        try:
-                            # Use the helper function to parse the result
-                            return _parse_mcp_tool_result(tool_result)
-                        except Exception as e:
-                            # Log the exception for debugging
-                            logger.error(f"Error parsing tool result: {e}")
-                            # Shortened line:
-                            return (
-                                f"Error parsing result: {e!s};"
-                                f" Raw content: {tool_result.content!r}"
-                            )
+            def _run(self, **kwargs: Any) -> NoReturn:
+                """Synchronous run method that always raises an error.
 
-                    except Exception as e:
-                        if self.handle_tool_error:
-                            return f"Error executing MCP tool: {str(e)}"
-                        raise
+                Raises:
+                    NotImplementedError: Always raises this error because MCP tools
+                        only support async operations.
+                """
+                raise NotImplementedError("MCP tools only support async operations")
 
-            connector_tools.append(McpToLangChainAdapter())
+            async def _arun(self, **kwargs: Any) -> Any:
+                """Asynchronously execute the tool with given arguments.
 
-        # Store the tools for this connector
-        self._connector_tool_map[connector] = connector_tools
+                Args:
+                    kwargs: The arguments to pass to the tool.
 
-        # Log available tools for debugging
-        logger.debug(
-            f"Loaded {len(connector_tools)} new tools for"
-            f" connector: {[tool.name for tool in connector_tools]}"
-        )
+                Returns:
+                    The result of the tool execution.
 
-        return connector_tools
+                Raises:
+                    ToolException: If tool execution fails.
+                """
+                logger.debug(f'MCP tool: "{self.name}" received input: {kwargs}')
 
-    async def create_langchain_tools(self, connectors: list[BaseConnector]) -> list[BaseTool]:
-        """Create LangChain tools from MCP tools.
+                try:
+                    tool_result: CallToolResult = await self.tool_connector.call_tool(
+                        self.name, kwargs
+                    )
+                    try:
+                        # Use the helper function to parse the result
+                        return adapter_self._parse_mcp_tool_result(tool_result)
+                    except Exception as e:
+                        # Log the exception for debugging
+                        logger.error(f"Error parsing tool result: {e}")
+                        return f"Error parsing result: {e!s}; Raw content: {tool_result.content!r}"
 
-        Args:
-            connectors: List of MCP connectors to create tools from.
+                except Exception as e:
+                    if self.handle_tool_error:
+                        return f"Error executing MCP tool: {str(e)}"
+                    raise
 
-        Returns:
-            A list of LangChain tools that wrap MCP tools.
-        """
-        tools = []
-        for connector in connectors:
-            # Create tools for this connector
-            connector_tools = await self.load_tools_for_connector(connector)
-            tools.extend(connector_tools)
-
-        # Log available tools for debugging
-        logger.debug(f"Available tools: {[tool.name for tool in tools]}")
-        return tools
+        return McpToLangChainAdapter()

mcp_use/agents/mcpagent.py

@@ -134,7 +134,10 @@ class MCPAgent:
                     logger.info("🔄 No active sessions found, creating new ones...")
                     self._sessions = await self.client.create_all_sessions()
                     logger.info(f"✅ Created {len(self._sessions)} new sessions")
-                connectors_to_use = [session.connector for session in self._sessions.values()]
+
+                # Create LangChain tools directly from the client using the adapter
+                self._tools = await self.adapter.create_tools(self.client)
+                logger.info(f"🛠️ Created {len(self._tools)} LangChain tools from client")
             else:
                 # Using direct connector - only establish connection
                 # LangChainAdapter will handle initialization
@@ -144,16 +147,16 @@ class MCPAgent:
                     if not hasattr(connector, "client") or connector.client is None:
                         await connector.connect()
 
-            tools = [tool for connector in connectors_to_use for tool in connector.tools]
-            logger.info(f"🧰 Found {len(tools)} tools across all connectors")
+                # Create LangChain tools using the adapter with connectors
+                self._tools = await self.adapter._create_tools_from_connectors(connectors_to_use)
+                logger.info(f"🛠️ Created {len(self._tools)} LangChain tools from connectors")
 
-            # Create the system message based on available tools
-            await self._create_system_message_from_tools(tools)
+            # Get all tools for system message generation
+            all_tools = self._tools
+            logger.info(f"🧰 Found {len(all_tools)} tools across all connectors")
 
-            # Create LangChain tools using the adapter
-            # (adapter will handle initialization if needed)
-            self._tools = await self.adapter.create_langchain_tools(connectors_to_use)
-            logger.info(f"🛠️ Created {len(self._tools)} LangChain tools")
+            # Create the system message based on available tools
+            await self._create_system_message_from_tools(all_tools)
 
         # Create the agent
         self._agent_executor = self._create_agent()
@@ -502,7 +505,7 @@ class MCPAgent:
             self._tools = []
 
             # If using client with session, close the session through client
-            if self.client and self._sessions:
+            if self.client:
                 logger.info("🔄 Closing sessions through client")
                 await self.client.close_all_sessions()
                 self._sessions = {}
@@ -512,6 +515,10 @@ class MCPAgent:
                     logger.info("🔄 Disconnecting connector")
                     await connector.disconnect()
 
+            # Clear adapter tool cache
+            if hasattr(self.adapter, "_connector_tool_map"):
+                self.adapter._connector_tool_map = {}
+
             self._initialized = False
             logger.info("👋 Agent closed successfully")
 

mcp_use/agents/server_manager.py

@@ -143,7 +143,9 @@ class ServerManager:
                     if session:
                         try:
                             connector = session.connector
-                            fetched_tools = await self.adapter.create_langchain_tools([connector])
+                            fetched_tools = await self.adapter._create_tools_from_connectors(
+                                [connector]
+                            )
                             self._server_tools[server_name] = fetched_tools  # Cache tools
                             self.initialized_servers[server_name] = True  # Mark as initialized
                             tools = fetched_tools
@@ -199,7 +201,7 @@ class ServerManager:
             # Initialize server tools if not already initialized
             if server_name not in self._server_tools:
                 connector = session.connector
-                self._server_tools[server_name] = await self.adapter.create_langchain_tools(
+                self._server_tools[server_name] = await self.adapter._create_tools_from_connectors(
                     [connector]
                 )
                 self.initialized_servers[server_name] = True

{mcp_use-1.2.5.dist-info → mcp_use-1.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.2.5
+Version: 1.2.6
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -69,6 +69,7 @@ Description-Content-Type: text/markdown
 | ⚙️ **Dynamic Server Selection** | Agents can dynamically choose the most appropriate MCP server for a given task from the available pool |
 | 🧩 **Multi-Server Support** | Use multiple MCP servers simultaneously in a single agent |
 | 🛡️ **Tool Restrictions** | Restrict potentially dangerous tools like file system or network access |
+| 🔧 **Custom Agents** | Build your own agents with any framework using the LangChain adapter or create new adapters |
 
 
 # Quick start
@@ -503,6 +504,41 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+# Build a Custom Agent:
+
+You can also build your own custom agent using the LangChain adapter:
+
+```python
+import asyncio
+from langchain_openai import ChatOpenAI
+from mcp_use.client import MCPClient
+from mcp_use.adapters.langchain_adapter import LangChainAdapter
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def main():
+    # Initialize MCP client
+    client = MCPClient.from_config_file("examples/browser_mcp.json")
+    llm = ChatOpenAI(model="gpt-4o")
+
+    # Create adapter instance
+    adapter = LangChainAdapter()
+    # Get LangChain tools with a single line
+    tools = await adapter.create_tools(client)
+
+    # Create a custom LangChain agent
+    llm_with_tools = llm.bind_tools(tools)
+    result = await llm_with_tools.ainvoke("What tools do you have avilable ? ")
+    print(result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+```
 
 # Debugging
 

{mcp_use-1.2.5.dist-info → mcp_use-1.2.6.dist-info}/RECORD

@@ -3,12 +3,13 @@ mcp_use/client.py,sha256=RoOOpCzMCjpqkkyAIEDOVc6Sn_HsET1rbn_J_J778q4,8278
 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/adapters/__init__.py,sha256=WUIU3WbMsjfMcZ7bJ8xVs3UkChge5zKam5DcKCRsayY,129
-mcp_use/adapters/langchain_adapter.py,sha256=cZmhgAQURziWHDCPjvX_tPc8CwYSUJx8kM9E_M9mji8,8150
+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=mbOkWHMgHJJNJYFXYLCk3JjIT0CRW_iiu5eZtxsWEmk,6309
 mcp_use/agents/__init__.py,sha256=7QCfjE9WA50r-W8CS7IzUZMuhLgm8xSuKH1kYWdFU64,324
 mcp_use/agents/base.py,sha256=bfuldi_89AbSbNc8KeTiCArRT9V62CNxHOWYkLHWjyA,1605
-mcp_use/agents/mcpagent.py,sha256=z7ZrFJDa6JF9Kr3tDomqPDm8PWhsybyQVjov_A3r7S0,23690
-mcp_use/agents/server_manager.py,sha256=-cfBgdzCGBM3U-jZMAwFXvH-PVIQ0TS3qZST882VxfQ,11239
+mcp_use/agents/mcpagent.py,sha256=kSNqmF728LrEYfzfvW8h8llqC877vJLcn-DJodYVucU,23988
+mcp_use/agents/server_manager.py,sha256=ShmjrvDtmU7dJtfVlw_srC3t5f_B-QtifzIiV4mfsRA,11315
 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
@@ -21,7 +22,7 @@ mcp_use/task_managers/base.py,sha256=ksNdxTwq8N-zqymxVoKGnWXq9iqkLYC61uB91o6Mh-4
 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.5.dist-info/METADATA,sha256=Iwsnx49WjUe81TPGSt5-SU1UePTWsu61rVngEwgxt3k,17178
-mcp_use-1.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_use-1.2.5.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-1.2.5.dist-info/RECORD,,
+mcp_use-1.2.6.dist-info/METADATA,sha256=wGaSC2X6TKK2-WUqmr7qupD_oc1l0IK_1Xrn09iLKiE,18156
+mcp_use-1.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.2.6.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.2.6.dist-info/RECORD,,