universal-mcp 0.1.20rc2__tar.gz → 0.1.22__tar.gz

{universal_mcp-0.1.20rc2 → universal_mcp-0.1.22}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.20rc2
+Version: 0.1.22
 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
 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: jinja2>=3.1.3

{universal_mcp-0.1.20rc2 → universal_mcp-0.1.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.20-rc2"
+version = "0.1.22"
 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 = [
@@ -14,6 +14,7 @@ requires-python = ">=3.11"
 license = { text = "MIT" }
 dependencies = [
     "Jinja2>=3.1.3",
+    "black>=25.1.0",
     "cookiecutter>=2.6.0",
     "gql[all]>=3.5.2",
     "jsonref>=1.1.0",

universal_mcp-0.1.22/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.20rc2 → universal_mcp-0.1.22}/src/tests/test_tool.py

@@ -18,7 +18,7 @@ def test_func_metadata_annotated():
         "title": "funcArguments",
         "properties": {
             "a": {"type": "integer", "title": "First integer"},
-            "b": {"type": "integer", "title": "B"},
+            "b": {"type": "integer", "title": "b"},
         },
         "required": ["a", "b"],
     }
@@ -40,8 +40,8 @@ def test_func_metadata_no_annotated():
         "type": "object",
         "title": "funcArguments",
         "properties": {
-            "a": {"type": "integer", "title": "The first integer"},
-            "b": {"type": "integer", "title": "The second integer"},
+            "a": {"type": "integer", "description": "The first integer", "title": "a"},
+            "b": {"type": "integer", "description": "The second integer", "title": "b"},
         },
         "required": ["a", "b"],
     }
@@ -57,7 +57,6 @@ def test_func_metadata_no_args():
         "type": "object",
         "title": "funcArguments",
         "properties": {},
-        # "required": [],
     }
 
 
@@ -88,9 +87,9 @@ def test_func_metadata_required():
         "type": "object",
         "title": "funcArguments",
         "properties": {
-            "a": {"type": "integer", "title": "A"},
-            "b": {"type": "string", "title": "B"},
-            "c": {"type": "number", "title": "C", "default": 1.0},
+            "a": {"type": "integer", "title": "a"},
+            "b": {"type": "string", "title": "b"},
+            "c": {"type": "number", "title": "c", "default": 1.0},
         },
         "required": ["a", "b"],
     }
@@ -106,7 +105,7 @@ def test_func_metadata_none_type():
         "type": "object",
         "title": "funcArguments",
         "properties": {
-            "a": {"type": "null", "title": "A", "default": None},
+            "a": {"type": "null", "title": "a", "default": None},
         },
     }
 

{universal_mcp-0.1.20rc2 → universal_mcp-0.1.22}/src/universal_mcp/applications/__init__.py

@@ -30,12 +30,13 @@ 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):
     """
     Helper to install a package via pip from the universal-mcp GitHub repository.
     """
-
     uv_path = os.getenv("UV_PATH")
     uv_executable = str(Path(uv_path) / "uv") if uv_path else "uv"
     logger.info(f"Using uv executable: {uv_executable}")
@@ -72,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)
@@ -82,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.20rc2 → universal_mcp-0.1.22}/src/universal_mcp/integrations/integration.py

@@ -3,9 +3,8 @@ from typing import Any
 import httpx
 from loguru import logger
 
-from universal_mcp.exceptions import NotAuthorizedError
-from universal_mcp.stores import BaseStore
-from universal_mcp.stores.store import KeyNotFoundError, MemoryStore
+from universal_mcp.exceptions import KeyNotFoundError, NotAuthorizedError
+from universal_mcp.stores import BaseStore, MemoryStore
 from universal_mcp.utils.agentr import AgentrClient
 
 
@@ -34,10 +33,7 @@ class Integration:
 
     def __init__(self, name: str, store: BaseStore | None = None):
         self.name = name
-        if store is None:
-            self.store = MemoryStore()
-        else:
-            self.store = store
+        self.store = store or MemoryStore()
 
     def authorize(self) -> str | dict[str, Any]:
         """Authorize the integration.
@@ -329,7 +325,7 @@ class AgentRIntegration(Integration):
         ValueError: If no API key is provided or found in environment variables
     """
 
-    def __init__(self, name: str, api_key: str = None, **kwargs):
+    def __init__(self, name: str, api_key: str, **kwargs):
         super().__init__(name, **kwargs)
         self.client = AgentrClient(api_key=api_key)
         self._credentials = None

{universal_mcp-0.1.20rc2 → universal_mcp-0.1.22}/src/universal_mcp/servers/server.py

@@ -13,6 +13,7 @@ from universal_mcp.exceptions import ConfigurationError, ToolError
 from universal_mcp.integrations import AgentRIntegration, integration_from_config
 from universal_mcp.stores import BaseStore, store_from_config
 from universal_mcp.tools import ToolManager
+from universal_mcp.tools.adapters import ToolFormat, format_to_mcp_result
 from universal_mcp.utils.agentr import AgentrClient
 
 
@@ -33,6 +34,7 @@ class BaseServer(FastMCP):
             logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
             self.config = config
             self._tool_manager = tool_manager or ToolManager(warn_on_duplicate_tools=True)
+            # Validate config after setting attributes to ensure proper initialization
             ServerConfig.model_validate(config)
         except Exception as e:
             logger.error(f"Failed to initialize server: {e}", exc_info=True)
@@ -47,33 +49,15 @@ class BaseServer(FastMCP):
         Raises:
             ValueError: If tool is invalid
         """
-
         self._tool_manager.add_tool(tool)
 
-    async def list_tools(self) -> list[dict]:
+    async def list_tools(self) -> list:
         """List all available tools in MCP format.
 
         Returns:
             List of tool definitions
         """
-        return self._tool_manager.list_tools(format="mcp")
-
-    def _format_tool_result(self, result: Any) -> list[TextContent]:
-        """Format tool result into TextContent list.
-
-        Args:
-            result: Raw tool result
-
-        Returns:
-            List of TextContent objects
-        """
-        if isinstance(result, str):
-            return [TextContent(type="text", text=result)]
-        elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
-            return result
-        else:
-            logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
-            return [TextContent(type="text", text=str(result))]
+        return self._tool_manager.list_tools(format=ToolFormat.MCP)
 
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> list[TextContent]:
         """Call a tool with comprehensive error handling.
@@ -98,7 +82,7 @@ class BaseServer(FastMCP):
         try:
             result = await self._tool_manager.call_tool(name, arguments)
             logger.info(f"Tool '{name}' completed successfully")
-            return self._format_tool_result(result)
+            return format_to_mcp_result(result)
         except Exception as e:
             logger.error(f"Tool '{name}' failed: {e}", exc_info=True)
             raise ToolError(f"Tool execution failed: {str(e)}") from e
@@ -218,11 +202,12 @@ class AgentRServer(BaseServer):
     """
 
     def __init__(self, config: ServerConfig, **kwargs):
+        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.client.api_key)
         self._load_apps()
 
     def _fetch_apps(self) -> list[AppConfig]:
@@ -260,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
             )
@@ -321,12 +306,12 @@ class SingleMCPServer(BaseServer):
         **kwargs,
     ):
         if not app_instance:
-            raise ValueError("app_instance is required")
-        if not config:
-            config = ServerConfig(
-                type="local",
-                name=f"{app_instance.name.title()} MCP Server for Local Development",
-                description=f"Minimal MCP server for the local {app_instance.name} application.",
-            )
+            raise ValueError("app_instance is required for SingleMCPServer")
+
+        config = config or ServerConfig(
+            type="local",
+            name=f"{app_instance.name.title()} MCP Server for Local Development",
+            description=f"Minimal MCP server for the local {app_instance.name} application.",
+        )
         super().__init__(config, **kwargs)
         self._tool_manager.register_tools_from_app(app_instance, tags="all")

universal_mcp-0.1.22/src/universal_mcp/tools/adapters.py

@@ -0,0 +1,104 @@
+from enum import Enum
+
+from loguru import logger
+from mcp.types import TextContent
+
+from universal_mcp.tools.tools import Tool
+
+
+class ToolFormat(str, Enum):
+    """Supported tool formats."""
+
+    MCP = "mcp"
+    LANGCHAIN = "langchain"
+    OPENAI = "openai"
+
+
+def convert_tool_to_mcp_tool(
+    tool: Tool,
+):
+    from mcp.server.fastmcp.server import 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]:
+    """Format tool result into TextContent list.
+
+    Args:
+        result: Raw tool result
+
+    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.")
+        return [TextContent(type="text", text=str(result))]
+
+
+def convert_tool_to_langchain_tool(
+    tool: Tool,
+):
+    from langchain_core.tools import StructuredTool
+
+    """Convert an tool to a LangChain tool.
+
+    NOTE: this tool can be executed only in a context of an active MCP client session.
+
+    Args:
+        tool: Tool to convert
+
+    Returns:
+        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
+
+    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."""
+    logger.debug(f"Converting tool '{tool.name}' to OpenAI format")
+    openai_tool = {
+        "type": "function",
+        "function": {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": tool.parameters,
+        },
+    }
+    logger.debug(f"Successfully converted tool '{tool.name}' to OpenAI format")
+    return openai_tool

{universal_mcp-0.1.20rc2 → universal_mcp-0.1.22}/src/universal_mcp/tools/func_metadata.py

@@ -192,8 +192,10 @@ class FuncMetadata(BaseModel):
                 _get_typed_annotation(annotation, globalns),
                 param.default if param.default is not inspect.Parameter.empty else PydanticUndefined,
             )
-            if not field_info.title and arg_description and arg_description.get(param.name):
-                field_info.title = arg_description.get(param.name)
+            if not field_info.title:
+                field_info.title = param.name
+            if not field_info.description and arg_description and arg_description.get(param.name):
+                field_info.description = arg_description.get(param.name)
             dynamic_pydantic_model_params[param.name] = (
                 field_info.annotation,
                 field_info,