universal-mcp 0.1.24rc26__tar.gz → 0.1.24rc28__tar.gz

{universal_mcp-0.1.24rc26 → universal_mcp-0.1.24rc28}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.24-rc26"
+version = "0.1.24-rc28"
 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.24rc26 → universal_mcp-0.1.24rc28}/src/universal_mcp/agentr/registry.py

@@ -1,5 +1,4 @@
 import base64
-import inspect
 from typing import Any
 
 from loguru import logger
@@ -8,9 +7,7 @@ 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, ToolNotFoundError
-from universal_mcp.tools.adapters import convert_tools
 from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig, ToolFormat
 
 from .integration import AgentrIntegration
 
@@ -145,64 +142,6 @@ class AgentrRegistry(ToolRegistry):
             logger.error(f"Error searching tools from AgentR: {e}")
             return []
 
-    async def export_tools(
-        self,
-        tools: list[str] | ToolConfig,
-        format: ToolFormat,
-    ) -> list[Any]:
-        """Export given tools to required format.
-
-        Args:
-            tools: List of tool identifiers to export
-            format: The format to export tools to (native, mcp, langchain, openai)
-
-        Returns:
-            List of tools in the specified format
-        """
-        from langchain_core.tools import StructuredTool
-
-        try:
-            logger.info(f"Exporting tools to {format.value} format")
-            if isinstance(tools, dict):
-                self._load_tools_from_tool_config(tools)
-            else:
-                self._load_tools_from_list(tools)
-
-            loaded_tools = self.tool_manager.get_tools()
-
-            if format != ToolFormat.LANGCHAIN:
-                return convert_tools(loaded_tools, format)
-
-            logger.info(f"Exporting {len(loaded_tools)} tools to LangChain format with special handling")
-
-            langchain_tools = []
-            for tool in loaded_tools:
-                full_docstring = inspect.getdoc(tool.fn)
-
-                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)
-
-                    return call_tool_wrapper
-
-                langchain_tool = StructuredTool(
-                    name=tool.name,
-                    description=full_docstring or 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")

{universal_mcp-0.1.24rc26 → universal_mcp-0.1.24rc28}/src/universal_mcp/tools/adapters.py

@@ -1,4 +1,6 @@
 import inspect
+from collections.abc import Callable
+from functools import wraps
 from typing import Any
 
 from loguru import logger
@@ -12,7 +14,7 @@ def convert_tools(tools: list[Tool], format: ToolFormat) -> list[Any]:
     """Convert a list of Tool objects to a specified format."""
     logger.debug(f"Converting {len(tools)} tools to {format.value} format.")
     if format == ToolFormat.NATIVE:
-        return [tool.fn for tool in tools]
+        return [convert_to_native_tool(tool) for tool in tools]
     if format == ToolFormat.MCP:
         return [convert_tool_to_mcp_tool(tool) for tool in tools]
     if format == ToolFormat.LANGCHAIN:
@@ -22,6 +24,26 @@ def convert_tools(tools: list[Tool], format: ToolFormat) -> list[Any]:
     raise ValueError(f"Invalid format: {format}")
 
 
+def convert_to_native_tool(tool: Tool) -> Callable[..., Any]:
+    """Decorator to convert a Tool object to a native tool."""
+
+    def decorator(func):
+        if inspect.iscoroutinefunction(func):
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                return await func(*args, **kwargs)
+        else:
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+        wrapper.__name__ = tool.name
+        wrapper.__doc__ = tool.fn.__doc__
+        return wrapper
+
+    return decorator(tool.fn)
+
+
 def convert_tool_to_mcp_tool(
     tool: Tool,
 ):
@@ -81,8 +103,6 @@ def convert_tool_to_langchain_tool(
 
     """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
 

{universal_mcp-0.1.24rc26 → universal_mcp-0.1.24rc28}/src/universal_mcp/tools/manager.py

@@ -5,23 +5,13 @@ from loguru import logger
 
 from universal_mcp.applications.application import BaseApplication
 from universal_mcp.tools.tools import Tool
-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]:
-    """Get the app name from a tool name."""
-    if TOOL_NAME_SEPARATOR in tool_name:
-        app_name = tool_name.split(TOOL_NAME_SEPARATOR, 1)[0]
-        tool_name_without_app_name = tool_name.split(TOOL_NAME_SEPARATOR, 1)[1]
-    else:
-        app_name = DEFAULT_APP_NAME
-        tool_name_without_app_name = tool_name
-    return app_name, tool_name_without_app_name
+from universal_mcp.tools.utils import get_app_and_tool_name
+from universal_mcp.types import DEFAULT_IMPORTANT_TAG, ToolFormat
 
 
 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]
+    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]:
@@ -114,8 +104,8 @@ class ToolManager:
 
     def get_tools(
         self,
-        tags: list[str] | None = None,
         tool_names: list[str] | None = None,
+        tags: list[str] | None = None,
     ) -> list[Tool]:
         """Get a filtered list of registered tools.
 
@@ -151,10 +141,10 @@ class ToolManager:
             if self.warn_on_duplicate_tools:
                 if existing.fn is not tool.fn:
                     logger.warning(
-                        f"Tool name '{tool.name}' conflicts with an existing tool. Skipping addition of new function."
+                        f"Tool '{tool.name}' already exists with a different function. Skipping addition of new function."
                     )
                 else:
-                    logger.debug(f"Tool '{tool.name}' with the same function already exists.")
+                    logger.debug(f"Tool '{tool.name}' already exists with the same function.")
             return existing
 
         logger.debug(f"Adding tool: {tool.name}")

{universal_mcp-0.1.24rc26 → universal_mcp-0.1.24rc28}/src/universal_mcp/tools/registry.py

@@ -4,7 +4,9 @@ from typing import Any
 from loguru import logger
 
 from universal_mcp.applications.application import BaseApplication
-from universal_mcp.tools.manager import ToolManager, _get_app_and_tool_name
+from universal_mcp.tools.adapters import convert_tools
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.tools.utils import list_to_tool_config, tool_config_to_list
 from universal_mcp.types import ToolConfig, ToolFormat
 
 
@@ -20,6 +22,36 @@ class ToolRegistry(ABC):
         self.tool_manager = ToolManager()
         logger.debug(f"{self.__class__.__name__} initialized.")
 
+    def _load_tools_from_app(self, app_name: str, tool_names: list[str] | None) -> None:
+        """Helper method to load and register tools for an app."""
+        logger.info(f"Loading tools for app '{app_name}' (tools: {tool_names or 'default'})")
+        try:
+            if app_name not in self._app_instances:
+                self._app_instances[app_name] = self._create_app_instance(app_name)
+            app_instance = self._app_instances[app_name]
+            self.tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
+            logger.info(f"Successfully registered tools for app: {app_name}")
+        except Exception as e:
+            logger.error(f"Failed to load tools for app {app_name}: {e}", exc_info=True)
+
+    def _load_tools_from_list(self, tools: list[str]) -> None:
+        """Load tools from a list of full tool names (e.g., 'app__tool')."""
+        tool_config = list_to_tool_config(tools)
+        for app_name, tool_names in tool_config.items():
+            self._load_tools_from_app(app_name, tool_names or None)
+
+    def _load_tools_from_tool_config(self, tool_config: ToolConfig) -> None:
+        """Load tools from a ToolConfig dictionary."""
+        logger.debug(f"Loading tools from tool_config: {tool_config}")
+        for app_name, tool_names in tool_config.items():
+            self._load_tools_from_app(app_name, tool_names or None)
+
+    # --- Abstract method for subclass implementation ---
+
+    def _create_app_instance(self, app_name: str) -> BaseApplication:
+        """Create an application instance for a given app name."""
+        raise NotImplementedError("Subclasses must implement this method")
+
     # --- Abstract methods for the public interface ---
 
     @abstractmethod
@@ -49,54 +81,35 @@ class ToolRegistry(ABC):
         """Search for tools by a query, optionally filtered by an app."""
         pass
 
-    @abstractmethod
-    async def export_tools(self, tools: list[str] | ToolConfig, format: ToolFormat) -> list[Any]:
-        """Export a selection of tools to a specified format."""
-        pass
+    async def load_tools(self, tools: list[str] | ToolConfig | None = None):
+        """Load the tools to be used"""
+        if isinstance(tools, list):
+            self._load_tools_from_list(tools)
+        elif isinstance(tools, dict):
+            self._load_tools_from_tool_config(tools)
+        else:
+            raise ValueError(f"Invalid tools type: {type(tools)}. Expected list or ToolConfig.")
+        return self.tool_manager.get_tools()
+
+    async def export_tools(
+        self, tools: list[str] | ToolConfig | None = None, format: ToolFormat = ToolFormat.NATIVE
+    ) -> list[Any]:
+        """Export the loaded tools as in required format"""
+        if tools is not None:
+            # Load the tools if they are not already loaded
+            await self.load_tools(tools)
+        tools_list = tool_config_to_list(tools) if isinstance(tools, dict) else tools
+        loaded_tools = self.tool_manager.get_tools(tool_names=tools_list)
+        exported_tools = convert_tools(loaded_tools, format)
+        logger.info(f"Exported {len(exported_tools)} tools to {format.value} format")
+        return exported_tools if isinstance(exported_tools, list) else [exported_tools]
 
-    @abstractmethod
     async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> Any:
         """Call a tool with the given name and arguments."""
-        pass
+        result = await self.tool_manager.get_tool(tool_name)
+        return await result.run(tool_args)
 
     @abstractmethod
     async def list_connected_apps(self) -> list[dict[str, Any]]:
         """List all apps that the user has connected."""
         pass
-
-    # --- Abstract method for subclass implementation ---
-
-    def _create_app_instance(self, app_name: str) -> BaseApplication:
-        """Create an application instance for a given app name."""
-        raise NotImplementedError("Subclasses must implement this method")
-
-    # --- Concrete methods for shared tool loading ---
-
-    def _load_tools(self, app_name: str, tool_names: list[str] | None) -> None:
-        """Helper method to load and register tools for an app."""
-        logger.info(f"Loading tools for app '{app_name}' (tools: {tool_names or 'default'})")
-        try:
-            if app_name not in self._app_instances:
-                self._app_instances[app_name] = self._create_app_instance(app_name)
-            app_instance = self._app_instances[app_name]
-            self.tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
-            logger.info(f"Successfully registered tools for app: {app_name}")
-        except Exception as e:
-            logger.error(f"Failed to load tools for app {app_name}: {e}", exc_info=True)
-
-    def _load_tools_from_list(self, tools: list[str]) -> None:
-        """Load tools from a list of full tool names (e.g., 'app__tool')."""
-        logger.debug(f"Loading tools from list: {tools}")
-        tools_by_app: dict[str, list[str]] = {}
-        for tool_name in tools:
-            app_name, _ = _get_app_and_tool_name(tool_name)
-            tools_by_app.setdefault(app_name, []).append(tool_name)
-
-        for app_name, tool_names in tools_by_app.items():
-            self._load_tools(app_name, tool_names)
-
-    def _load_tools_from_tool_config(self, tool_config: ToolConfig) -> None:
-        """Load tools from a ToolConfig dictionary."""
-        logger.debug(f"Loading tools from tool_config: {tool_config}")
-        for app_name, tool_names in tool_config.items():
-            self._load_tools(app_name, tool_names or None)

universal_mcp-0.1.24rc28/src/universal_mcp/tools/utils.py

@@ -0,0 +1,30 @@
+from universal_mcp.types import DEFAULT_APP_NAME, TOOL_NAME_SEPARATOR, ToolConfig
+
+
+def get_app_and_tool_name(tool_name: str) -> tuple[str, str]:
+    """Get the app and tool name from a tool name."""
+    if TOOL_NAME_SEPARATOR in tool_name:
+        app_name = tool_name.split(TOOL_NAME_SEPARATOR, 1)[0]
+        tool_name_without_app_name = tool_name.split(TOOL_NAME_SEPARATOR, 1)[1]
+    else:
+        app_name = DEFAULT_APP_NAME
+        tool_name_without_app_name = tool_name
+    return app_name, tool_name_without_app_name
+
+
+def tool_config_to_list(tools: ToolConfig) -> list[str]:
+    """Convert a ToolConfig dictionary to a list of tool names."""
+    return [
+        f"{app_name}{TOOL_NAME_SEPARATOR}{tool_name}"
+        for app_name, tool_names in tools.items()
+        for tool_name in tool_names
+    ]
+
+
+def list_to_tool_config(tools: list[str]) -> ToolConfig:
+    """Convert a list of tool names to a ToolConfig dictionary."""
+    tool_config = {}
+    for tool_name in tools:
+        app_name, tool_name_without_app_name = get_app_and_tool_name(tool_name)
+        tool_config.setdefault(app_name, []).append(tool_name_without_app_name)
+    return tool_config