universal-mcp 0.1.24rc4__tar.gz → 0.1.24rc6__tar.gz

{universal_mcp-0.1.24rc4 → universal_mcp-0.1.24rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc4
+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]==4.0.0
+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.24rc4 → universal_mcp-0.1.24rc6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.24-rc4"
+version = "0.1.24-rc6"
 description = "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."
 readme = "README.md"
 authors = [
@@ -16,7 +16,7 @@ dependencies = [
     "Jinja2>=3.1.3",
     "black>=25.1.0",
     "cookiecutter>=2.6.0",
-    "gql[all]==4.0.0",
+    "gql>=4.0.0",
     "jsonref>=1.1.0",
     "keyring>=25.6.0",
     "langchain-mcp-adapters>=0.1.9",
@@ -26,21 +26,18 @@ dependencies = [
     "langsmith>=0.4.5",
     "loguru>=0.7.3",
     "mcp>=1.10.0",
-    "mkdocs>=1.6.1",
-    "mkdocs-material>=9.6.15",
     "posthog>=3.24.0",
     "pydantic>=2.11.1",
     "pydantic-settings>=2.8.1",
     "pyyaml>=6.0.2",
     "rich>=14.0.0",
     "streamlit>=1.46.1",
-    "ty>=0.0.1a17",
     "typer>=0.15.2",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "mypy>=1.16.0",
+    "ty>=0.0.1a17",
     "litellm>=1.30.7",
     "pre-commit>=4.2.0",
     "pyright>=1.1.398",

{universal_mcp-0.1.24rc4 → universal_mcp-0.1.24rc6}/src/tests/test_tool_manager.py

@@ -4,6 +4,7 @@ from universal_mcp.applications.application import BaseApplication
 from universal_mcp.exceptions import ToolError, ToolNotFoundError
 from universal_mcp.tools.adapters import ToolFormat
 from universal_mcp.tools.manager import Tool, ToolManager
+from universal_mcp.types import TOOL_NAME_SEPARATOR
 
 
 # Dummy tools for testing
@@ -158,8 +159,8 @@ async def test_call_tool_from_app(tool_manager: ToolManager):
     tool_manager.register_tools_from_app(app)
     tools = tool_manager.list_tools()
     assert len(tools) == 1
-    assert "example_app_dummy_add" in [t.name for t in tools]
-    result = await tool_manager.call_tool("example_app_dummy_add", {"a": 2, "b": 3})
+    assert f"example_app{TOOL_NAME_SEPARATOR}dummy_add" in [t.name for t in tools]
+    result = await tool_manager.call_tool(f"example_app{TOOL_NAME_SEPARATOR}dummy_add", {"a": 2, "b": 3})
     assert result == 5
 
 
@@ -170,8 +171,8 @@ async def test_call_tool_from_app_with_tags(tool_manager: ToolManager):
     tool_manager.register_tools_from_app(app, tags=["math"])
     tools = tool_manager.list_tools()
     assert len(tools) == 2
-    assert "example_app_dummy_add" in [t.name for t in tools]
-    assert "example_app_dummy_multiply" in [t.name for t in tools]
+    assert "example_app__dummy_add" in [t.name for t in tools]
+    assert "example_app__dummy_multiply" in [t.name for t in tools]
 
 
 @pytest.mark.asyncio
@@ -181,5 +182,5 @@ async def test_load_tool_from_name(tool_manager: ToolManager):
     tool_manager.register_tools_from_app(app, tool_names=["dummy_multiply", "dummy_add"])
     tools = tool_manager.list_tools()
     assert len(tools) == 2
-    assert "example_app_dummy_multiply" in [t.name for t in tools]
-    assert "example_app_dummy_add" in [t.name for t in tools]
+    assert f"example_app{TOOL_NAME_SEPARATOR}dummy_multiply" in [t.name for t in tools]
+    assert f"example_app{TOOL_NAME_SEPARATOR}dummy_add" in [t.name for t in tools]

{universal_mcp-0.1.24rc4 → universal_mcp-0.1.24rc6}/src/tests/test_zenquotes.py

@@ -2,6 +2,7 @@ import pytest
 
 from universal_mcp.config import AppConfig, ServerConfig
 from universal_mcp.servers import LocalServer
+from universal_mcp.types import TOOL_NAME_SEPARATOR
 
 
 @pytest.mark.asyncio
@@ -20,7 +21,7 @@ async def test_zenquotes():
     tools = await server.list_tools()
     assert len(tools) > 0
     # Get a random quote
-    result = await server.call_tool("zenquotes_get_quote", {})
+    result = await server.call_tool(f"zenquotes{TOOL_NAME_SEPARATOR}get_quote", {})
     assert len(result) > 0
     quote = result[0].text
     assert quote is not None

{universal_mcp-0.1.24rc4 → universal_mcp-0.1.24rc6}/src/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-0.1.24rc6/src/universal_mcp/agents/react.py

@@ -0,0 +1,64 @@
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.prebuilt import create_react_agent
+from loguru import logger
+
+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,
+        memory: BaseCheckpointSaver | None = None,
+        tools: ToolConfig | None = None,
+        max_iterations: int = 10,
+        **kwargs,
+    ):
+        super().__init__(name, instructions, model, memory, **kwargs)
+        self.tools = tools
+        self.max_iterations = max_iterations
+
+    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,
+            prompt=self._build_system_message(),
+            checkpointer=self.memory,
+        )
+
+    def _build_system_message(self) -> str:
+        system_message = f"""You are {self.name}. {self.instructions}
+
+You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
+
+1. Think about what information you need
+2. Call the appropriate tool with the right parameters
+3. Use the tool results to provide a comprehensive answer
+
+Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so."""
+        return system_message
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    agent = ReactAgent(
+        "Universal React Agent",
+        instructions="",
+        model="gpt-4o",
+        tools=ToolConfig(agentrServers={"google-mail": {"tools": ["send_email"]}}),
+    )
+    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-0.1.24rc6/src/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-0.1.24rc4 → universal_mcp-0.1.24rc6}/src/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-0.1.24rc4 → universal_mcp-0.1.24rc6}/src/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-0.1.24rc4 → universal_mcp-0.1.24rc6}/src/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-0.1.24rc6/src/universal_mcp/types.py

@@ -0,0 +1,35 @@
+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):
+    """Supported tool formats."""
+
+    NATIVE = "native"
+    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.24rc4/src/universal_mcp/agents/react.py

@@ -1,58 +0,0 @@
-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
-
-
-class ReactAgent(BaseAgent):
-    def __init__(
-        self, name: str, instructions: str, model: str, tools: list[str] | None = None, max_iterations: int = 10
-    ):
-        super().__init__(name, instructions, model)
-        self.llm = get_llm(model)
-        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 []
-        return create_react_agent(
-            self.llm,
-            tools,
-            prompt=self._build_system_message(),
-            checkpointer=self.memory,
-        )
-
-    def _build_system_message(self) -> str:
-        system_message = f"""You are {self.name}. {self.instructions}
-
-You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
-
-1. Think about what information you need
-2. Call the appropriate tool with the right parameters
-3. Use the tool results to provide a comprehensive answer
-
-Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so."""
-        return system_message
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    agent = ReactAgent(
-        "Universal React Agent", "You are a helpful assistant", "gpt-4.1", tools=["google-mail_send_email"]
-    )
-    asyncio.run(agent.run_interactive())

universal_mcp-0.1.24rc4/src/universal_mcp/types.py

@@ -1,10 +0,0 @@
-from enum import Enum
-
-
-class ToolFormat(str, Enum):
-    """Supported tool formats."""
-
-    NATIVE = "native"
-    MCP = "mcp"
-    LANGCHAIN = "langchain"
-    OPENAI = "openai"