universal-mcp 0.1.24rc19__py3-none-any.whl → 0.1.24rc21__py3-none-any.whl

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/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/agentr/server.py

@@ -1,51 +1,52 @@
 from loguru import logger
 
-from universal_mcp.applications import app_from_config
-from universal_mcp.config import AppConfig, ServerConfig
+from universal_mcp.config import ServerConfig
 from universal_mcp.servers.server import BaseServer
 from universal_mcp.tools import ToolManager
 
 from .client import AgentrClient
-from .integration import AgentrIntegration
-
-
-def load_from_agentr_server(client: AgentrClient, tool_manager: ToolManager) -> None:
-    """Load apps from AgentR server and register their tools."""
-    try:
-        apps = client.fetch_apps()
-        for app in apps:
-            try:
-                app_config = AppConfig.model_validate(app)
-                integration = (
-                    AgentrIntegration(name=app_config.integration.name, client=client)  # type: ignore
-                    if app_config.integration
-                    else None
-                )
-                app_instance = app_from_config(app_config)(integration=integration)
-                tool_manager.register_tools_from_app(app_instance, app_config.actions)
-                logger.info(f"Loaded app from AgentR: {app_config.name}")
-            except Exception as e:
-                logger.error(f"Failed to load app from AgentR: {e}", exc_info=True)
-    except Exception as e:
-        logger.error(f"Failed to fetch apps from AgentR: {e}", exc_info=True)
-        raise
+from .registry import AgentrRegistry
 
 
 class AgentrServer(BaseServer):
-    """Server that loads apps from AgentR server."""
+    """Server that loads apps and tools from an AgentR instance."""
 
-    def __init__(self, config: ServerConfig, **kwargs):
+    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.api_key = config.api_key.get_secret_value() if config.api_key else None
-        self.base_url = config.base_url
-        self.client = AgentrClient(api_key=self.api_key, base_url=self.base_url)
+        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:
-        if self._tool_manager is None:
-            self._tool_manager = ToolManager(warn_on_duplicate_tools=True)
-        if not self._tools_loaded:
-            load_from_agentr_server(self.client, self._tool_manager)
-            self._tools_loaded = True
-        return self._tool_manager
+        return self.registry.tool_manager

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)

universal_mcp/servers/server.py

@@ -12,7 +12,8 @@ from universal_mcp.exceptions import ConfigurationError, ToolError
 from universal_mcp.integrations.integration import ApiKeyIntegration, OAuthIntegration
 from universal_mcp.stores import store_from_config
 from universal_mcp.tools import ToolManager
-from universal_mcp.tools.adapters import ToolFormat, format_to_mcp_result
+from universal_mcp.tools.adapters import convert_tool_to_mcp_tool, format_to_mcp_result
+from universal_mcp.tools.local_registry import LocalRegistry
 
 # --- Loader Implementations ---
 
@@ -69,6 +70,7 @@ class BaseServer(FastMCP):
             super().__init__(config.name, config.description, port=config.port, **kwargs)  # type: ignore
             self.config = config
             self._tool_manager = tool_manager
+            self.registry: Any = None
             ServerConfig.model_validate(config)
         except Exception as e:
             logger.error(f"Failed to initialize server: {e}", exc_info=True)
@@ -84,7 +86,8 @@ class BaseServer(FastMCP):
         self.tool_manager.add_tool(fn, name)
 
     async def list_tools(self) -> list:  # type: ignore
-        return self.tool_manager.list_tools(format=ToolFormat.MCP)
+        tools = self.tool_manager.get_tools()
+        return [convert_tool_to_mcp_tool(tool) for tool in tools]
 
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> list[TextContent]:
         if not name:
@@ -92,7 +95,8 @@ class BaseServer(FastMCP):
         if not isinstance(arguments, dict):
             raise ValueError("Arguments must be a dictionary")
         try:
-            result = await self.tool_manager.call_tool(name, arguments)
+            # Delegate the call to the registry
+            result = await self.registry.call_tool(name, arguments)
             return format_to_mcp_result(result)
         except Exception as e:
             logger.error(f"Tool '{name}' failed: {e}", exc_info=True)
@@ -102,18 +106,28 @@ class BaseServer(FastMCP):
 class LocalServer(BaseServer):
     """Server that loads apps and store from local config."""
 
-    def __init__(self, config: ServerConfig, **kwargs):
+    def __init__(self, config: ServerConfig, registry: LocalRegistry | None = None, **kwargs):
         super().__init__(config, **kwargs)
+        self.registry = registry or LocalRegistry()
         self._tools_loaded = False
+        self._load_tools_from_config()
+
+    def _load_tools_from_config(self):
+        """Load tools from the server configuration into the registry."""
+        if not self.config.apps:
+            logger.warning("No applications configured in server config; no tools to load.")
+            return
+
+        logger.info(f"Loading tools from {len(self.config.apps)} app(s) specified in server config...")
+        # Create a tool config dictionary from the server config
+        tool_config = {app.name: app.actions for app in self.config.apps}
+        self.registry._load_tools_from_tool_config(tool_config)
+        self._tools_loaded = True
+        logger.info("Finished loading tools from server config.")
 
     @property
     def tool_manager(self) -> ToolManager:
-        if self._tool_manager is None:
-            self._tool_manager = ToolManager(warn_on_duplicate_tools=True)
-        if not getattr(self, "_tools_loaded", False):
-            load_from_local_config(self.config, self._tool_manager)
-            self._tools_loaded = True
-        return self._tool_manager
+        return self.registry.tool_manager
 
 
 class SingleMCPServer(BaseServer):

universal_mcp/tools/adapters.py

@@ -4,7 +4,21 @@ from loguru import logger
 from mcp.types import TextContent
 
 from universal_mcp.tools.tools import Tool
-from universal_mcp.types import ToolFormat  # noqa: F401
+from universal_mcp.types import ToolFormat
+
+
+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]
+    if format == ToolFormat.MCP:
+        return [convert_tool_to_mcp_tool(tool) for tool in tools]
+    if format == ToolFormat.LANGCHAIN:
+        return [convert_tool_to_langchain_tool(tool) for tool in tools]
+    if format == ToolFormat.OPENAI:
+        return [convert_tool_to_openai_tool(tool) for tool in tools]
+    raise ValueError(f"Invalid format: {format}")
 
 
 def convert_tool_to_mcp_tool(

universal_mcp/tools/local_registry.py

@@ -0,0 +1,109 @@
+import base64
+import os
+from typing import Any
+
+from loguru import logger
+
+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.integrations.integration import IntegrationFactory
+from universal_mcp.tools.adapters import convert_tools
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig, ToolFormat
+
+
+class LocalRegistry(ToolRegistry):
+    """A local implementation of the tool registry."""
+
+    def __init__(self, output_dir: str = "output"):
+        """Initialize the LocalRegistry."""
+        super().__init__()
+        self.output_dir = output_dir
+        if not os.path.exists(self.output_dir):
+            os.makedirs(self.output_dir)
+        logger.debug(f"Local output directory set to: {self.output_dir}")
+
+    def _create_app_instance(self, app_name: str) -> BaseApplication:
+        """Create a local app instance with a default integration."""
+        app = app_from_slug(app_name)
+        integration = IntegrationFactory.create(app_name)
+        return app(integration=integration)
+
+    async def list_all_apps(self) -> list[dict[str, Any]]:
+        """Not implemented for LocalRegistry."""
+        raise NotImplementedError("LocalRegistry does not support listing all apps.")
+
+    async def get_app_details(self, app_id: str) -> dict[str, Any]:
+        """Not implemented for LocalRegistry."""
+        raise NotImplementedError("LocalRegistry does not support getting app details.")
+
+    async def search_apps(
+        self,
+        query: str,
+        limit: int = 2,
+    ) -> list[dict[str, Any]]:
+        """Not implemented for LocalRegistry."""
+        raise NotImplementedError("LocalRegistry does not support searching apps.")
+
+    async def list_tools(
+        self,
+        app_id: str,
+    ) -> list[dict[str, Any]]:
+        """Not implemented for LocalRegistry."""
+        raise NotImplementedError("LocalRegistry does not support listing tools.")
+
+    async def search_tools(
+        self,
+        query: str,
+        limit: int = 2,
+        app_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """Not implemented for LocalRegistry."""
+        raise NotImplementedError("LocalRegistry does not support searching tools.")
+
+    async def export_tools(
+        self,
+        tools: list[str] | ToolConfig,
+        format: ToolFormat,
+    ) -> list[Any]:
+        """Export given tools to the required format."""
+        self.tool_manager.clear_tools()
+        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()
+        exported = convert_tools(loaded_tools, format)
+        logger.info(f"Exported {len(exported)} tools")
+        return exported
+
+    def _handle_file_output(self, data: Any) -> Any:
+        """Handle special file outputs by writing them to the filesystem."""
+        if isinstance(data, dict) and data.get("type") in ["image", "audio"]:
+            base64_data = data.get("data")
+            file_name = data.get("file_name")
+            if not base64_data or not file_name:
+                raise ToolError("File data or name is missing")
+
+            bytes_data = base64.b64decode(base64_data)
+            file_path = os.path.join(self.output_dir, file_name)
+            with open(file_path, "wb") as f:
+                f.write(bytes_data)
+            return f"File saved to: {file_path}"
+        return data
+
+    async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> Any:
+        """Call a tool and handle its output."""
+        tool = self.tool_manager.get_tool(tool_name)
+        if not tool:
+            raise ToolNotFoundError(f"Tool '{tool_name}' not found.")
+
+        result = await tool.run(tool_args)
+        return self._handle_file_output(result)
+
+    async def list_connected_apps(self) -> list[str]:
+        """Not implemented for LocalRegistry."""
+        raise NotImplementedError("LocalRegistry does not support listing connected apps.")

universal_mcp/tools/manager.py

@@ -4,12 +4,6 @@ from typing import Any
 from loguru import logger
 
 from universal_mcp.applications.application import BaseApplication
-from universal_mcp.exceptions import ToolNotFoundError
-from universal_mcp.tools.adapters import (
-    convert_tool_to_langchain_tool,
-    convert_tool_to_mcp_tool,
-    convert_tool_to_openai_tool,
-)
 from universal_mcp.tools.tools import Tool
 from universal_mcp.types import DEFAULT_APP_NAME, DEFAULT_IMPORTANT_TAG, TOOL_NAME_SEPARATOR, ToolFormat
 
@@ -118,46 +112,24 @@ class ToolManager:
         """
         return self._all_tools.get(name)
 
-    def list_tools(
+    def get_tools(
         self,
-        format: ToolFormat | None = None,
         tags: list[str] | None = None,
         tool_names: list[str] | None = None,
-    ) -> list:
-        """List all registered tools in the specified format.
+    ) -> list[Tool]:
+        """Get a filtered list of registered tools.
 
         Args:
-            format: The format to convert tools to.
             tags: Optional list of tags to filter tools by.
-            app_name: Optional app name to filter tools by.
             tool_names: Optional list of tool names to filter by.
 
         Returns:
-            List of tools in the specified format.
-
-        Raises:
-            ValueError: If an invalid format is provided.
+            A list of Tool instances.
         """
-        if format is None:
-            format = self.default_format
-
-        # Start with app-specific tools or all tools
         tools = list(self._all_tools.values())
-        # Apply filters
         tools = _filter_by_tags(tools, tags)
         tools = _filter_by_name(tools, tool_names)
-
-        # Convert to requested format
-        if format == ToolFormat.NATIVE:
-            return [tool.fn for tool in tools]
-        if format == ToolFormat.MCP:
-            return [convert_tool_to_mcp_tool(tool) for tool in tools]
-        elif format == ToolFormat.LANGCHAIN:
-            return [convert_tool_to_langchain_tool(tool) for tool in tools]
-        elif format == ToolFormat.OPENAI:
-            return [convert_tool_to_openai_tool(tool) for tool in tools]
-        else:
-            raise ValueError(f"Invalid format: {format}")
+        return tools
 
     def add_tool(self, fn: Callable[..., Any] | Tool, name: str | None = None) -> Tool:
         """Add a tool to the manager.
@@ -269,34 +241,3 @@ class ToolManager:
             tools = _filter_by_tags(tools, [DEFAULT_IMPORTANT_TAG])
 
         self.register_tools(tools)
-
-    async def call_tool(
-        self,
-        name: str,
-        arguments: dict[str, Any],
-        context: dict[str, Any] | None = None,
-    ) -> Any:
-        """Call a tool by name with arguments.
-
-        Args:
-            name: The name of the tool to call.
-            arguments: The arguments to pass to the tool.
-            context: Optional context information for the tool execution.
-
-        Returns:
-            The result of the tool execution.
-
-        Raises:
-            ToolError: If the tool is not found or execution fails.
-        """
-        logger.debug(f"Calling tool: {name} with arguments: {arguments}")
-        app_name, _ = _get_app_and_tool_name(name)
-        tool = self.get_tool(name)
-        if not tool:
-            logger.error(f"Unknown tool: {name}")
-            raise ToolNotFoundError(f"Unknown tool: {name}")
-        try:
-            result = await tool.run(arguments, context)
-            return result
-        except Exception as e:
-            raise e

universal_mcp/tools/registry.py

@@ -1,84 +1,58 @@
 from abc import ABC, abstractmethod
 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.types import ToolConfig, ToolFormat
 
 
 class ToolRegistry(ABC):
-    """Abstract base class for platform-specific functionality.
-
-    This class abstracts away platform-specific operations like fetching apps,
-    loading actions, and managing integrations. This allows the agents to
-    work with different platforms without being tightly coupled to any specific one.
-
-    The following methods are abstract and must be implemented by the subclass:
-    - list_all_apps: Get list of available apps from the platform.
-    - get_app_details: Get details of a specific app.
-    - search_apps: Search for apps by a query.
-    - list_tools: List all tools available on the platform, filter by app_id.
-    - search_tools: Search for tools by a query.
-    - export_tools: Export tools to required format.
     """
+    Abstract base class for tool registries, defining a common interface and providing
+    shared tool loading functionality.
+    """
+
+    def __init__(self):
+        """Initializes the registry and its internal tool manager."""
+        self.tool_manager = ToolManager()
+        logger.debug(f"{self.__class__.__name__} initialized.")
+
+    # --- Abstract methods for the public interface ---
 
     @abstractmethod
     async def list_all_apps(self) -> list[dict[str, Any]]:
-        """Get list of available apps from the platform.
-
-        Returns:
-            Return a list of apps with their details
-        """
+        """Get a list of all available apps from the platform."""
         pass
 
     @abstractmethod
     async def get_app_details(self, app_id: str) -> dict[str, Any]:
-        """Get detailed information about a specific app.
-
-        Args:
-            app_id: The ID of the app to get details for
-
-        Returns:
-            Dictionary containing app details
-        """
+        """Get detailed information about a specific app."""
         pass
 
     @abstractmethod
-    async def search_apps(
-        self,
-        query: str,
-        limit: int = 2,
-    ) -> list[dict[str, Any]]:
+    async def search_apps(self, query: str, limit: int = 2) -> list[dict[str, Any]]:
         """Search for apps by a query."""
         pass
 
     @abstractmethod
-    async def list_tools(
-        self,
-        app_id: str,
-    ) -> list[dict[str, Any]]:
-        """List all tools available on the platform, filter by app_id."""
+    async def list_tools(self, app_id: str) -> list[dict[str, Any]]:
+        """List all tools available for a specific app."""
         pass
 
     @abstractmethod
-    async def search_tools(
-        self,
-        query: str,
-        limit: int = 2,
-        app_id: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """Search for tools by a query."""
+    async def search_tools(self, query: str, limit: int = 2, app_id: str | None = None) -> list[dict[str, Any]]:
+        """Search for tools by a query, optionally filtered by an app."""
         pass
 
     @abstractmethod
-    async def export_tools(
-        self,
-        tools: list[str] | ToolConfig,
-        format: ToolFormat,
-    ) -> str:
-        """Export giventools to required format."""
+    async def export_tools(self, tools: list[str] | ToolConfig, format: ToolFormat) -> list[Any]:
+        """Export a selection of tools to a specified format."""
         pass
 
     @abstractmethod
-    async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
+    async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> Any:
         """Call a tool with the given name and arguments."""
         pass
 
@@ -86,3 +60,38 @@ class ToolRegistry(ABC):
     async def list_connected_apps(self) -> list[str]:
         """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:
+            app_instance = self._create_app_instance(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/utils/templates/api_client.py.j2

@@ -15,7 +15,7 @@ class {{ class_name }}(APIApplication):
         Tags: {{ method.tags|join(', ') }}
         {% endif %}
         """
-        
+
         {{ method.implementation|indent(8) }}
 {% endfor %}
 
@@ -24,4 +24,4 @@ class {{ class_name }}(APIApplication):
             {% for method in methods %}
             self.{{ method.name }}{% if not loop.last %},{% endif %}
             {%- endfor %}
-        ] 
+        ]

{universal_mcp-0.1.24rc19.dist-info → universal_mcp-0.1.24rc21.dist-info}/METADATA

@@ -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.dist-info → universal_mcp-0.1.24rc21.dist-info}/RECORD

@@ -4,12 +4,12 @@ universal_mcp/exceptions.py,sha256=Uen8UFgLHGlSwXgRUyF-nhqTwdiBuL3okgBVRV2AgtA,2
 universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/types.py,sha256=DAzYyS7Zqdi38SpnhdOm08_JeN2CJiC0hDIpLLIhlSw,316
-universal_mcp/agentr/README.md,sha256=t15pVgkCwZM5wzgLgrf0Zv6hVL7dPmKXvAeTf8CiXPQ,6641
+universal_mcp/agentr/README.md,sha256=oF2Ou3czOCLZnRrfcko8xL7zt89j3Im3_wxwpSikz0A,6638
 universal_mcp/agentr/__init__.py,sha256=fv1ZnOCduIUiJ9oN4e6Ya_hA2oWQvcEuDU3Ek1vEufI,180
 universal_mcp/agentr/client.py,sha256=CwfmOAgWsApm0buxZPni3vW6MFgrwdddXsXmQA5UYrA,7882
 universal_mcp/agentr/integration.py,sha256=V5GjqocqS02tRoI8MeV9PL6m-BzejwBzgJhOHo4MxAE,4212
-universal_mcp/agentr/registry.py,sha256=cWkg9cUEmksWqeuh4xazFf1WtRQ3lEZf1s53hqTlmG4,8657
-universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
+universal_mcp/agentr/registry.py,sha256=VrB39dq3HMOrunPa9ruB8YbNyu1-18BtLaBUio_gCGk,8722
+universal_mcp/agentr/server.py,sha256=d_UaxCGTOzdOsIMiHiILgAjeZLbUASCyQkUqhd1x9wA,1911
 universal_mcp/applications/application.py,sha256=do45GC0jnNepZHL8US2yDNq9s0ZnE6bII4Xbw90GRTc,23727
 universal_mcp/applications/utils.py,sha256=8Pp9lZU6IPt9z9BnuJ-vpv-NGuzryt1c4e4-ShDd2XI,1450
 universal_mcp/applications/sample/app.py,sha256=D9zPezC13xXVMlfO2A0fHgJQD_I-bnpf9UOOHveHMek,10537
@@ -17,17 +17,18 @@ universal_mcp/client/oauth.py,sha256=O00zOUfQxINaruFU2zt-64DIR1_mAqrY8ykLQo-teJU
 universal_mcp/client/token_store.py,sha256=6VAzjzJG49wYvmEDqksFvb-fVqdjHIKWv7yYyh_AuF8,3912
 universal_mcp/client/transport.py,sha256=qqtb0ky6yvLBxsaA9-oFU0v9MwfcQb4eomq-O2fmwtQ,11850
 universal_mcp/integrations/__init__.py,sha256=tfzLyPEPly5tfIcT8K6-oKCr_MEFGxOROHy_NeVy0KM,200
-universal_mcp/integrations/integration.py,sha256=H-hOoDHqk78A4Fi_TGN7OOFS7PDfqXK_nedH8iSz-6A,16459
+universal_mcp/integrations/integration.py,sha256=JAf6_Oy4f3gNI94xS3-yGPwEswAah7hre1en7AwVLdY,17186
 universal_mcp/servers/__init__.py,sha256=speBb_E94UJa4A6Fv8RHFeoJ7cR-q2bCMtKV7R21P5w,142
-universal_mcp/servers/server.py,sha256=bJTG86X_kn0R8lWIYvCZw-cp-rVAOKd12-E5WOEsz8Y,5950
+universal_mcp/servers/server.py,sha256=OUze-imwZxfQdqaRtsoT4DOAbjRK42qfO7k13TpiKMk,6683
 universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
 universal_mcp/stores/store.py,sha256=yWbEGZb53z3fpVyqGWbes63z1CtIzC_IuM49OXy__UY,10137
 universal_mcp/tools/__init__.py,sha256=jC8hsqfTdtn32yU57AVFUXiU3ZmUOCfCERSCaNEIH7E,395
-universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESoTo,3947
+universal_mcp/tools/adapters.py,sha256=LmI5J6e-3TPVuyeDki7uHeZVeCES52y7TRcLpUurzNQ,4591
 universal_mcp/tools/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
 universal_mcp/tools/func_metadata.py,sha256=F4jd--hoZWKPBbZihVtluYKUsIdXdq4a0VWRgMl5k-Q,10838
-universal_mcp/tools/manager.py,sha256=T8iSk7Q6s3MFaQcwUapPvcQ6_l7_g4Xt2xXk55lPJ1w,10321
-universal_mcp/tools/registry.py,sha256=LD0J_bPsd8PRTObyvXglqTW1jfZX98m7KBdyP8Yn7wA,2585
+universal_mcp/tools/local_registry.py,sha256=lvvpW_reF2lHSr3_s3txRU9b5Ps8rUwH-cZSApw46Ew,4236
+universal_mcp/tools/manager.py,sha256=73x5RB5Sgew1hNqCOMmoxHZN2DYjiE7pjsytfi0Gj0g,8213
+universal_mcp/tools/registry.py,sha256=PTVDeVIdHDxMHlf5cNuBmvbmSTFBt_YencA6e79DH4s,3868
 universal_mcp/tools/tools.py,sha256=Lk-wUO3rfhwdxaRANtC7lQr5fXi7nclf0oHzxNAb79Q,4927
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
 universal_mcp/utils/installation.py,sha256=PU_GfHPqzkumKk-xG4L9CkBzSmABxmchwblZkx-zY-I,7204
@@ -46,9 +47,9 @@ universal_mcp/utils/openapi/preprocessor.py,sha256=r4n0WQI__OzPL8FTza7jxiM4EYeZw
 universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
 universal_mcp/utils/openapi/test_generator.py,sha256=vucBh9klWmQOUA740TFwfM9ry2nkwKWQiNRcsiZ9HbY,12229
 universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
-universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
-universal_mcp-0.1.24rc19.dist-info/METADATA,sha256=zKP0JF9Lp3hnTW-8ZvLutdDpGEcqAishzXtrICY3a4Y,3255
-universal_mcp-0.1.24rc19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.24rc19.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.24rc19.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.24rc19.dist-info/RECORD,,
+universal_mcp/utils/templates/api_client.py.j2,sha256=DS1nczOOD8YkMexVSGpUGeyc0nYGKKTPadL_x1_if7k,900
+universal_mcp-0.1.24rc21.dist-info/METADATA,sha256=uMU2UHEiXuJZSI4-3DhheHEjz_IImx2YTN13upi82d8,3255
+universal_mcp-0.1.24rc21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc21.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc21.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc21.dist-info/RECORD,,