universal-mcp 0.1.24rc3__py3-none-any.whl → 0.1.24rc6__py3-none-any.whl

universal_mcp/agentr/README.md

@@ -0,0 +1,201 @@
+# AgentR Python SDK
+
+The official Python SDK for the AgentR platform, a component of the Universal MCP framework.
+Currently in beta, breaking changes are expected.
+
+The AgentR Python SDK provides convenient access to the AgentR REST API from any Python 3.10+
+application, allowing for dynamic loading and management of tools and integrations.
+
+## Installation
+```bash
+pip install universal-mcp
+```
+
+## Usage
+The AgentR platform is designed to seamlessly integrate a wide array of tools into your agentic applications. The primary entry point for this is the `Agentr` class, which provides a high-level interface for loading and listing tools.
+
+### High-Level Client (`Agentr`)
+This is the recommended way to get started. It abstracts away the details of the registry and tool management.
+
+```python
+import os
+from universal_mcp.agentr import Agentr
+from universal_mcp.tools import ToolFormat
+
+# Initialize the main client
+# It reads from environment variables by default (AGENTR_API_KEY, AGENTR_BASE_URL)
+agentr = Agentr(
+    api_key=os.environ.get("AGENTR_API_KEY")
+)
+
+# Load specific tools from the AgentR server into the tool manager
+agentr.load_tools(["reddit_search_subreddits", "google_drive_list_files"])
+
+# List the tools that are now loaded and ready to be used
+# You can specify a format compatible with your LLM (e.g., OPENAI)
+tools = agentr.list_tools(format=ToolFormat.OPENAI)
+print(tools)
+```
+
+### Low-Level API
+
+For more granular control over the AgentR platform, you can use the lower-level components directly.
+
+### AgentrClient
+The `AgentrClient` provides direct access to the AgentR REST API endpoints.
+
+#### Methods
+```python
+import os
+from universal_mcp.agentr import AgentrClient
+from universal_mcp.exceptions import NotAuthorizedError
+
+# Initialize the low-level client
+client = AgentrClient(
+    api_key=os.environ.get("AGENTR_API_KEY")
+)
+
+# Fetch all available applications from the AgentR server
+apps = client.fetch_apps()
+print(apps)
+
+# Get credentials for a specific integration
+# This will raise a NotAuthorizedError if the user needs to authenticate
+try:
+    credentials = client.get_credentials("reddit")
+    print("Reddit credentials found.")
+except NotAuthorizedError as e:
+    print(e) # "Please ask the user to visit the following url to authorize..."
+
+# Example of fetching a single app and its actions
+if apps:
+    app_id = apps[0].id  # Assuming AppConfig has an 'id' attribute
+
+    # Fetch a single app's configuration
+    app_config = client.fetch_app(app_id)
+    print(f"Fetched config for app {app_id}:", app_config)
+
+    # List all actions for that app
+    actions = client.list_actions(app_id)
+    print(f"Actions for app {app_id}:", actions)
+
+# List all apps (returns raw JSON data)
+all_apps = client.list_all_apps()
+print("All available apps:", all_apps)
+```
+
+### AgentrIntegration
+This class handles the authentication and authorization flow for a single integration (e.g., "reddit"). It's used under the hood by applications to acquire credentials.
+
+#### Methods
+```python
+from universal_mcp.agentr import AgentrIntegration, AgentrClient
+from universal_mcp.exceptions import NotAuthorizedError
+
+client = AgentrClient()
+
+# Create an integration for a specific service
+reddit_integration = AgentrIntegration(name="reddit", client=client)
+
+# If credentials are not present, this will raise NotAuthorizedError
+try:
+    creds = reddit_integration.credentials
+    print("Successfully retrieved credentials.")
+except NotAuthorizedError:
+    # Get the URL to send the user to for authentication
+    auth_url = reddit_integration.authorize()
+    print(f"Please authorize here: {auth_url}")
+
+# You can also use the get_credentials() method
+try:
+    creds = reddit_integration.get_credentials()
+    print("Successfully retrieved credentials again.")
+except NotAuthorizedError:
+    print("Still not authorized.")
+```
+
+### AgentrRegistry
+The registry is responsible for discovering which tools are available on the AgentR platform.
+
+#### Methods
+```python
+import asyncio
+from universal_mcp.agentr import AgentrRegistry, AgentrClient
+
+client = AgentrClient()
+registry = AgentrRegistry(client=client)
+
+async def main():
+    # List all apps available on the AgentR platform
+    available_apps = await registry.list_apps()
+    print(available_apps)
+
+    if available_apps:
+        app_id = available_apps[0]['id']
+        # Get details for a specific app
+        app_details = await registry.get_app_details(app_id)
+        print(f"Details for {app_id}:", app_details)
+
+    # The load_tools method is used internally by the high-level Agentr client
+    # but can be called directly if needed.
+    # from universal_mcp.tools import ToolManager
+    # tool_manager = ToolManager()
+    # registry.load_tools(["reddit_search_subreddits"], tool_manager)
+    # print(tool_manager.list_tools())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### AgentrServer
+For server-side deployments, `AgentrServer` can be used to load all configured applications and their tools from an AgentR instance on startup.
+
+```python
+from universal_mcp.config import ServerConfig
+from universal_mcp.agentr.server import AgentrServer
+
+# Configuration for the server
+config = ServerConfig(
+    type="agentr",
+    api_key="your-agentr-api-key"
+)
+
+# The server will automatically fetch and register all tools on initialization
+server = AgentrServer(config=config)
+
+# The tool manager is now populated with tools from the AgentR instance
+tool_manager = server.tool_manager
+print(tool_manager.list_tools())
+```
+
+## Executing Tools
+Once tools are loaded, you can execute them using the `call_tool` method on the `ToolManager` instance, which is available via `agentr.manager`.
+
+```python
+import os
+import asyncio
+from universal_mcp.agentr import Agentr
+
+async def main():
+    # 1. Initialize Agentr
+    agentr = Agentr(api_key=os.environ.get("AGENTR_API_KEY"))
+
+    # 2. Load the tool(s) you want to use
+    tool_name = "reddit_search_subreddits"
+    agentr.load_tools([tool_name])
+
+    # 3. Execute the tool using the tool manager
+    try:
+        # Note the 'await' since call_tool is an async method
+        result = await agentr.manager.call_tool(
+            name=tool_name,
+            arguments={"query": "elon musk", "limit": 5, "sort": "relevance"}
+        )
+        print("Execution result:", result)
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

universal_mcp/agents/base.py

@@ -3,26 +3,31 @@ from typing import cast
 from uuid import uuid4
 
 from langchain_core.messages import AIMessageChunk
+from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.types import Command
 
+from .llm import get_llm
 from .utils import RichCLI
 
 
 class BaseAgent:
-    def __init__(self, name: str, instructions: str, model: str):
+    def __init__(self, name: str, instructions: str, model: str, memory: BaseCheckpointSaver | None = None, **kwargs):
         self.name = name
         self.instructions = instructions
         self.model = model
-        self.memory = MemorySaver()
+        self.memory = memory or MemorySaver()
+        self._graph = None
+        self.llm = get_llm(model)
         self.cli = RichCLI()
 
-    @property
-    def graph(self):
+    async def _build_graph(self):
         raise NotImplementedError("Subclasses must implement this method")
 
     async def stream(self, thread_id: str, user_input: str):
-        async for event, _ in self.graph.astream(
+        if self._graph is None:
+            self._graph = await self._build_graph()
+        async for event, _ in self._graph.astream(
             {"messages": [{"role": "user", "content": user_input}]},
             config={"configurable": {"thread_id": thread_id}},
             stream_mode="messages",
@@ -32,25 +37,33 @@ class BaseAgent:
 
     async def stream_interactive(self, thread_id: str, user_input: str):
         with self.cli.display_agent_response_streaming(self.name) as stream_updater:
-            async for event in self.stream(thread_id, user_input):
+            async for event in self.astream(thread_id, user_input):
                 stream_updater.update(event.content)
 
-    async def process_command(self, command: str) -> bool | None:
-        """Process a command from the user"""
+    async def run(self, user_input: str, thread_id: str = str(uuid4())):
+        """Run the agent"""
+        if not self._graph:
+            self._graph = await self._build_graph()
+        return await self._graph.ainvoke(
+            {"messages": [{"role": "user", "content": user_input}]},
+            config={"configurable": {"thread_id": thread_id}},
+        )
 
     async def run_interactive(self, thread_id: str = str(uuid4())):
         """Main application loop"""
 
+        if not self._graph:
+            self._graph = await self._build_graph()
         # Display welcome
         self.cli.display_welcome(self.name)
 
         # Main loop
         while True:
             try:
-                state = self.graph.get_state(config={"configurable": {"thread_id": thread_id}})
+                state = self._graph.get_state(config={"configurable": {"thread_id": thread_id}})
                 if state.interrupts:
                     value = self.cli.handle_interrupt(state.interrupts[0])
-                    self.graph.invoke(Command(resume=value), config={"configurable": {"thread_id": thread_id}})
+                    self._graph.invoke(Command(resume=value), config={"configurable": {"thread_id": thread_id}})
                     continue
 
                 user_input = self.cli.get_user_input()

universal_mcp/agents/react.py

@@ -1,34 +1,36 @@
+from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.prebuilt import create_react_agent
 from loguru import logger
 
-from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.tools.adapters import ToolFormat
-from universal_mcp.tools.manager import ToolManager
-
-from .base import BaseAgent
-from .llm import get_llm
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.tools import load_agentr_tools, load_mcp_tools
+from universal_mcp.types import ToolConfig
 
 
 class ReactAgent(BaseAgent):
     def __init__(
-        self, name: str, instructions: str, model: str, tools: list[str] | None = None, max_iterations: int = 10
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        memory: BaseCheckpointSaver | None = None,
+        tools: ToolConfig | None = None,
+        max_iterations: int = 10,
+        **kwargs,
     ):
-        super().__init__(name, instructions, model)
-        self.llm = get_llm(model)
+        super().__init__(name, instructions, model, memory, **kwargs)
+        self.tools = tools
         self.max_iterations = max_iterations
-        self.tool_manager = ToolManager()
-        registry = AgentrRegistry()
-        if tools:
-            registry.load_tools(tools, self.tool_manager)
-        logger.debug(f"Initialized ReactAgent: name={name}, model={model}")
-        self._graph = self._build_graph()
-
-    @property
-    def graph(self):
-        return self._graph
-
-    def _build_graph(self):
-        tools = self.tool_manager.list_tools(format=ToolFormat.LANGCHAIN) if self.tool_manager else []
+
+    async def _build_graph(self):
+        if self.tools:
+            config = self.tools.model_dump(exclude_none=True)
+            agentr_tools = await load_agentr_tools(config["agentrServers"]) if config.get("agentrServers") else []
+            mcp_tools = await load_mcp_tools(config["mcpServers"]) if config.get("mcpServers") else []
+            tools = agentr_tools + mcp_tools
+        else:
+            tools = []
+        logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
         return create_react_agent(
             self.llm,
             tools,
@@ -53,6 +55,10 @@ if __name__ == "__main__":
     import asyncio
 
     agent = ReactAgent(
-        "Universal React Agent", "You are a helpful assistant", "gpt-4.1", tools=["google-mail_send_email"]
+        "Universal React Agent",
+        instructions="",
+        model="gpt-4o",
+        tools=ToolConfig(agentrServers={"google-mail": {"tools": ["send_email"]}}),
     )
-    asyncio.run(agent.run_interactive())
+    result = asyncio.run(agent.run(user_input="Send an email with the subject 'Hello' to john.doe@example.com"))
+    print(result["messages"][-1].content)

universal_mcp/agents/tools.py

@@ -0,0 +1,35 @@
+import json
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+from universal_mcp.agentr.integration import AgentrIntegration
+from universal_mcp.applications import app_from_slug
+from universal_mcp.tools.adapters import ToolFormat
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.types import ToolConfig
+
+
+async def load_agentr_tools(agentr_servers: dict):
+    tool_manager = ToolManager()
+    for app_name, tool_names in agentr_servers.items():
+        app = app_from_slug(app_name)
+        integration = AgentrIntegration(name=app_name)
+        app_instance = app(integration=integration)
+        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names["tools"])
+    tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
+    return tools
+
+
+async def load_mcp_tools(mcp_servers: dict):
+    client = MultiServerMCPClient(mcp_servers)
+    tools = await client.get_tools()
+    return tools
+
+
+async def load_tools(path: str) -> ToolConfig:
+    with open(path) as f:
+        data = json.load(f)
+        config = ToolConfig.model_validate(data)
+        agentr_tools = await load_agentr_tools(config.model_dump(exclude_none=True)["agentrServers"])
+        mcp_tools = await load_mcp_tools(config.model_dump(exclude_none=True)["mcpServers"])
+        return agentr_tools + mcp_tools

universal_mcp/config.py

@@ -176,96 +176,3 @@ class ServerConfig(BaseSettings):
         with open(path) as f:
             data = json.load(f)
         return cls.model_validate(data)
-
-
-class ClientTransportConfig(BaseModel):
-    """Configuration for how an MCP client connects to an MCP server.
-
-    Specifies the transport protocol and its associated parameters, such as
-    the command for stdio, URL for HTTP-based transports (SSE, streamable_http),
-    and any necessary headers or environment variables.
-    """
-
-    transport: str | None = Field(
-        default=None,
-        description="The transport protocol (e.g., 'stdio', 'sse', 'streamable_http'). Auto-detected in model_validate if not set.",
-    )
-    command: str | None = Field(
-        default=None, description="The command to execute for 'stdio' transport (e.g., 'python -m mcp_server.run')."
-    )
-    args: list[str] = Field(default=[], description="List of arguments for the 'stdio' command.")
-    env: dict[str, str] = Field(default={}, description="Environment variables to set for the 'stdio' command.")
-    url: str | None = Field(default=None, description="The URL for 'sse' or 'streamable_http' transport.")
-    headers: dict[str, str] = Field(
-        default={}, description="HTTP headers to include for 'sse' or 'streamable_http' transport."
-    )
-
-    @model_validator(mode="after")
-    def determine_transport_if_not_set(self) -> Self:
-        """Determines and sets the transport type if not explicitly provided.
-
-        - If `command` is present, transport is set to 'stdio'.
-        - If `url` is present, transport is 'streamable_http' if URL ends with '/mcp',
-          otherwise 'sse' if URL ends with '/sse'.
-        - Raises ValueError if transport cannot be determined or if neither
-          `command` nor `url` is provided.
-        """
-        if self.command:
-            self.transport = "stdio"
-        elif self.url:
-            # Remove search params from url
-            url = self.url.split("?")[0]
-            if url.rstrip("/").endswith("mcp"):
-                self.transport = "streamable_http"
-            elif url.rstrip("/").endswith("sse"):
-                self.transport = "sse"
-            else:
-                raise ValueError(f"Unknown transport: {self.url}")
-        else:
-            raise ValueError("Either command or url must be provided")
-        return self
-
-
-class ClientConfig(BaseSettings):
-    """Configuration for a client application that interacts with MCP servers and an LLM.
-
-    Defines connections to one or more MCP servers (via `mcpServers`) and
-    optionally, settings for an LLM to be used by the client (e.g., by an agent).
-    """
-
-    mcpServers: dict[str, ClientTransportConfig] = Field(
-        ...,
-        description="Dictionary of MCP server connections. Keys are descriptive names for the server, values are `ClientTransportConfig` objects defining how to connect to each server.",
-    )
-    apps: list[AppConfig] = Field(
-        default=[],
-        description="List of application configurations to load",
-    )
-    store: StoreConfig | None = Field(
-        default=None,
-        description="Default credential store configuration for applications that do not define their own specific store.",
-    )
-    model: str = Field(
-        default="openrouter/auto",
-        description="The model to use for the LLM.",
-    )
-
-    @classmethod
-    def load_json_config(cls, path: Path) -> Self:
-        """Loads client configuration from a JSON file.
-
-        Args:
-            path (str, optional): The path to the JSON configuration file.
-                Defaults to "client_config.json".
-
-        Returns:
-            ClientConfig: An instance of ClientConfig populated with data
-                          from the JSON file.
-        """
-        with open(path) as f:
-            data = json.load(f)
-        return cls.model_validate(data)
-
-    def save_json_config(self, path: str) -> None:
-        with open(path, "w") as f:
-            json.dump(self.model_dump(), f, indent=4)

universal_mcp/tools/manager.py

@@ -12,12 +12,7 @@ from universal_mcp.tools.adapters import (
     convert_tool_to_openai_tool,
 )
 from universal_mcp.tools.tools import Tool
-from universal_mcp.types import ToolFormat
-
-# Constants
-DEFAULT_IMPORTANT_TAG = "important"
-TOOL_NAME_SEPARATOR = "_"
-DEFAULT_APP_NAME = "common"
+from universal_mcp.types import DEFAULT_APP_NAME, DEFAULT_IMPORTANT_TAG, TOOL_NAME_SEPARATOR, ToolFormat
 
 
 def _get_app_and_tool_name(tool_name: str) -> tuple[str, str]:
@@ -31,8 +26,13 @@ def _get_app_and_tool_name(tool_name: str) -> tuple[str, str]:
     return app_name, tool_name_without_app_name
 
 
+def _sanitize_tool_names(tool_names: list[str]) -> list[str]:
+    """Sanitize tool names by removing empty strings and converting to lowercase."""
+    return [_get_app_and_tool_name(name)[1].lower() for name in tool_names if name]
+
+
 def _filter_by_name(tools: list[Tool], tool_names: list[str] | None) -> list[Tool]:
-    """Filter tools by name using simple string matching.
+    """Filter tools by name using set comparison for efficient matching.
 
     Args:
         tools: List of tools to filter.
@@ -45,16 +45,14 @@ def _filter_by_name(tools: list[Tool], tool_names: list[str] | None) -> list[Too
         return tools
 
     logger.debug(f"Filtering tools by names: {tool_names}")
-    # Convert names to lowercase for case-insensitive matching
-    tool_names = [name.lower() for name in tool_names]
+    tool_names_set = set(_sanitize_tool_names(tool_names))
+    logger.debug(f"Tool names set: {tool_names_set}")
     filtered_tools = []
     for tool in tools:
-        for tool_name in tool_names:
-            if tool_name in tool.name.lower():
-                filtered_tools.append(tool)
-                logger.debug(f"Tool '{tool.name}' matched name filter")
-                break
-
+        if tool.tool_name.lower() in tool_names_set:
+            filtered_tools.append(tool)
+            logger.debug(f"Tool '{tool.name}' matched name filter")
+    logger.debug(f"Filtered tools: {[tool.name for tool in filtered_tools]}")
     return filtered_tools
 
 
@@ -200,11 +198,6 @@ class ToolManager:
             app_name: Application name to group the tools under.
         """
         for tool in tools:
-            app_name, tool_name = _get_app_and_tool_name(tool.name)
-
-            # Add prefix to tool name, if not already present
-            tool.name = f"{app_name}{TOOL_NAME_SEPARATOR}{tool_name}"
-            tool.tags.append(app_name)
             self.add_tool(tool)
 
     def remove_tool(self, name: str) -> bool:
@@ -259,14 +252,14 @@ class ToolManager:
 
             try:
                 tool_instance = Tool.from_function(function)
-                tool_instance.name = f"{app.name}{TOOL_NAME_SEPARATOR}{tool_instance.name}"
+                tool_instance.app_name = app.name
                 if app.name not in tool_instance.tags:
                     tool_instance.tags.append(app.name)
                 tools.append(tool_instance)
             except Exception as e:
                 tool_name = getattr(function, "__name__", "unknown")
                 logger.error(f"Failed to create Tool from '{tool_name}' in {app.name}: {e}")
-
+        print([tool.name for tool in tools])
         if tags:
             tools = _filter_by_tags(tools, tags)
 

universal_mcp/tools/tools.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel, Field, create_model
 
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.tools.docstring_parser import parse_docstring
+from universal_mcp.types import TOOL_NAME_SEPARATOR
 
 from .func_metadata import FuncMetadata
 
@@ -31,8 +32,9 @@ class Tool(BaseModel):
     """Internal tool registration info."""
 
     fn: Callable[..., Any] = Field(exclude=True)
-    name: str = Field(description="Name of the tool")
-    description: str = Field(description="Summary line from the tool's docstring")
+    app_name: str | None = Field(default=None, description="Name of the app that the tool belongs to")
+    tool_name: str = Field(description="Name of the tool")
+    description: str | None = Field(default=None, description="Summary line from the tool's docstring")
     args_description: dict[str, str] = Field(
         default_factory=dict, description="Descriptions of arguments from the docstring"
     )
@@ -44,11 +46,15 @@ class Tool(BaseModel):
     tags: list[str] = Field(default_factory=list, description="Tags for categorizing the tool")
     parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
     output_schema: dict[str, Any] | None = Field(default=None, description="JSON schema for tool output")
-    fn_metadata: FuncMetadata = Field(
-        description="Metadata about the function including a pydantic model for tool arguments"
+    fn_metadata: FuncMetadata | None = Field(
+        default=None, description="Metadata about the function including a pydantic model for tool arguments"
     )
     is_async: bool = Field(description="Whether the tool is async")
 
+    @property
+    def name(self) -> str:
+        return f"{self.app_name}{TOOL_NAME_SEPARATOR}{self.tool_name}" if self.app_name else self.tool_name
+
     @classmethod
     def from_function(
         cls,
@@ -81,7 +87,7 @@ class Tool(BaseModel):
 
         return cls(
             fn=fn,
-            name=func_name,
+            tool_name=func_name,
             description=parsed_doc["summary"],
             args_description=simple_args_descriptions,
             returns_description=parsed_doc["returns"],

universal_mcp/types.py

@@ -1,4 +1,12 @@
 from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel
+
+# Constants
+DEFAULT_IMPORTANT_TAG = "important"
+TOOL_NAME_SEPARATOR = "__"
+DEFAULT_APP_NAME = "common"
 
 
 class ToolFormat(str, Enum):
@@ -8,3 +16,20 @@ class ToolFormat(str, Enum):
     MCP = "mcp"
     LANGCHAIN = "langchain"
     OPENAI = "openai"
+
+
+class AgentrConnection(BaseModel):
+    tools: list[str]
+
+
+class MCPConnection(BaseModel):
+    transport: Literal["stdio", "sse", "streamable-http"]
+    command: str | None = None
+    args: list[str] | None = None
+    url: str | None = None
+    headers: dict[str, str] | None = None
+
+
+class ToolConfig(BaseModel):
+    mcpServers: dict[str, MCPConnection] | None = None
+    agentrServers: dict[str, AgentrConnection] | None = None

{universal_mcp-0.1.24rc3.dist-info → universal_mcp-0.1.24rc6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc3
+Version: 0.1.24rc6
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT
@@ -8,7 +8,7 @@ License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: black>=25.1.0
 Requires-Dist: cookiecutter>=2.6.0
-Requires-Dist: gql[all]>=3.5.2
+Requires-Dist: gql>=4.0.0
 Requires-Dist: jinja2>=3.1.3
 Requires-Dist: jsonref>=1.1.0
 Requires-Dist: keyring>=25.6.0
@@ -19,24 +19,21 @@ Requires-Dist: langgraph>=0.5.2
 Requires-Dist: langsmith>=0.4.5
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mcp>=1.10.0
-Requires-Dist: mkdocs-material>=9.6.15
-Requires-Dist: mkdocs>=1.6.1
 Requires-Dist: posthog>=3.24.0
 Requires-Dist: pydantic-settings>=2.8.1
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.0.0
 Requires-Dist: streamlit>=1.46.1
-Requires-Dist: ty>=0.0.1a17
 Requires-Dist: typer>=0.15.2
 Provides-Extra: dev
 Requires-Dist: litellm>=1.30.7; extra == 'dev'
-Requires-Dist: mypy>=1.16.0; extra == 'dev'
 Requires-Dist: pre-commit>=4.2.0; extra == 'dev'
 Requires-Dist: pyright>=1.1.398; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
 Requires-Dist: pytest>=8.3.5; extra == 'dev'
 Requires-Dist: ruff>=0.11.4; extra == 'dev'
+Requires-Dist: ty>=0.0.1a17; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs-glightbox>=0.4.0; extra == 'docs'
 Requires-Dist: mkdocs-material[imaging]>=9.5.45; extra == 'docs'

{universal_mcp-0.1.24rc3.dist-info → universal_mcp-0.1.24rc6.dist-info}/RECORD

@@ -1,11 +1,12 @@
 universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/analytics.py,sha256=RzS88HSvJRGMjdJeLHnOgWzfKSb1jVnvOcD7NHqfERw,3733
 universal_mcp/cli.py,sha256=pPnIWLhSrLV9ukI8YAg2znehCR3VovhEkmh8XkRT3MU,2505
-universal_mcp/config.py,sha256=pkKs0gST65umzmNEvjHiOAtmiBaaICi45WG4Z0My0ak,11983
+universal_mcp/config.py,sha256=lOlDAgQMT7f6VymmsuCP9sYLlxGKj0hDF3hFcJ2nzS4,8135
 universal_mcp/exceptions.py,sha256=Uen8UFgLHGlSwXgRUyF-nhqTwdiBuL3okgBVRV2AgtA,2150
 universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/types.py,sha256=dVK7uSMuhvx5Xk6L7GGdjeaAIKiEwQskTmaVFwIS8LQ,176
+universal_mcp/types.py,sha256=jeUEkUnwdGWo3T_qSRSF83u0fYpuydaWzdKlCYBlCQA,770
+universal_mcp/agentr/README.md,sha256=xXM8JzPyrM2__pGhxHrGEUn9uP2y2bdF00wwcQtBUCI,6441
 universal_mcp/agentr/__init__.py,sha256=ogOhH_OJwkoUZu_2nQJc7-vEGmYQxEjOE511-6ubrX0,217
 universal_mcp/agentr/agentr.py,sha256=JfawuREfXAyeNUE7o58DzTPhmQXuwsB_Da7c1Gf3Qxw,1059
 universal_mcp/agentr/client.py,sha256=oyF6VKq56UMVf5L1WnFTMSZ85W8Qcy-5HZ5XOGiIELM,4139
@@ -14,12 +15,13 @@ universal_mcp/agentr/registry.py,sha256=b9sr5JyT3HLj3e7GFpdXpT7ofGwLQc--y8k2DqF5
 universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
 universal_mcp/agents/__init__.py,sha256=vgixOLTCcCmSweENV7GSAuOPyHXlE4XAbvOXyr4MrRA,185
 universal_mcp/agents/auto.py,sha256=o__71BCOHSfaj7Xt0PhsamVXdeP4o7irhtmu1q6-3Fo,25336
-universal_mcp/agents/base.py,sha256=U5JtpOopmUi73qcxtY9T2qJpYD7e6c62iVlIr3m5Chc,3430
+universal_mcp/agents/base.py,sha256=aplcZ-OKva3hFMB5uzoAPCB0ZDh3BL3FlJV39sJYYZ8,4057
 universal_mcp/agents/cli.py,sha256=7GdRBpu9rhZPiC2vaNQXWI7K-0yCnvdlmE0IFpvy2Gk,539
 universal_mcp/agents/hil.py,sha256=CTgX7CoFEyTFIaNaL-id2WALOPd0VBb79pHkQK8quM8,3671
 universal_mcp/agents/llm.py,sha256=YNxN43bVhGfdYs09yPkdkGCKJkj-2UNqkB1EFmtnUS4,309
-universal_mcp/agents/react.py,sha256=6L--LcuU5Ityi2UiZSYJWgp-lXGkxvpsx8mjvpoNRBQ,2021
+universal_mcp/agents/react.py,sha256=cpE4wzySnyEdhz-c1T1FDA3w68nRByz7yWFt8FefUBo,2361
 universal_mcp/agents/simple.py,sha256=UfmQIIff--_Y0DQ6oivRciHqSZvRqy_qwQn_UYVzYy8,1146
+universal_mcp/agents/tools.py,sha256=7Vdw0VZYxXVAzAYSpRKWHzVl9Ll6NOnVRlc4cTXguUQ,1335
 universal_mcp/agents/utils.py,sha256=7kwFpD0Rv6JqHG-LlNCVwSu_xRX-N119mUmiBroHJL4,4109
 universal_mcp/agents/codeact/__init__.py,sha256=5D_I3lI_3tWjZERRoFav_bPe9UDaJ53pDzZYtyixg3E,10097
 universal_mcp/agents/codeact/sandbox.py,sha256=lGRzhuXTHCB1qauuOI3bH1-fPTsyL6Lf9EmMIz4C2xQ,1039
@@ -41,9 +43,9 @@ universal_mcp/tools/__init__.py,sha256=jC8hsqfTdtn32yU57AVFUXiU3ZmUOCfCERSCaNEIH
 universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESoTo,3947
 universal_mcp/tools/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
 universal_mcp/tools/func_metadata.py,sha256=F4jd--hoZWKPBbZihVtluYKUsIdXdq4a0VWRgMl5k-Q,10838
-universal_mcp/tools/manager.py,sha256=MajVskIptgXv1uZzwnSRycj1TSi7nhn4ebNSRkSSEDs,10455
+universal_mcp/tools/manager.py,sha256=24Rkn5Uvv_AuYAtjeMq986bJ7uzTaGE1290uB9eDtRE,10435
 universal_mcp/tools/registry.py,sha256=XsmVZL1rY5XgIBPTmvKKBWFLAvB3d9LfYMb11b4wSPI,1169
-universal_mcp/tools/tools.py,sha256=1Q8bKiqj1E_-swvjmNHv16Orpd4p_HQtMKGxfqPmoPI,4570
+universal_mcp/tools/tools.py,sha256=Lk-wUO3rfhwdxaRANtC7lQr5fXi7nclf0oHzxNAb79Q,4927
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
 universal_mcp/utils/common.py,sha256=3aJK3AnBkmYf-dbsFLaEu_dGuXQ0Qi2HuqYTueLVhXQ,10968
 universal_mcp/utils/installation.py,sha256=PU_GfHPqzkumKk-xG4L9CkBzSmABxmchwblZkx-zY-I,7204
@@ -63,8 +65,8 @@ universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vH
 universal_mcp/utils/openapi/test_generator.py,sha256=h44gQXEXmrw4pD3-XNHKB7T9c2lDomqrJxVO6oszCqM,12186
 universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
 universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
-universal_mcp-0.1.24rc3.dist-info/METADATA,sha256=rJ2CEZw0gwZkc3O39e1u_6VMcCr1dAhNBviG0YZXwto,3116
-universal_mcp-0.1.24rc3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.24rc3.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.24rc3.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.24rc3.dist-info/RECORD,,
+universal_mcp-0.1.24rc6.dist-info/METADATA,sha256=5KFnUe9auDhLti6G6uogy93a3RuJIBc9un01LNoVBgU,3015
+universal_mcp-0.1.24rc6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc6.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc6.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc6.dist-info/RECORD,,