mcp-use 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

mcp_use/managers/tools/use_tool.py

@@ -30,9 +30,7 @@ class UseToolFromServerTool(MCPServerTool):
     )
     args_schema: ClassVar[type[BaseModel]] = UseToolInput
 
-    async def _arun(
-        self, server_name: str, tool_name: str, tool_input: dict[str, Any] | str
-    ) -> str:
+    async def _arun(self, server_name: str, tool_name: str, tool_input: dict[str, Any] | str) -> str:
         """Execute a tool from a specific server."""
         # Check if server exists
         servers = self.server_manager.client.get_server_names()
@@ -78,20 +76,14 @@ class UseToolFromServerTool(MCPServerTool):
 
         if not target_tool:
             tool_names = [t.name for t in server_tools]
-            return (
-                f"Tool '{tool_name}' not found on server '{server_name}'. "
-                f"Available tools: {', '.join(tool_names)}"
-            )
+            return f"Tool '{tool_name}' not found on server '{server_name}'. Available tools: {', '.join(tool_names)}"
 
         # Execute the tool with the provided input
         try:
             # Parse the input based on target tool's schema
             structured_input = self._parse_tool_input(target_tool, tool_input)
             if structured_input is None:
-                return (
-                    f"Could not parse input for tool '{tool_name}'."
-                    " Please check the input format and try again."
-                )
+                return f"Could not parse input for tool '{tool_name}'. Please check the input format and try again."
 
             # Store the previous active server
             previous_active = self.server_manager.active_server
@@ -100,10 +92,7 @@ class UseToolFromServerTool(MCPServerTool):
             self.server_manager.active_server = server_name
 
             # Execute the tool
-            logger.info(
-                f"Executing tool '{tool_name}' on server '{server_name}'"
-                "with input: {structured_input}"
-            )
+            logger.info(f"Executing tool '{tool_name}' on server '{server_name}'with input: {{structured_input}}")
             result = await target_tool._arun(**structured_input)
 
             # Restore the previous active server
@@ -162,6 +151,4 @@ class UseToolFromServerTool(MCPServerTool):
 
     def _run(self, server_name: str, tool_name: str, tool_input: dict[str, Any] | str) -> str:
         """Synchronous version that raises a NotImplementedError."""
-        raise NotImplementedError(
-            "UseToolFromServerTool requires async execution. Use _arun instead."
-        )
+        raise NotImplementedError("UseToolFromServerTool requires async execution. Use _arun instead.")

mcp_use/observability/__init__.py

@@ -0,0 +1,8 @@
+from dotenv import load_dotenv
+
+# Load environment variables once for all observability modules
+load_dotenv()
+
+from . import laminar, langfuse  # noqa
+
+__all__ = ["laminar", "langfuse"]

mcp_use/observability/laminar.py

@@ -0,0 +1,21 @@
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# Check if Laminar is disabled via environment variable
+_laminar_disabled = os.getenv("MCP_USE_LAMINAR", "").lower() == "false"
+
+# Only initialize if not disabled and API key is present
+if _laminar_disabled:
+    logger.debug("Laminar tracing disabled via MCP_USE_LAMINAR environment variable")
+elif not os.getenv("LAMINAR_PROJECT_API_KEY"):
+    logger.debug("Laminar API key not found - tracing disabled. Set LAMINAR_PROJECT_API_KEY to enable")
+else:
+    try:
+        from lmnr import Laminar
+
+        Laminar.initialize(project_api_key=os.getenv("LAMINAR_PROJECT_API_KEY"))
+        logger.debug("Laminar observability initialized successfully")
+    except ImportError:
+        logger.debug("Laminar package not installed - tracing disabled. Install with: pip install lmnr")

mcp_use/observability/langfuse.py

@@ -0,0 +1,35 @@
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# Check if Langfuse is disabled via environment variable
+_langfuse_disabled = os.getenv("MCP_USE_LANGFUSE", "").lower() == "false"
+
+# Only initialize if not disabled and required keys are present
+if _langfuse_disabled:
+    logger.debug("Langfuse tracing disabled via MCP_USE_LANGFUSE environment variable")
+    langfuse = None
+    langfuse_handler = None
+elif not os.getenv("LANGFUSE_PUBLIC_KEY") or not os.getenv("LANGFUSE_SECRET_KEY"):
+    logger.debug(
+        "Langfuse API keys not found - tracing disabled. Set LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY to enable"
+    )
+    langfuse = None
+    langfuse_handler = None
+else:
+    try:
+        from langfuse import Langfuse
+        from langfuse.langchain import CallbackHandler
+
+        langfuse = Langfuse(
+            public_key=os.getenv("LANGFUSE_PUBLIC_KEY"),
+            secret_key=os.getenv("LANGFUSE_SECRET_KEY"),
+            host=os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com"),
+        )
+        langfuse_handler = CallbackHandler()
+        logger.debug("Langfuse observability initialized successfully")
+    except ImportError:
+        logger.debug("Langfuse package not installed - tracing disabled. Install with: pip install langfuse")
+        langfuse = None
+        langfuse_handler = None

mcp_use/telemetry/telemetry.py

@@ -0,0 +1,306 @@
+import logging
+import os
+import platform
+import uuid
+from collections.abc import Callable
+from functools import wraps
+from pathlib import Path
+from typing import Any
+
+from posthog import Posthog
+from scarf import ScarfEventLogger
+
+from mcp_use.logging import MCP_USE_DEBUG
+from mcp_use.telemetry.events import (
+    BaseTelemetryEvent,
+    MCPAgentExecutionEvent,
+)
+from mcp_use.telemetry.utils import get_package_version
+from mcp_use.utils import singleton
+
+logger = logging.getLogger(__name__)
+
+
+def requires_telemetry(func: Callable) -> Callable:
+    """Decorator that skips function execution if telemetry is disabled"""
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        if not self._posthog_client and not self._scarf_client:
+            return None
+        return func(self, *args, **kwargs)
+
+    return wrapper
+
+
+def get_cache_home() -> Path:
+    """Get platform-appropriate cache directory."""
+    # XDG_CACHE_HOME for Linux and manually set envs
+    env_var: str | None = os.getenv("XDG_CACHE_HOME")
+    if env_var and (path := Path(env_var)).is_absolute():
+        return path
+
+    system = platform.system()
+    if system == "Windows":
+        appdata = os.getenv("LOCALAPPDATA") or os.getenv("APPDATA")
+        if appdata:
+            return Path(appdata)
+        return Path.home() / "AppData" / "Local"
+    elif system == "Darwin":  # macOS
+        return Path.home() / "Library" / "Caches"
+    else:  # Linux or other Unix
+        return Path.home() / ".cache"
+
+
+@singleton
+class Telemetry:
+    """
+    Service for capturing anonymized telemetry data via PostHog and Scarf.
+    If the environment variable `MCP_USE_ANONYMIZED_TELEMETRY=false`, telemetry will be disabled.
+    """
+
+    USER_ID_PATH = str(get_cache_home() / "mcp_use_3" / "telemetry_user_id")
+    VERSION_DOWNLOAD_PATH = str(get_cache_home() / "mcp_use" / "download_version")
+    PROJECT_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI"
+    HOST = "https://eu.i.posthog.com"
+    SCARF_GATEWAY_URL = "https://mcpuse.gateway.scarf.sh/events"
+    UNKNOWN_USER_ID = "UNKNOWN_USER_ID"
+
+    _curr_user_id = None
+
+    def __init__(self):
+        telemetry_disabled = os.getenv("MCP_USE_ANONYMIZED_TELEMETRY", "true").lower() == "false"
+
+        if telemetry_disabled:
+            self._posthog_client = None
+            self._scarf_client = None
+            logger.debug("Telemetry disabled")
+        else:
+            logger.info("Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable.")
+
+            # Initialize PostHog
+            try:
+                self._posthog_client = Posthog(
+                    project_api_key=self.PROJECT_API_KEY,
+                    host=self.HOST,
+                    disable_geoip=False,
+                    enable_exception_autocapture=True,
+                )
+
+                # Silence posthog's logging unless debug mode (level 2)
+                if MCP_USE_DEBUG < 2:
+                    posthog_logger = logging.getLogger("posthog")
+                    posthog_logger.disabled = True
+
+            except Exception as e:
+                logger.warning(f"Failed to initialize PostHog telemetry: {e}")
+                self._posthog_client = None
+
+            # Initialize Scarf
+            try:
+                self._scarf_client = ScarfEventLogger(
+                    endpoint_url=self.SCARF_GATEWAY_URL,
+                    timeout=3.0,
+                    verbose=MCP_USE_DEBUG >= 2,
+                )
+
+                # Silence scarf's logging unless debug mode (level 2)
+                if MCP_USE_DEBUG < 2:
+                    scarf_logger = logging.getLogger("scarf")
+                    scarf_logger.disabled = True
+
+            except Exception as e:
+                logger.warning(f"Failed to initialize Scarf telemetry: {e}")
+                self._scarf_client = None
+
+    @property
+    def user_id(self) -> str:
+        """Get or create a persistent anonymous user ID"""
+        if self._curr_user_id:
+            return self._curr_user_id
+
+        try:
+            is_first_time = not os.path.exists(self.USER_ID_PATH)
+
+            if is_first_time:
+                logger.debug(f"Creating user ID path: {self.USER_ID_PATH}")
+                os.makedirs(os.path.dirname(self.USER_ID_PATH), exist_ok=True)
+                with open(self.USER_ID_PATH, "w") as f:
+                    new_user_id = str(uuid.uuid4())
+                    f.write(new_user_id)
+                self._curr_user_id = new_user_id
+
+                logger.debug(f"User ID path created: {self.USER_ID_PATH}")
+            else:
+                with open(self.USER_ID_PATH) as f:
+                    self._curr_user_id = f.read().strip()
+
+            # Always check for version-based download tracking
+            self.track_package_download(
+                {
+                    "triggered_by": "user_id_property",
+                }
+            )
+        except Exception as e:
+            logger.debug(f"Failed to get/create user ID: {e}")
+            self._curr_user_id = self.UNKNOWN_USER_ID
+
+        return self._curr_user_id
+
+    @requires_telemetry
+    def capture(self, event: BaseTelemetryEvent) -> None:
+        """Capture a telemetry event"""
+        # Send to PostHog
+        if self._posthog_client:
+            try:
+                # Add package version to all events
+                properties = event.properties.copy()
+                properties["mcp_use_version"] = get_package_version()
+
+                self._posthog_client.capture(distinct_id=self.user_id, event=event.name, properties=properties)
+            except Exception as e:
+                logger.debug(f"Failed to track PostHog event {event.name}: {e}")
+
+        # Send to Scarf
+        if self._scarf_client:
+            try:
+                # Add package version and user_id to all events
+                properties = {}
+                properties["mcp_use_version"] = get_package_version()
+                properties["user_id"] = self.user_id
+                properties["event"] = event.name
+
+                # Convert complex types to simple types for Scarf compatibility
+                self._scarf_client.log_event(properties=properties)
+            except Exception as e:
+                logger.debug(f"Failed to track Scarf event {event.name}: {e}")
+
+    @requires_telemetry
+    def track_package_download(self, properties: dict[str, Any] | None = None) -> None:
+        """Track package download event specifically for Scarf analytics"""
+        if self._scarf_client:
+            try:
+                current_version = get_package_version()
+                should_track = False
+                first_download = False
+
+                # Check if version file exists
+                if not os.path.exists(self.VERSION_DOWNLOAD_PATH):
+                    # First download
+                    should_track = True
+                    first_download = True
+
+                    # Create directory and save version
+                    os.makedirs(os.path.dirname(self.VERSION_DOWNLOAD_PATH), exist_ok=True)
+                    with open(self.VERSION_DOWNLOAD_PATH, "w") as f:
+                        f.write(current_version)
+                else:
+                    # Read saved version
+                    with open(self.VERSION_DOWNLOAD_PATH) as f:
+                        saved_version = f.read().strip()
+
+                    # Compare versions (simple string comparison for now)
+                    if current_version > saved_version:
+                        should_track = True
+                        first_download = False
+
+                        # Update saved version
+                        with open(self.VERSION_DOWNLOAD_PATH, "w") as f:
+                            f.write(current_version)
+
+                if should_track:
+                    logger.debug(f"Tracking package download event with properties: {properties}")
+                    # Add package version and user_id to event
+                    event_properties = (properties or {}).copy()
+                    event_properties["mcp_use_version"] = current_version
+                    event_properties["user_id"] = self.user_id
+                    event_properties["event"] = "package_download"
+                    event_properties["first_download"] = first_download
+
+                    # Convert complex types to simple types for Scarf compatibility
+                    self._scarf_client.log_event(properties=event_properties)
+            except Exception as e:
+                logger.debug(f"Failed to track Scarf package_download event: {e}")
+
+    @requires_telemetry
+    def track_agent_execution(
+        self,
+        execution_method: str,
+        query: str,
+        success: bool,
+        model_provider: str,
+        model_name: str,
+        server_count: int,
+        server_identifiers: list[dict[str, str]],
+        total_tools_available: int,
+        tools_available_names: list[str],
+        max_steps_configured: int,
+        memory_enabled: bool,
+        use_server_manager: bool,
+        max_steps_used: int | None,
+        manage_connector: bool,
+        external_history_used: bool,
+        steps_taken: int | None = None,
+        tools_used_count: int | None = None,
+        tools_used_names: list[str] | None = None,
+        response: str | None = None,
+        execution_time_ms: int | None = None,
+        error_type: str | None = None,
+        conversation_history_length: int | None = None,
+    ) -> None:
+        """Track comprehensive agent execution"""
+        event = MCPAgentExecutionEvent(
+            execution_method=execution_method,
+            query=query,
+            success=success,
+            model_provider=model_provider,
+            model_name=model_name,
+            server_count=server_count,
+            server_identifiers=server_identifiers,
+            total_tools_available=total_tools_available,
+            tools_available_names=tools_available_names,
+            max_steps_configured=max_steps_configured,
+            memory_enabled=memory_enabled,
+            use_server_manager=use_server_manager,
+            max_steps_used=max_steps_used,
+            manage_connector=manage_connector,
+            external_history_used=external_history_used,
+            steps_taken=steps_taken,
+            tools_used_count=tools_used_count,
+            tools_used_names=tools_used_names,
+            response=response,
+            execution_time_ms=execution_time_ms,
+            error_type=error_type,
+            conversation_history_length=conversation_history_length,
+        )
+        self.capture(event)
+
+    @requires_telemetry
+    def flush(self) -> None:
+        """Flush any queued telemetry events"""
+        # Flush PostHog
+        if self._posthog_client:
+            try:
+                self._posthog_client.flush()
+                logger.debug("PostHog client telemetry queue flushed")
+            except Exception as e:
+                logger.debug(f"Failed to flush PostHog client: {e}")
+
+        # Scarf events are sent immediately, no flush needed
+        if self._scarf_client:
+            logger.debug("Scarf telemetry events sent immediately (no flush needed)")
+
+    @requires_telemetry
+    def shutdown(self) -> None:
+        """Shutdown telemetry clients and flush remaining events"""
+        # Shutdown PostHog
+        if self._posthog_client:
+            try:
+                self._posthog_client.shutdown()
+                logger.debug("PostHog client shutdown successfully")
+            except Exception as e:
+                logger.debug(f"Error shutting down PostHog client: {e}")
+
+        # Scarf doesn't require explicit shutdown
+        if self._scarf_client:
+            logger.debug("Scarf telemetry client shutdown (no action needed)")

{mcp_use-1.3.1.dist-info → mcp_use-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.3.1
+Version: 1.3.2
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -15,6 +15,9 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: anyio>=4.0.0
+Requires-Dist: authlib>=1.5.2
+Requires-Dist: httpx>=0.28.1
 Requires-Dist: jsonschema-pydantic>=0.1.0
 Requires-Dist: langchain-community>=0.0.10
 Requires-Dist: langchain>=0.1.0
@@ -22,10 +25,13 @@ Requires-Dist: mcp>=1.9.3
 Requires-Dist: posthog>=4.8.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: scarf-sdk>=0.1.0
+Requires-Dist: starlette>=0.41.0
 Requires-Dist: typing-extensions>=4.8.0
+Requires-Dist: uvicorn>=0.32.0
 Requires-Dist: websockets>=12.0
 Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.15.0; extra == 'anthropic'
+Requires-Dist: langchain-anthropic; extra == 'anthropic'
 Provides-Extra: dev
 Requires-Dist: black>=23.9.0; extra == 'dev'
 Requires-Dist: fastmcp; extra == 'dev'
@@ -38,7 +44,7 @@ Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Provides-Extra: e2b
 Requires-Dist: e2b-code-interpreter>=1.5.0; extra == 'e2b'
 Provides-Extra: openai
-Requires-Dist: openai>=1.10.0; extra == 'openai'
+Requires-Dist: langchain-openai; extra == 'openai'
 Provides-Extra: search
 Requires-Dist: fastembed>=0.0.1; extra == 'search'
 Description-Content-Type: text/markdown
@@ -76,7 +82,7 @@ Description-Content-Type: text/markdown
     <a href="https://x.com/pederzh" alt="Twitter Follow - Luigi">
         <img src="https://img.shields.io/twitter/follow/Luigi?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>
+        <img src="https://dcbadge.limes.pink/api/server/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.
 

mcp_use-1.3.2.dist-info/RECORD

@@ -0,0 +1,49 @@
+mcp_use/__init__.py,sha256=I3gFxw6Id45RksUBIZS1kxBW3ItjFXuAfoReJabpnW0,1055
+mcp_use/client.py,sha256=sAyZY6n5XHRW5dWKinfMZ-ovnUYi0s4u7T1mFfEHGLs,9476
+mcp_use/config.py,sha256=jRjTVNMxi7pkqFHMJhzSWpwukE4PbdYU8Pe_IZ33sYI,2433
+mcp_use/logging.py,sha256=CRtkPwR-bkXK_kQ0QOL86RikMWOHzEOi7A8VRHkNsZw,4270
+mcp_use/session.py,sha256=4kwcB_IkTt_3FiBSTI1H17KhL1W_6N5oai3HTxFrTH4,2496
+mcp_use/utils.py,sha256=QavJcVq2WxUUUCCpPCUeOB5bqIS0FFmpK-RAZkGc6aA,720
+mcp_use/adapters/__init__.py,sha256=-xCrgPThuX7x0PHGFDdjb7M-mgw6QV3sKu5PM7ShnRg,275
+mcp_use/adapters/base.py,sha256=tX5vNcz1HZtim4aID_KTfCeI6mQ6qI3bywTWJv0HaZs,7120
+mcp_use/adapters/langchain_adapter.py,sha256=LdlpRyLORhl8NZvtAmisgPelXkhEbBErSNdGHb8SF18,10860
+mcp_use/agents/__init__.py,sha256=N3eVYP2PxqNO2KcQv5fY8UMUX2W3eLTNkkzuFIJ1DUA,261
+mcp_use/agents/base.py,sha256=EN-dRbwOi9vIqofFg3jmi5yT2VKlwEr9Cwi1DZgB3eE,1591
+mcp_use/agents/mcpagent.py,sha256=7AsU8NE7vWmtTp2N2t1N0j4D-gxBFpBlC3XAjyVULWE,31297
+mcp_use/agents/prompts/system_prompt_builder.py,sha256=E86STmxcl2Ic763_114awNqFB2RyLrQlbvgRmJajQjI,4116
+mcp_use/agents/prompts/templates.py,sha256=AZKrGWuI516C-PmyOPvxDBibNdqJtN24sOHTGR06bi4,1933
+mcp_use/connectors/__init__.py,sha256=cUF4yT0bNr8qeLkSzg28SHueiV5qDaHEB1l1GZ2K0dc,536
+mcp_use/connectors/base.py,sha256=yajYF5P924VzggCJ-kt37Rh_srCu__Seb7KUBhjvFdQ,12255
+mcp_use/connectors/http.py,sha256=Aw0DVQN-7fYebDKuX3bvlH9GAFS7Mq9CM_HylXdNqEI,6274
+mcp_use/connectors/sandbox.py,sha256=Id6THKdBvPxFzOFJ2tSK300CiiRFE_EtN5Gu6NRfUTU,10870
+mcp_use/connectors/stdio.py,sha256=rnJoLaHf1cIjk1KqfxfSsUs-iGTJ7KZonxgIc3kXeCM,2791
+mcp_use/connectors/utils.py,sha256=zQ8GdNQx0Twz3by90BoU1RsWPf9wODGof4K3-NxPXeA,366
+mcp_use/connectors/websocket.py,sha256=G7ZeLJNPVl9AG6kCmiNJz1N2Ing_QxT7pSswigTKi8Y,9650
+mcp_use/managers/__init__.py,sha256=rzsJbOhtlmxNQLGcdmtmHaiExEXmiQiUuzPrAgKhAJw,439
+mcp_use/managers/server_manager.py,sha256=Ag1EUSxkG6-UG004vcvaZarPoDnUUMMX7BUeKReUWRI,3704
+mcp_use/managers/tools/__init__.py,sha256=JrA5iTRdtbgwROJE8pQ7GH1sYnqBRcgj4NzFVADKbQ4,510
+mcp_use/managers/tools/base_tool.py,sha256=Jbbp7SwmHKDk8jT_6yVIv7iNsn6KaV_PljWuhhLcbXg,509
+mcp_use/managers/tools/connect_server.py,sha256=MGYQCl11q-w6gSIYuT44dDk7ILV3Oh7kGAJ4fsNXbso,2923
+mcp_use/managers/tools/disconnect_server.py,sha256=Y3kJN31efzsjfJwxUhpBxS-bgU21DCfGbn_LgEbzyvI,1586
+mcp_use/managers/tools/get_active_server.py,sha256=tCaib76gYU3L5G82tEOTq4Io2cuCXWjOjPselb-92i8,964
+mcp_use/managers/tools/list_servers_tool.py,sha256=OPDSMNe-VuAhlUyhDnR4CiuZFpoMhnhWpAablwO5S0k,1897
+mcp_use/managers/tools/search_tools.py,sha256=Vxbi8j50q3DyV9dvWCdPeN4vWFG5ksuLG5sERpdlmWg,12226
+mcp_use/managers/tools/use_tool.py,sha256=gMNjgJrI9XDitPyJglcJcAvowbEWkO5z57yt4DT2Lpc,6626
+mcp_use/observability/__init__.py,sha256=kTUcP0d6L5_3ktfldhdAk-3AWckzVHs7ztG-R6cye64,186
+mcp_use/observability/laminar.py,sha256=WWjmVXP55yCfAlqlayeuJmym1gdrv8is7UyrIp4Tbn0,839
+mcp_use/observability/langfuse.py,sha256=9vgJgnGtVpv_CbCyJqyRkzq2ELqPfYFIUGnpSbm2RCo,1334
+mcp_use/task_managers/__init__.py,sha256=LkXOjiDq5JcyB2tNJuSzyjbxZTl1Ordr_NKKD77Nb7g,557
+mcp_use/task_managers/base.py,sha256=mvLFTVyOfvBWFmkx5l8DZVZUezbhsRARDDfMS2AuFLE,5031
+mcp_use/task_managers/sse.py,sha256=nLKt99OiqoJxFT62zCeNwSZUmdPPg4SD7M1pCEPOa3c,2391
+mcp_use/task_managers/stdio.py,sha256=MJcW03lUZUs_HEUxwFPaqy7m8QLbmdn6LagpcfZdjc8,2130
+mcp_use/task_managers/streamable_http.py,sha256=Zky821Ston5CX0DQVyeRxc2uUqALD8soonRSe09cHcE,2683
+mcp_use/task_managers/websocket.py,sha256=9JTw705rhYbP6x2xAPF6PwtNgF5yEWTQhx-dYSPMoaI,2154
+mcp_use/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_use/telemetry/events.py,sha256=K5xqbmkum30r4gM2PWtTiUWGF8oZzGZw2DYwco1RfOQ,3113
+mcp_use/telemetry/telemetry.py,sha256=ck2MDFMtooafriR1W_zi41dWq-0O-ucF89pCkdkyc9E,11724
+mcp_use/telemetry/utils.py,sha256=kDVTqt2oSeWNJbnTOlXOehr2yFO0PMyx2UGkrWkfJiw,1769
+mcp_use/types/sandbox.py,sha256=opJ9r56F1FvaqVvPovfAj5jZbsOexgwYx5wLgSlN8_U,712
+mcp_use-1.3.2.dist-info/METADATA,sha256=-74mIsLr1hd6BBPmXxpHKf7Yz_fk10W_kHmAQ6DK_K4,28683
+mcp_use-1.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.3.2.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.3.2.dist-info/RECORD,,