universal-mcp 0.1.24rc19__tar.gz → 0.1.24rc21__tar.gz

{universal_mcp-0.1.24rc19 → universal_mcp-0.1.24rc21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc19
+Version: 0.1.24rc21
 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

{universal_mcp-0.1.24rc19 → universal_mcp-0.1.24rc21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.24-rc19"
+version = "0.1.24-rc21"
 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 = [

universal_mcp-0.1.24rc21/src/tests/test_apps.py

@@ -0,0 +1,64 @@
+import pytest
+
+from universal_mcp.applications.sample.app import SampleApp
+
+
+@pytest.mark.asyncio
+async def test_sample_app_initialization():
+    """Test that the SampleApp initializes correctly."""
+    app = SampleApp()
+
+    # Check app initialized
+    assert app is not None
+    assert app.name == "sample"
+
+
+@pytest.mark.asyncio
+async def test_sample_app_tools():
+    """Test that the SampleApp provides the expected tools."""
+    app = SampleApp()
+
+    # Get list of tools
+    tools = app.list_tools()
+
+    # Check that tools are available
+    assert len(tools) > 0
+
+    # Check specific tools exist
+    tool_names = [tool.__name__ for tool in tools]
+    expected_tools = [
+        "get_current_time",
+        "get_current_date",
+        "calculate",
+        "read_file",
+        "write_file",
+        "get_simple_weather",
+        "generate_image",
+    ]
+
+    for expected_tool in expected_tools:
+        assert expected_tool in tool_names
+
+
+@pytest.mark.asyncio
+async def test_sample_app_basic_functionality():
+    """Test basic functionality of SampleApp tools."""
+    app = SampleApp()
+
+    # Test get_current_time
+    current_time = app.get_current_time()
+    assert isinstance(current_time, str)
+    assert len(current_time) > 0
+
+    # Test get_current_date
+    current_date = app.get_current_date()
+    assert isinstance(current_date, str)
+    assert len(current_date) > 0
+
+    # Test calculate
+    result = app.calculate("2 + 2")
+    assert "Result: 4" in result
+
+    # Test calculate with error
+    error_result = app.calculate("invalid expression")
+    assert "Error in calculation" in error_result

universal_mcp-0.1.24rc21/src/tests/test_local_registry.py

@@ -0,0 +1,94 @@
+import os
+import shutil
+
+import pytest
+from langchain_core.tools import StructuredTool
+from mcp.server.fastmcp.server import MCPTool
+
+from universal_mcp.exceptions import ToolNotFoundError
+from universal_mcp.tools.local_registry import LocalRegistry
+from universal_mcp.types import ToolFormat
+
+
+@pytest.fixture
+def registry():
+    """Provides a LocalRegistry instance and cleans up the output directory."""
+    output_dir = "test_output"
+    reg = LocalRegistry(output_dir=output_dir)
+    yield reg
+    # Cleanup the test output directory after tests are done
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+
+
+@pytest.mark.asyncio
+async def test_export_tools_formats(registry: LocalRegistry):
+    """Verify that tools are exported to all supported formats correctly."""
+    tool_names = ["sample__get_current_date", "sample__calculate"]
+
+    # Test MCP Format
+    mcp_tools = await registry.export_tools(tool_names, format=ToolFormat.MCP)
+    assert len(mcp_tools) == 2
+    assert all(isinstance(t, MCPTool) for t in mcp_tools)
+
+    # Test LangChain Format
+    langchain_tools = await registry.export_tools(tool_names, format=ToolFormat.LANGCHAIN)
+    assert len(langchain_tools) == 2
+    assert all(isinstance(t, StructuredTool) for t in langchain_tools)
+
+    # Test OpenAI Format
+    openai_tools = await registry.export_tools(tool_names, format=ToolFormat.OPENAI)
+    assert len(openai_tools) == 2
+    assert all(isinstance(t, dict) and t.get("type") == "function" for t in openai_tools)
+
+    # Test Native Format
+    native_tools = await registry.export_tools(tool_names, format=ToolFormat.NATIVE)
+    assert len(native_tools) == 2
+    assert all(callable(t) for t in native_tools)
+
+
+@pytest.mark.asyncio
+async def test_call_tool_success(registry: LocalRegistry):
+    """Test a successful tool call through the registry."""
+    await registry.export_tools(["sample__calculate"], format=ToolFormat.NATIVE)  # Load the tool
+    result = await registry.call_tool("sample__calculate", {"expression": "10 - 4"})
+    assert result == "Result: 6"
+
+
+@pytest.mark.asyncio
+async def test_call_tool_not_found(registry: LocalRegistry):
+    """Test that calling a non-existent tool raises the correct exception."""
+    with pytest.raises(ToolNotFoundError):
+        await registry.call_tool("nonexistent__tool", {})
+
+
+@pytest.mark.asyncio
+async def test_file_output_handling(registry: LocalRegistry):
+    """Test that file outputs are correctly handled by writing to a file."""
+    tool_name = "sample__generate_image"
+    await registry.export_tools([tool_name], format=ToolFormat.NATIVE)  # Load the tool
+
+    result = await registry.call_tool(tool_name, {"prompt": "testing file output"})
+    assert isinstance(result, str)
+    assert "File saved to:" in result
+
+    # Verify the file was actually created
+    file_path = result.split("File saved to: ")[1]
+    assert os.path.exists(file_path)
+
+
+@pytest.mark.asyncio
+async def test_unimplemented_methods(registry: LocalRegistry):
+    """Test that abstract methods raise NotImplementedError."""
+    with pytest.raises(NotImplementedError):
+        await registry.list_all_apps()
+    with pytest.raises(NotImplementedError):
+        await registry.get_app_details("some_app")
+    with pytest.raises(NotImplementedError):
+        await registry.search_apps("query")
+    with pytest.raises(NotImplementedError):
+        await registry.list_tools("some_app")
+    with pytest.raises(NotImplementedError):
+        await registry.search_tools("query")
+    with pytest.raises(NotImplementedError):
+        await registry.list_connected_apps()

universal_mcp-0.1.24rc21/src/tests/test_localserver.py

@@ -0,0 +1,71 @@
+import pytest
+
+from universal_mcp.config import AppConfig, ServerConfig
+from universal_mcp.servers.server import LocalServer
+from universal_mcp.tools.local_registry import LocalRegistry
+
+
+@pytest.fixture
+def registry():
+    """Provides a fresh LocalRegistry for each test."""
+    return LocalRegistry()
+
+
+@pytest.mark.asyncio
+async def test_local_server_initialization(registry: LocalRegistry):
+    """Test that the server initializes correctly and loads default tools."""
+    apps_list = [AppConfig(name="sample")]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    assert server is not None
+    assert server.registry is registry
+
+    tools = await server.list_tools()
+    tool_names = {tool.name for tool in tools}
+
+    # By default, only "important" tools should be loaded
+    assert "sample__get_current_time" in tool_names
+    assert "sample__calculate" in tool_names
+    assert "sample__generate_image" in tool_names
+    # This tool is not tagged as important
+    assert "sample__get_simple_weather" not in tool_names
+
+
+@pytest.mark.asyncio
+async def test_local_server_loads_specific_actions(registry: LocalRegistry):
+    """Test that the server loads only the actions specified in the config."""
+    actions = ["get_current_date", "calculate"]
+    apps_list = [AppConfig(name="sample", actions=actions)]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    tools = await server.list_tools()
+    assert len(tools) == 2
+    tool_names = {tool.name for tool in tools}
+    assert tool_names == {"sample__get_current_date", "sample__calculate"}
+
+
+@pytest.mark.asyncio
+async def test_local_server_no_apps(registry: LocalRegistry):
+    """Test that the server handles a config with no apps gracefully."""
+    server_config = ServerConfig(apps=[])
+    server = LocalServer(server_config, registry=registry)
+
+    tools = await server.list_tools()
+    assert len(tools) == 0
+
+
+@pytest.mark.asyncio
+async def test_local_server_tool_call(registry: LocalRegistry):
+    """Test that a tool can be successfully called through the server."""
+    apps_list = [AppConfig(name="sample", actions=["get_current_date"])]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    # Test tool call
+    result = await server.call_tool("sample__get_current_date", {})
+    assert result is not None
+    # A basic check on the result format
+    assert isinstance(result[0].text, str)
+    assert "-" in result[0].text

{universal_mcp-0.1.24rc19 → universal_mcp-0.1.24rc21}/src/tests/test_tool_manager.py

@@ -1,8 +1,6 @@
 import pytest
 
 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
 
@@ -76,14 +74,14 @@ class ExampleApp(BaseApplication):
 def test_add_tool(tool_manager: ToolManager):
     tool = tool_manager.add_tool(dummy_add)
     assert tool.name == "dummy_add"
-    assert tool.name in [t.name for t in tool_manager.list_tools()]
+    assert tool.name in [t.name for t in tool_manager.get_tools()]
 
 
 def test_add_duplicate_tool(tool_manager: ToolManager):
     tool1 = tool_manager.add_tool(dummy_add)
     tool2 = tool_manager.add_tool(dummy_add)
     assert tool1 is tool2  # Should return existing tool
-    assert len(tool_manager.list_tools()) == 1
+    assert len(tool_manager.get_tools()) == 1
 
 
 def test_remove_tool(tool_manager: ToolManager):
@@ -96,26 +94,17 @@ def test_remove_tool(tool_manager: ToolManager):
 def test_clear_tools(tool_manager: ToolManager, dummy_tools):
     for tool in dummy_tools:
         tool_manager.add_tool(tool)
-    assert len(tool_manager.list_tools()) == 3
+    assert len(tool_manager.get_tools()) == 3
     tool_manager.clear_tools()
-    assert len(tool_manager.list_tools()) == 0
+    assert len(tool_manager.get_tools()) == 0
 
 
-def test_list_tools_format(tool_manager: ToolManager, dummy_tools):
+def test_get_tools_no_filters(tool_manager: ToolManager, dummy_tools):
     for tool in dummy_tools:
         tool_manager.add_tool(tool)
 
-    # Test MCP format
-    mcp_tools = tool_manager.list_tools(format=ToolFormat.MCP)
-    assert len(mcp_tools) == 3
-
-    # Test LangChain format
-    langchain_tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
-    assert len(langchain_tools) == 3
-
-    # Test OpenAI format
-    openai_tools = tool_manager.list_tools(format=ToolFormat.OPENAI)
-    assert len(openai_tools) == 3
+    tools = tool_manager.get_tools()
+    assert len(tools) == 3
 
 
 def test_filter_tools_by_tags(tool_manager: ToolManager, dummy_tools):
@@ -123,53 +112,21 @@ def test_filter_tools_by_tags(tool_manager: ToolManager, dummy_tools):
         tool_manager.add_tool(tool)
 
     # Test filtering by important tag
-    important_tools = tool_manager.list_tools(tags=["important"])
+    important_tools = tool_manager.get_tools(tags=["important"])
     assert len(important_tools) == 1
     assert important_tools[0].name == "dummy_add"
 
     # Test filtering by math tag
-    math_tools = tool_manager.list_tools(tags=["math"])
+    math_tools = tool_manager.get_tools(tags=["math"])
     assert len(math_tools) == 2
 
 
-@pytest.mark.asyncio
-async def test_call_tool_success(tool_manager):
-    tool_manager.add_tool(dummy_add)
-    result = await tool_manager.call_tool("dummy_add", {"a": 2, "b": 3})
-    assert result == 5
-
-
-@pytest.mark.asyncio
-async def test_call_tool_error(tool_manager: ToolManager):
-    tool_manager.add_tool(dummy_error)
-    with pytest.raises(ToolError):
-        await tool_manager.call_tool("dummy_error", {})
-
-
-@pytest.mark.asyncio
-async def test_call_nonexistent_tool(tool_manager: ToolManager):
-    with pytest.raises(ToolNotFoundError):
-        await tool_manager.call_tool("nonexistent", {})
-
-
-@pytest.mark.asyncio
-async def test_call_tool_from_app(tool_manager: ToolManager):
-    app = ExampleApp()
-    # Only important are added by default
-    tool_manager.register_tools_from_app(app)
-    tools = tool_manager.list_tools()
-    assert len(tools) == 1
-    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
-
-
 @pytest.mark.asyncio
 async def test_call_tool_from_app_with_tags(tool_manager: ToolManager):
     app = ExampleApp()
     # Only important are added by default
     tool_manager.register_tools_from_app(app, tags=["math"])
-    tools = tool_manager.list_tools()
+    tools = tool_manager.get_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]
@@ -180,7 +137,7 @@ async def test_load_tool_from_name(tool_manager: ToolManager):
     app = ExampleApp()
     # Only important are added by default
     tool_manager.register_tools_from_app(app, tool_names=["dummy_multiply", "dummy_add"])
-    tools = tool_manager.list_tools()
+    tools = tool_manager.get_tools()
     assert len(tools) == 2
     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.24rc19 → universal_mcp-0.1.24rc21}/src/universal_mcp/agentr/README.md

@@ -85,7 +85,7 @@ if apps:
 
 if all_tools:
     tool_id = all_tools[0]['id']
-    
+
     # Fetch a single tool's details
     tool_details = client.get_tool(tool_id)
     print(f"Fetched details for tool '{tool_id}':", tool_details)
@@ -207,4 +207,4 @@ async def main():
 
 if __name__ == "__main__":
     asyncio.run(main())
-```
+```

{universal_mcp-0.1.24rc19 → universal_mcp-0.1.24rc21}/src/universal_mcp/agentr/registry.py

@@ -4,9 +4,10 @@ from typing import Any
 from loguru import logger
 
 from universal_mcp.agentr.client import AgentrClient
+from universal_mcp.applications.application import BaseApplication
 from universal_mcp.applications.utils import app_from_slug
-from universal_mcp.exceptions import ToolError
-from universal_mcp.tools.manager import ToolManager, _get_app_and_tool_name
+from universal_mcp.exceptions import ToolError, ToolNotFoundError
+from universal_mcp.tools.adapters import convert_tools
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig, ToolFormat
 
@@ -35,10 +36,14 @@ class AgentrRegistry(ToolRegistry):
 
     def __init__(self, client: AgentrClient | None = None, **kwargs):
         """Initialize the AgentR platform manager."""
-
+        super().__init__()
         self.client = client or AgentrClient(**kwargs)
-        self.tool_manager = ToolManager()
-        logger.debug("AgentrRegistry initialized successfully")
+
+    def _create_app_instance(self, app_name: str) -> BaseApplication:
+        """Create an app instance with an AgentrIntegration."""
+        app = app_from_slug(app_name)
+        integration = AgentrIntegration(name=app_name, client=self.client)
+        return app(integration=integration)
 
     async def list_all_apps(self) -> list[dict[str, Any]]:
         """Get list of available apps from AgentR.
@@ -139,7 +144,7 @@ class AgentrRegistry(ToolRegistry):
         self,
         tools: list[str] | ToolConfig,
         format: ToolFormat,
-    ) -> str:
+    ) -> list[Any]:
         """Export given tools to required format.
 
         Args:
@@ -147,61 +152,54 @@ class AgentrRegistry(ToolRegistry):
             format: The format to export tools to (native, mcp, langchain, openai)
 
         Returns:
-            String representation of tools in the specified format
+            List of tools in the specified format
         """
+        from langchain_core.tools import StructuredTool
+
         try:
             # Clear tools from tool manager before loading new tools
             self.tool_manager.clear_tools()
+            logger.info(f"Exporting tools to {format.value} format")
             if isinstance(tools, dict):
-                logger.info("Loading tools from tool config")
-                self._load_tools_from_tool_config(tools, self.tool_manager)
+                self._load_tools_from_tool_config(tools)
             else:
-                logger.info("Loading tools from list")
-                self._load_agentr_tools_from_list(tools, self.tool_manager)
-            loaded_tools = self.tool_manager.list_tools(format=format)
-            logger.info(f"Exporting {len(loaded_tools)} tools to {format} format")
-            return loaded_tools
-        except Exception as e:
-            logger.error(f"Error exporting tools: {e}")
-            return ""
+                self._load_tools_from_list(tools)
 
-    def _load_tools(self, app_name: str, tool_names: list[str], tool_manager: ToolManager) -> None:
-        """Helper method to load and register tools for an app."""
-        app = app_from_slug(app_name)
-        integration = AgentrIntegration(name=app_name, client=self.client)
-        app_instance = app(integration=integration)
-        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
+            loaded_tools = self.tool_manager.get_tools()
 
-    def _load_agentr_tools_from_list(self, tools: list[str], tool_manager: ToolManager) -> None:
-        """Load tools from AgentR and register them as tools.
+            if format != ToolFormat.LANGCHAIN:
+                return convert_tools(loaded_tools, format)
 
-        Args:
-            tools: The list of tools to load (prefixed with app name)
-            tool_manager: The tool manager to register tools with
-        """
-        logger.info(f"Loading all tools: {tools}")
-        tools_by_app = {}
-        for tool_name in tools:
-            app_name, _ = _get_app_and_tool_name(tool_name)
-            tools_by_app.setdefault(app_name, []).append(tool_name)
+            logger.info(f"Exporting {len(loaded_tools)} tools to LangChain format with special handling")
 
-        for app_name, tool_names in tools_by_app.items():
-            self._load_tools(app_name, tool_names, tool_manager)
+            langchain_tools = []
+            for tool in loaded_tools:
 
-    def _load_tools_from_tool_config(self, tool_config: ToolConfig, tool_manager: ToolManager) -> None:
-        """Load tools from ToolConfig and register them as tools.
+                def create_coroutine(t):
+                    async def call_tool_wrapper(**arguments: dict[str, Any]):
+                        logger.debug(
+                            f"Executing registry-wrapped LangChain tool '{t.name}' with arguments: {arguments}"
+                        )
+                        return await self.call_tool(t.name, arguments)
 
-        Args:
-            tool_config: The tool configuration containing app names and tools
-            tool_manager: The tool manager to register tools with
-        """
-        for app_name, tool_names in tool_config.items():
-            self._load_tools(app_name, tool_names, tool_manager)
+                    return call_tool_wrapper
 
-    async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
-        """Call a tool with the given name and arguments."""
-        data = await self.tool_manager.call_tool(tool_name, tool_args)
-        logger.debug(f"Tool {tool_name} called with args {tool_args} and returned {data}")
+                langchain_tool = StructuredTool(
+                    name=tool.name,
+                    description=tool.description or "",
+                    coroutine=create_coroutine(tool),
+                    response_format="content",
+                    args_schema=tool.parameters,
+                )
+                langchain_tools.append(langchain_tool)
+
+            return langchain_tools
+
+        except Exception as e:
+            logger.error(f"Error exporting tools: {e}")
+            return []
+
+    def _handle_special_output(self, data: Any) -> Any:
         if isinstance(data, dict):
             type_ = data.get("type")
             if type_ == "image" or type_ == "audio":
@@ -218,6 +216,20 @@ class AgentrRegistry(ToolRegistry):
                 return response
         return data
 
+    async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
+        """Call a tool with the given name and arguments."""
+        logger.debug(f"Calling tool: {tool_name} with arguments: {tool_args}")
+        tool = self.tool_manager.get_tool(tool_name)
+        if not tool:
+            logger.error(f"Unknown tool: {tool_name}")
+            raise ToolNotFoundError(f"Unknown tool: {tool_name}")
+        try:
+            data = await tool.run(tool_args)
+            logger.debug(f"Tool {tool_name} called with args {tool_args} and returned {data}")
+            return self._handle_special_output(data)
+        except Exception as e:
+            raise e
+
     async def list_connected_apps(self) -> list[str]:
         """List all apps that the user has connected."""
         return self.client.list_my_connections()

universal_mcp-0.1.24rc21/src/universal_mcp/agentr/server.py

@@ -0,0 +1,52 @@
+from loguru import logger
+
+from universal_mcp.config import ServerConfig
+from universal_mcp.servers.server import BaseServer
+from universal_mcp.tools import ToolManager
+
+from .client import AgentrClient
+from .registry import AgentrRegistry
+
+
+class AgentrServer(BaseServer):
+    """Server that loads apps and tools from an AgentR instance."""
+
+    def __init__(self, config: ServerConfig, registry: AgentrRegistry | None = None, **kwargs):
+        super().__init__(config, **kwargs)
+
+        if registry:
+            self.registry = registry
+        else:
+            api_key = config.api_key.get_secret_value() if config.api_key else None
+            client = AgentrClient(api_key=api_key, base_url=config.base_url)
+            self.registry = AgentrRegistry(client=client)
+
+        self._tools_loaded = False
+        self._load_all_tools_from_remote()
+
+    def _load_all_tools_from_remote(self):
+        """Load all available tools from the remote AgentR server."""
+        if self._tools_loaded:
+            return
+
+        logger.info("Loading all available tools from AgentR server...")
+        try:
+            all_apps = self.registry.client.list_all_apps()
+            if not all_apps:
+                logger.warning("No apps found on AgentR server.")
+                self._tools_loaded = True
+                return
+
+            # Create a tool config to load all default (important) tools for each app
+            tool_config = {app["name"]: [] for app in all_apps}
+
+            self.registry._load_tools_from_tool_config(tool_config)
+            self._tools_loaded = True
+            logger.info(f"Finished loading tools for {len(all_apps)} app(s) from AgentR server.")
+        except Exception as e:
+            logger.error(f"Failed to load tools from AgentR: {e}", exc_info=True)
+            raise
+
+    @property
+    def tool_manager(self) -> ToolManager:
+        return self.registry.tool_manager

{universal_mcp-0.1.24rc19 → universal_mcp-0.1.24rc21}/src/universal_mcp/integrations/integration.py

@@ -404,3 +404,20 @@ class OAuthIntegration(Integration):
         credentials = response.json()
         self.store.set(self.name, credentials)
         return credentials
+
+
+class IntegrationFactory:
+    """A factory for creating integration instances."""
+
+    @staticmethod
+    def create(app_name: str, integration_type: str = "api_key", **kwargs) -> "Integration":
+        """Create an integration instance."""
+        if integration_type == "api_key":
+            return ApiKeyIntegration(app_name, **kwargs)
+        elif integration_type == "oauth":
+            return OAuthIntegration(app_name, **kwargs)
+        # Add other integration types here
+        else:
+            # Return a default or generic integration if type is unknown
+            logger.warning(f"Unknown integration type '{integration_type}'. Using a default integration.")
+            return Integration(app_name, **kwargs)