universal-mcp 0.1.22rc1__tar.gz → 0.1.22rc4__tar.gz

{universal_mcp-0.1.22rc1 → universal_mcp-0.1.22rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.22rc1
+Version: 0.1.22rc4
 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.22rc1 → universal_mcp-0.1.22rc4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.22-rc1"
+version = "0.1.22-rc4"
 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.22rc4/src/tests/test_applications.py

@@ -0,0 +1,71 @@
+import pytest
+
+from universal_mcp.applications import app_from_slug
+from universal_mcp.utils.testing import check_application_instance
+
+ALL_APPS = [
+    "ahrefs",
+    "airtable",
+    "apollo",
+    "asana",
+    "box",
+    # "braze",
+    # "cal-com-v2",
+    "confluence",
+    "calendly",
+    "canva",
+    # "clickup",
+    "coda",
+    "crustdata",
+    "e2b",
+    # "elevenlabs",
+    "exa",
+    "falai",
+    "figma",
+    "firecrawl",
+    "github",
+    "gong",
+    "google-calendar",
+    "google-docs",
+    # "google-drive",
+    "google-gemini",
+    "google-mail",
+    "google-sheet",
+    "hashnode",
+    "heygen",
+    "hubspot",
+    # "jira",
+    "klaviyo",
+    "mailchimp",
+    "markitdown",
+    "miro",
+    "neon",
+    "notion",
+    "perplexity",
+    # "pipedrive",
+    "posthog",
+    "reddit",
+    "replicate",
+    "resend",
+    "retell",
+    "rocketlane",
+    "serpapi",
+    # "shopify",
+    "shortcut",
+    "spotify",
+    "supabase",
+    "tavily",
+    "trello",
+    "unipile",
+    # "whatsapp-business",
+    "wrike",
+    "youtube",
+    "zenquotes",
+]
+
+
+@pytest.mark.parametrize("app_name", ALL_APPS)
+def test_application(app_name):
+    app = app_from_slug(app_name)
+    app_instance = app(integration=None)
+    check_application_instance(app_instance, app_name)

{universal_mcp-0.1.22rc1 → universal_mcp-0.1.22rc4}/src/universal_mcp/applications/__init__.py

@@ -30,6 +30,8 @@ sys.path.append(str(UNIVERSAL_MCP_HOME))
 # Name are in the format of "app-name", eg, google-calendar
 # Class name is NameApp, eg, GoogleCalendarApp
 
+app_cache: dict[str, type[BaseApplication]] = {}
+
 
 def _install_or_upgrade_package(package_name: str, repository_path: str):
     """
@@ -71,6 +73,8 @@ def app_from_slug(slug: str):
     Dynamically resolve and return the application class for the given slug.
     Attempts installation from GitHub if the package is not found locally.
     """
+    if slug in app_cache:
+        return app_cache[slug]
     class_name = get_default_class_name(slug)
     module_path = get_default_module_path(slug)
     package_name = get_default_package_name(slug)
@@ -81,6 +85,7 @@ def app_from_slug(slug: str):
         module = importlib.import_module(module_path)
         class_ = getattr(module, class_name)
         logger.debug(f"Loaded class '{class_}' from module '{module_path}'")
+        app_cache[slug] = class_
         return class_
     except ModuleNotFoundError as e:
         raise ModuleNotFoundError(f"Package '{module_path}' not found locally. Please install it first.") from e

{universal_mcp-0.1.22rc1 → universal_mcp-0.1.22rc4}/src/universal_mcp/servers/server.py

@@ -4,7 +4,6 @@ from typing import Any
 import httpx
 from loguru import logger
 from mcp.server.fastmcp import FastMCP
-from mcp.server.fastmcp.server import MCPTool
 from mcp.types import TextContent
 from pydantic import ValidationError
 
@@ -203,23 +202,13 @@ class AgentRServer(BaseServer):
     """
 
     def __init__(self, config: ServerConfig, **kwargs):
-        # Initialize API key and client before calling super().__init__
+        super().__init__(config, **kwargs)
         self.api_key = config.api_key.get_secret_value() if config.api_key else None
         if not self.api_key:
             raise ValueError("API key is required for AgentR server")
-
         logger.info(f"Initializing AgentR server with API key: {self.api_key}")
         self.client = AgentrClient(api_key=self.api_key)
-        super().__init__(config, **kwargs)
-        self.integration = AgentRIntegration(name="agentr", api_key=self.api_key)
-        # Don't load apps in __init__ for stateless operation
-        self._apps_loaded = False
-
-    def _ensure_apps_loaded(self) -> None:
-        """Ensure apps are loaded, loading them if necessary."""
-        if not self._apps_loaded:
-            self._load_apps()
-            self._apps_loaded = True
+        self._load_apps()
 
     def _fetch_apps(self) -> list[AppConfig]:
         """Fetch available apps from AgentR API with retry logic.
@@ -256,7 +245,7 @@ class AgentRServer(BaseServer):
         """
         try:
             integration = (
-                AgentRIntegration(name=app_config.integration.name, api_key=self.client.api_key)
+                AgentRIntegration(name=app_config.integration.name, api_key=self.api_key)
                 if app_config.integration
                 else None
             )
@@ -292,16 +281,6 @@ class AgentRServer(BaseServer):
             # Don't raise the exception to allow server to start with partial functionality
             logger.warning("Server will start with limited functionality due to app loading failures")
 
-    async def list_tools(self) -> list[MCPTool]:
-        """List available tools, ensuring apps are loaded first."""
-        self._ensure_apps_loaded()
-        return await super().list_tools()
-
-    async def call_tool(self, name: str, arguments: dict) -> list[TextContent]:
-        """Call a tool by name, ensuring apps are loaded first."""
-        self._ensure_apps_loaded()
-        return await super().call_tool(name, arguments)
-
 
 class SingleMCPServer(BaseServer):
     """

{universal_mcp-0.1.22rc1 → universal_mcp-0.1.22rc4}/src/universal_mcp/tools/adapters.py

@@ -19,11 +19,14 @@ def convert_tool_to_mcp_tool(
 ):
     from mcp.server.fastmcp.server import MCPTool
 
-    return MCPTool(
+    logger.debug(f"Converting tool '{tool.name}' to MCP format")
+    mcp_tool = MCPTool(
         name=tool.name[:63],
         description=tool.description or "",
         inputSchema=tool.parameters,
     )
+    logger.debug(f"Successfully converted tool '{tool.name}' to MCP format")
+    return mcp_tool
 
 
 def format_to_mcp_result(result: any) -> list[TextContent]:
@@ -35,9 +38,12 @@ def format_to_mcp_result(result: any) -> list[TextContent]:
     Returns:
         List of TextContent objects
     """
+    logger.debug(f"Formatting result to MCP format, type: {type(result)}")
     if isinstance(result, str):
+        logger.debug("Result is string, wrapping in TextContent")
         return [TextContent(type="text", text=result)]
     elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
+        logger.debug("Result is already list of TextContent objects")
         return result
     else:
         logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
@@ -60,26 +66,33 @@ def convert_tool_to_langchain_tool(
         a LangChain tool
     """
 
+    logger.debug(f"Converting tool '{tool.name}' to LangChain format")
+
     async def call_tool(
         **arguments: dict[str, any],
     ):
+        logger.debug(f"Executing LangChain tool '{tool.name}' with arguments: {arguments}")
         call_tool_result = await tool.run(arguments)
+        logger.debug(f"Tool '{tool.name}' execution completed")
         return call_tool_result
 
-    return StructuredTool(
+    langchain_tool = StructuredTool(
         name=tool.name,
         description=tool.description or "",
         coroutine=call_tool,
         response_format="content",
         args_schema=tool.parameters,
     )
+    logger.debug(f"Successfully converted tool '{tool.name}' to LangChain format")
+    return langchain_tool
 
 
 def convert_tool_to_openai_tool(
     tool: Tool,
 ):
     """Convert a Tool object to an OpenAI function."""
-    return {
+    logger.debug(f"Converting tool '{tool.name}' to OpenAI format")
+    openai_tool = {
         "type": "function",
         "function": {
             "name": tool.name,
@@ -87,3 +100,5 @@ def convert_tool_to_openai_tool(
             "parameters": tool.parameters,
         },
     }
+    logger.debug(f"Successfully converted tool '{tool.name}' to OpenAI format")
+    return openai_tool

{universal_mcp-0.1.22rc1 → universal_mcp-0.1.22rc4}/src/universal_mcp/tools/tools.py

@@ -55,7 +55,7 @@ class Tool(BaseModel):
 
         return cls(
             fn=fn,
-            name=func_name[:48],
+            name=func_name,
             description=parsed_doc["summary"],
             args_description=parsed_doc["args"],
             returns_description=parsed_doc["returns"],

{universal_mcp-0.1.22rc1 → universal_mcp-0.1.22rc4}/src/universal_mcp/utils/agentr.py

@@ -78,3 +78,27 @@ class AgentrClient:
         response.raise_for_status()
         data = response.json()
         return [AppConfig.model_validate(app) for app in data]
+
+    def list_all_apps(self) -> list:
+        """List all apps from AgentR API.
+
+        Returns:
+            List of app names
+        """
+        response = self.client.get("/apps/")
+        response.raise_for_status()
+        return response.json()
+
+    def list_actions(self, app_name: str):
+        """List actions for an app.
+
+        Args:
+            app_name (str): Name of the app to list actions for
+
+        Returns:
+            List of action configurations
+        """
+
+        response = self.client.get(f"/apps/{app_name}/actions/")
+        response.raise_for_status()
+        return response.json()

{universal_mcp-0.1.22rc1 → universal_mcp-0.1.22rc4}/src/universal_mcp/utils/openapi/openapi.py

@@ -149,7 +149,9 @@ def _sanitize_identifier(name: str | None) -> str:
         return ""
 
     # Initial replacements for common non-alphanumeric characters
-    sanitized = name.replace("-", "_").replace(".", "_").replace("[", "_").replace("]", "").replace("$", "_")
+    sanitized = (
+        name.replace("-", "_").replace(".", "_").replace("[", "_").replace("]", "").replace("$", "_").replace("/", "_")
+    )
 
     # Remove leading underscores, but preserve a single underscore if the name (after initial replace)
     # consisted only of underscores.

universal_mcp-0.1.22rc4/src/universal_mcp/utils/testing.py

@@ -0,0 +1,31 @@
+from loguru import logger
+
+from universal_mcp.tools.tools import Tool
+
+
+def check_application_instance(app_instance, app_name):
+    assert app_instance is not None, f"Application object is None for {app_name}"
+    assert (
+        app_instance.name == app_name
+    ), f"Application instance name '{app_instance.name}' does not match expected name '{app_name}'"
+
+    tools = app_instance.list_tools()
+    logger.info(f"Tools for {app_name}: {len(tools)}")
+    assert len(tools) > 0, f"No tools found for {app_name}"
+
+    tools = [Tool.from_function(tool) for tool in tools]
+    seen_names = set()
+    important_tools = []
+
+    for tool in tools:
+        assert tool.name is not None, f"Tool name is None for a tool in {app_name}"
+        assert (
+            0 < len(tool.name) <= 48
+        ), f"Tool name '{tool.name}' for {app_name} has invalid length (must be between 1 and 47 characters)"
+        assert tool.description is not None, f"Tool description is None for tool '{tool.name}' in {app_name}"
+        # assert 0 < len(tool.description) <= 255, f"Tool description for '{tool.name}' in {app_name} has invalid length (must be between 1 and 255 characters)"
+        assert tool.name not in seen_names, f"Duplicate tool name: '{tool.name}' found for {app_name}"
+        seen_names.add(tool.name)
+        if "important" in tool.tags:
+            important_tools.append(tool.name)
+    assert len(important_tools) > 0, f"No important tools found for {app_name}"

universal_mcp-0.1.22rc1/src/tests/test_applications.py

@@ -1,92 +0,0 @@
-import pytest
-from loguru import logger
-
-from universal_mcp.applications import app_from_slug
-from universal_mcp.tools.tools import Tool
-
-ALL_APPS = [
-    "ahrefs",
-    "airtable",
-    "apollo",
-    "asana",
-    "box",
-    "braze",
-    "cal-com-v2",
-    "confluence",
-    "calendly",
-    "canva",
-    "clickup",
-    "coda",
-    "crustdata",
-    "e2b",
-    "elevenlabs",
-    "exa",
-    "falai",
-    "figma",
-    "firecrawl",
-    "github",
-    "gong",
-    "google-calendar",
-    "google-docs",
-    "google-drive",
-    "google-gemini",
-    "google-mail",
-    "google-sheet",
-    "hashnode",
-    "heygen",
-    "hubspot",
-    "jira",
-    "klaviyo",
-    "mailchimp",
-    "markitdown",
-    "miro",
-    "neon",
-    "notion",
-    "perplexity",
-    "pipedrive",
-    "posthog",
-    "reddit",
-    "replicate",
-    "resend",
-    "retell",
-    "rocketlane",
-    "serpapi",
-    "shopify",
-    "shortcut",
-    "spotify",
-    "supabase",
-    "tavily",
-    "trello",
-    "whatsapp-business",
-    "wrike",
-    "youtube",
-    "zenquotes",
-]
-
-
-@pytest.fixture
-def app(app_name):
-    return app_from_slug(app_name)
-
-
-class TestApplications:
-    @pytest.mark.parametrize(
-        "app_name",
-        ALL_APPS,
-    )
-    def test_application(self, app, app_name):
-        assert app is not None
-        app_instance = app(integration=None)
-        assert app_instance.name == app_name
-        tools = app_instance.list_tools()
-        logger.info(f"Tools for {app_name}: {len(tools)}")
-        assert len(tools) > 0, f"No tools found for {app_name}"
-        tools = [Tool.from_function(tool) for tool in tools]
-        important_tools = []
-        for tool in tools:
-            assert tool.name is not None
-            assert len(tool.name) > 0 and len(tool.name) < 64
-            assert tool.description is not None
-            if "important" in tool.tags:
-                important_tools.append(tool.name)
-        assert len(important_tools) > 0, f"No important tools found for {app_name}"