universal-mcp 0.1.24rc6__py3-none-any.whl → 0.1.24rc8__py3-none-any.whl

universal_mcp/agentr/README.md

@@ -1,20 +1,23 @@
 # AgentR Python SDK
 
 The official Python SDK for the AgentR platform, a component of the Universal MCP framework.
-Currently in beta, breaking changes are expected.
 
-The AgentR Python SDK provides convenient access to the AgentR REST API from any Python 3.10+
-application, allowing for dynamic loading and management of tools and integrations.
+*Currently in beta, breaking changes are expected.*
+
+The AgentR Python SDK provides convenient access to the AgentR REST API from any Python 3.10+ application, allowing for dynamic loading and management of tools and integrations.
 
 ## Installation
+
 ```bash
 pip install universal-mcp
 ```
 
 ## Usage
+
 The AgentR platform is designed to seamlessly integrate a wide array of tools into your agentic applications. The primary entry point for this is the `Agentr` class, which provides a high-level interface for loading and listing tools.
 
 ### High-Level Client (`Agentr`)
+
 This is the recommended way to get started. It abstracts away the details of the registry and tool management.
 
 ```python
@@ -29,7 +32,7 @@ agentr = Agentr(
 )
 
 # Load specific tools from the AgentR server into the tool manager
-agentr.load_tools(["reddit_search_subreddits", "google_drive_list_files"])
+agentr.load_tools(["reddit__search_subreddits", "google-drive__list_files"])
 
 # List the tools that are now loaded and ready to be used
 # You can specify a format compatible with your LLM (e.g., OPENAI)
@@ -41,10 +44,10 @@ print(tools)
 
 For more granular control over the AgentR platform, you can use the lower-level components directly.
 
-### AgentrClient
-The `AgentrClient` provides direct access to the AgentR REST API endpoints.
+#### AgentrClient
+
+The `AgentrClient` provides direct, one-to-one access to the AgentR REST API endpoints. The following examples have been updated to reflect the latest API structure.
 
-#### Methods
 ```python
 import os
 from universal_mcp.agentr import AgentrClient
@@ -55,39 +58,43 @@ client = AgentrClient(
     api_key=os.environ.get("AGENTR_API_KEY")
 )
 
-# Fetch all available applications from the AgentR server
-apps = client.fetch_apps()
-print(apps)
+# Fetch a list of available applications from the AgentR server
+apps = client.list_apps()
+print("Available Apps:", apps)
 
-# Get credentials for a specific integration
-# This will raise a NotAuthorizedError if the user needs to authenticate
+# Get credentials for a specific app by its ID (e.g., 'reddit')
+# This will raise a NotAuthorizedError if the user needs to authenticate.
 try:
-    credentials = client.get_credentials("reddit")
+    credentials = client.get_credentials(app_id="reddit")
     print("Reddit credentials found.")
 except NotAuthorizedError as e:
-    print(e) # "Please ask the user to visit the following url to authorize..."
-
-# Example of fetching a single app and its actions
-if apps:
-    app_id = apps[0].id  # Assuming AppConfig has an 'id' attribute
+    print(e)  # "Please ask the user to visit the following url to authorize..."
 
-    # Fetch a single app's configuration
-    app_config = client.fetch_app(app_id)
-    print(f"Fetched config for app {app_id}:", app_config)
+# List all available tools globally
+all_tools = client.list_tools()
+print("All Available Tools:", all_tools)
 
-    # List all actions for that app
-    actions = client.list_actions(app_id)
-    print(f"Actions for app {app_id}:", actions)
-
-# List all apps (returns raw JSON data)
-all_apps = client.list_all_apps()
-print("All available apps:", all_apps)
+# Example of fetching a single app and a single tool
+if apps:
+    # Note: We access dictionary keys, not attributes
+    app_id = apps[0]['id']
+
+    # Fetch a single app's details
+    app_details = client.get_app(app_id)
+    print(f"Fetched details for app '{app_id}':", app_details)
+
+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)
 ```
 
-### AgentrIntegration
+#### AgentrIntegration
+
 This class handles the authentication and authorization flow for a single integration (e.g., "reddit"). It's used under the hood by applications to acquire credentials.
 
-#### Methods
 ```python
 from universal_mcp.agentr import AgentrIntegration, AgentrClient
 from universal_mcp.exceptions import NotAuthorizedError
@@ -114,10 +121,10 @@ except NotAuthorizedError:
     print("Still not authorized.")
 ```
 
-### AgentrRegistry
+#### AgentrRegistry
+
 The registry is responsible for discovering which tools are available on the AgentR platform.
 
-#### Methods
 ```python
 import asyncio
 from universal_mcp.agentr import AgentrRegistry, AgentrClient
@@ -148,7 +155,8 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-### AgentrServer
+#### AgentrServer
+
 For server-side deployments, `AgentrServer` can be used to load all configured applications and their tools from an AgentR instance on startup.
 
 ```python
@@ -170,6 +178,7 @@ print(tool_manager.list_tools())
 ```
 
 ## Executing Tools
+
 Once tools are loaded, you can execute them using the `call_tool` method on the `ToolManager` instance, which is available via `agentr.manager`.
 
 ```python
@@ -182,7 +191,7 @@ async def main():
     agentr = Agentr(api_key=os.environ.get("AGENTR_API_KEY"))
 
     # 2. Load the tool(s) you want to use
-    tool_name = "reddit_search_subreddits"
+    tool_name = "reddit__search_subreddits"
     agentr.load_tools([tool_name])
 
     # 3. Execute the tool using the tool manager

universal_mcp/agentr/__init__.py

@@ -1,6 +1,5 @@
-from .agentr import Agentr
 from .client import AgentrClient
 from .integration import AgentrIntegration
 from .registry import AgentrRegistry
 
-__all__ = ["Agentr", "AgentrClient", "AgentrRegistry", "AgentrIntegration"]
+__all__ = ["AgentrClient", "AgentrRegistry", "AgentrIntegration"]

universal_mcp/agentr/client.py

@@ -1,9 +1,9 @@
 import os
+from typing import Any
 
 import httpx
 from loguru import logger
 
-from universal_mcp.config import AppConfig
 from universal_mcp.exceptions import NotAuthorizedError
 
 
@@ -14,110 +14,196 @@ class AgentrClient:
     including authentication, authorization, and credential management.
 
     Args:
-        api_key (str, optional): AgentR API key. If not provided, will look for AGENTR_API_KEY env var
-        base_url (str, optional): Base URL for AgentR API. Defaults to https://api.agentr.dev
+        api_key (str, optional): AgentR API key. If not provided, will look for AGENTR_API_KEY env var.
+        base_url (str, optional): Base URL for AgentR API. Defaults to https://api.agentr.dev.
+        auth_token (str, optional): Auth token for AgentR API. If not provided, will look for AGENTR_AUTH_TOKEN env var.
     """
 
-    def __init__(self, api_key: str | None = None, base_url: str | None = None):
+    def __init__(
+        self, api_key: str | None = None, base_url: str | None = None, auth_token: str | None = None, **kwargs
+    ):
         base_url = base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
-        self.base_url = base_url.rstrip("/")
-        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
-        if not self.api_key:
-            raise ValueError("No API key provided and AGENTR_API_KEY not found in environment variables")
-        self.client = httpx.Client(
-            base_url=self.base_url, headers={"X-API-KEY": self.api_key}, timeout=30, follow_redirects=True
-        )
+        self.base_url = f"{base_url.rstrip('/')}/v1"
+        api_key = api_key or os.getenv("AGENTR_API_KEY")
+        if api_key:
+            self.client = httpx.Client(
+                base_url=self.base_url,
+                headers={"X-API-KEY": api_key, "accept": "application/json"},
+                timeout=30,
+                follow_redirects=True,
+                verify=False,
+            )
+            me_data = self.me()
+            logger.debug(f"Client initialized with user: {me_data['email']}")
+        elif auth_token:
+            logger.debug("Initializing client with auth token")
+            self.client = httpx.Client(
+                base_url=self.base_url,
+                headers={"Authorization": f"Bearer {auth_token}", "accept": "application/json"},
+                timeout=30,
+                follow_redirects=True,
+                verify=False,
+            )
+            me_data = self.me()
+            logger.debug(f"Client initialized with user: {me_data['email']}")
+        else:
+            raise ValueError("No API key or auth token provided")
+
+    def me(self):
+        response = self.client.get("/users/me")
+        logger.debug(f"Me response: {response.status_code}")
+        response.raise_for_status()
+        data = response.json()
+        return data
 
-    def get_credentials(self, integration_name: str) -> dict:
+    def get_credentials(self, app_id: str) -> dict[str, Any]:
         """Get credentials for an integration from the AgentR API.
 
         Args:
-            integration_name (str): Name of the integration to get credentials for
+            app_id (str): The ID of the app (e.g., 'asana', 'google-drive').
 
         Returns:
-            dict: Credentials data from API response
+            dict: Credentials data from API response.
 
         Raises:
-            NotAuthorizedError: If credentials are not found (404 response)
-            HTTPError: For other API errors
+            NotAuthorizedError: If credentials are not found (404 response).
+            HTTPError: For other API errors.
         """
         response = self.client.get(
-            f"/api/{integration_name}/credentials/",
+            "/credentials",
+            params={"app_id": app_id},
         )
+        logger.debug(f"Credentials response: {response.status_code}")
         if response.status_code == 404:
-            logger.warning(f"No credentials found for {integration_name}. Requesting authorization...")
-            action = self.get_authorization_url(integration_name)
-            raise NotAuthorizedError(action)
+            logger.warning(f"No credentials found for app '{app_id}'. Requesting authorization...")
+            action_url = self.get_authorization_url(app_id)
+            raise NotAuthorizedError(action_url)
         response.raise_for_status()
         return response.json()
 
-    def get_authorization_url(self, integration_name: str) -> str:
-        """Get authorization URL for an integration.
+    def get_authorization_url(self, app_id: str) -> str:
+        """Get the authorization URL to connect an app.
 
         Args:
-            integration_name (str): Name of the integration to get authorization URL for
+            app_id (str): The ID of the app to authorize.
 
         Returns:
-            str: Message containing authorization URL
+            str: A message containing the authorization URL.
 
         Raises:
-            HTTPError: If API request fails
+            HTTPError: If the API request fails.
         """
-        response = self.client.get(f"/api/{integration_name}/authorize/")
+        response = self.client.post("/connections/authorize", json={"app_id": app_id})
         response.raise_for_status()
-        url = response.json()
+        url = response.json().get("authorize_url")
         return f"Please ask the user to visit the following url to authorize the application: {url}. Render the url in proper markdown format with a clickable link."
 
-    def fetch_apps(self) -> list[AppConfig]:
+    def list_all_apps(self):
         """Fetch available apps from AgentR API.
 
         Returns:
-            List of application configurations
+            List[Dict[str, Any]]: A list of application data dictionaries.
 
         Raises:
-            httpx.HTTPError: If API request fails
+            httpx.HTTPError: If the API request fails.
         """
-        response = self.client.get("/api/apps/")
+        response = self.client.get("/apps/")
         response.raise_for_status()
-        data = response.json()
-        return [AppConfig.model_validate(app) for app in data]
+        return response.json().get("items", [])
+
+    def list_my_apps(self):
+        """Fetch user apps from AgentR API.
+
+        Returns:
+            List[Dict[str, Any]]: A list of user app data dictionaries.
+        """
+        response = self.client.get("/apps/me")
+        response.raise_for_status()
+        return response.json().get("items", [])
+
+    def list_my_connections(self):
+        """Fetch user connections from AgentR API.
+
+        Returns:
+            List[Dict[str, Any]]: A list of user connection data dictionaries.
+        """
+        response = self.client.get("/connections")
+        response.raise_for_status()
+        return response.json().get("items", [])
 
-    def fetch_app(self, app_id: str) -> dict:
+    def get_app_details(self, app_id: str):
         """Fetch a specific app from AgentR API.
 
         Args:
-            app_id (str): ID of the app to fetch
+            app_id (str): ID of the app to fetch.
 
         Returns:
-            dict: App configuration data
+            dict: App configuration data.
 
         Raises:
-            httpx.HTTPError: If API request fails
+            httpx.HTTPError: If the API request fails.
         """
-        response = self.client.get(f"/apps/{app_id}/")
+        response = self.client.get(f"/apps/{app_id}")
         response.raise_for_status()
         return response.json()
 
-    def list_all_apps(self) -> list:
-        """List all apps from AgentR API.
+    def list_all_tools(self, app_id: str | None = None):
+        """List all available tools from the AgentR API.
+
+        Note: In the backend, tools are globally listed and not tied to a
+              specific app at this endpoint.
 
         Returns:
-            List of app names
+            List[Dict[str, Any]]: A list of tool configurations.
         """
-        response = self.client.get("/apps/")
+        params = {}
+        if app_id:
+            params["app_id"] = app_id
+        response = self.client.get("/tools", params=params)
+        response.raise_for_status()
+        return response.json().get("items", [])
+
+    def get_tool_details(self, tool_id: str):
+        """Fetch a specific tool configuration from the AgentR API.
+
+        Args:
+            tool_id (str): ID of the tool to fetch.
+
+        Returns:
+            dict: Tool configuration data.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        response = self.client.get(f"/tools/{tool_id}")
         response.raise_for_status()
         return response.json()
 
-    def list_actions(self, app_id: str):
-        """List actions for an app.
+    def search_all_apps(self, query: str, limit: int = 2):
+        """Search for apps from the AgentR API.
 
         Args:
-            app_id (str): ID of the app to list actions for
+            query (str): The query to search for.
+            limit (int, optional): The number of apps to return. Defaults to 2.
 
         Returns:
-            List of action configurations
+            List[Dict[str, Any]]: A list of app data dictionaries.
         """
+        response = self.client.get("/apps", params={"search": query, "limit": limit})
+        response.raise_for_status()
+        return response.json().get("items", [])
+
+    def search_all_tools(self, query: str, limit: int = 2, app_id: str | None = None):
+        """Search for tools from the AgentR API.
 
-        response = self.client.get(f"/apps/{app_id}/actions/")
+        Args:
+            query (str): The query to search for.
+            limit (int, optional): The number of tools to return. Defaults to 2.
+            app_id (str, optional): The ID of the app to search tools for.
+        """
+        params = {"search": query, "limit": limit}
+        if app_id:
+            params["app_id"] = app_id
+        response = self.client.get("/tools", params=params)
         response.raise_for_status()
-        return response.json()
+        return response.json().get("items", [])

universal_mcp/agentr/registry.py

@@ -1,9 +1,12 @@
+from typing import Any
+
 from loguru import logger
 
 from universal_mcp.agentr.client import AgentrClient
 from universal_mcp.applications import app_from_slug
 from universal_mcp.tools.manager import ToolManager, _get_app_and_tool_name
 from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig, ToolFormat
 
 from .integration import AgentrIntegration
 
@@ -15,28 +18,25 @@ class AgentrRegistry(ToolRegistry):
         """Initialize the AgentR platform manager."""
 
         self.client = client or AgentrClient(**kwargs)
+        self.tool_manager = ToolManager()
         logger.debug("AgentrRegistry initialized successfully")
 
-    async def list_apps(self) -> list[dict[str, str]]:
+    async def list_all_apps(self) -> list[dict[str, Any]]:
         """Get list of available apps from AgentR.
 
         Returns:
             List of app dictionaries with id, name, description, and available fields
         """
+        if self.client is None:
+            raise ValueError("Client is not initialized")
         try:
-            all_apps = await self.client.list_all_apps()
-            available_apps = [
-                {"id": app["id"], "name": app["name"], "description": app.get("description", "")}
-                for app in all_apps
-                if app.get("available", False)
-            ]
-            logger.info(f"Found {len(available_apps)} available apps from AgentR")
-            return available_apps
+            all_apps = self.client.list_all_apps()
+            return all_apps
         except Exception as e:
             logger.error(f"Error fetching apps from AgentR: {e}")
             return []
 
-    async def get_app_details(self, app_id: str) -> dict[str, str]:
+    async def get_app_details(self, app_id: str) -> dict[str, Any]:
         """Get detailed information about a specific app from AgentR.
 
         Args:
@@ -46,46 +46,137 @@ class AgentrRegistry(ToolRegistry):
             Dictionary containing app details
         """
         try:
-            app_info = await self.client.fetch_app(app_id)
-            return {
-                "id": app_info.get("id"),
-                "name": app_info.get("name"),
-                "description": app_info.get("description"),
-                "category": app_info.get("category"),
-                "available": app_info.get("available", True),
-            }
+            app_info = self.client.get_app_details(app_id)
+            return app_info
         except Exception as e:
             logger.error(f"Error getting details for app {app_id}: {e}")
-            return {
-                "id": app_id,
-                "name": app_id,
-                "description": "Error loading details",
-                "category": "Unknown",
-                "available": True,
-            }
-
-    def load_tools(self, tools: list[str] | None, tool_manager: ToolManager) -> None:
+            return {}
+
+    async def search_apps(
+        self,
+        query: str,
+        limit: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Search for apps by a query.
+
+        Args:
+            query: The query to search for
+            limit: The number of apps to return
+
+        Returns:
+            List of app dictionaries matching the query
+        """
+        try:
+            apps = self.client.search_all_apps(query, limit)
+            return apps
+        except Exception as e:
+            logger.error(f"Error searching apps from AgentR: {e}")
+            return []
+
+    async def list_tools(
+        self,
+        app_id: str,
+    ) -> list[dict[str, Any]]:
+        """List all tools available on the platform, filter by app_id.
+
+        Args:
+            app_id: The ID of the app to list tools for
+
+        Returns:
+            List of tool dictionaries for the specified app
+        """
+        try:
+            all_tools = self.client.list_all_tools(app_id=app_id)
+            return all_tools
+        except Exception as e:
+            logger.error(f"Error listing tools for app {app_id}: {e}")
+            return []
+
+    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.
+
+        Args:
+            query: The query to search for
+            limit: The number of tools to return
+            app_id: The ID of the app to list tools for
+        Returns:
+            List of tool dictionaries matching the query
+        """
+        try:
+            tools = self.client.search_all_tools(query, limit, app_id)
+            return tools
+        except Exception as e:
+            logger.error(f"Error searching tools from AgentR: {e}")
+            return []
+
+    async def export_tools(
+        self,
+        tools: list[str] | ToolConfig,
+        format: ToolFormat,
+    ) -> str:
+        """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:
+            String representation of tools in the specified format
+        """
+        try:
+            # Clear tools from tool manager before loading new tools
+            self.tool_manager.clear_tools()
+            if isinstance(tools, ToolConfig):
+                print("Loading tools from tool config")
+                self._load_tools_from_tool_config(tools, self.tool_manager)
+            else:
+                print("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 ""
+
+    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)
+
+    def _load_agentr_tools_from_list(self, tools: list[str], tool_manager: ToolManager) -> None:
         """Load tools from AgentR and register them as tools.
 
         Args:
-            tools: The list of tools to load ( prefixed with app name )
+            tools: The list of tools to load (prefixed with app name)
             tool_manager: The tool manager to register tools with
         """
-        if not tools:
-            return
-        logger.info(f"Loading all actions for app: {tools}")
-        # Group all tools by app_name, tools
+        logger.info(f"Loading all tools: {tools}")
         tools_by_app = {}
         for tool_name in tools:
             app_name, _ = _get_app_and_tool_name(tool_name)
-            if app_name not in tools_by_app:
-                tools_by_app[app_name] = []
-            tools_by_app[app_name].append(tool_name)
+            tools_by_app.setdefault(app_name, []).append(tool_name)
 
         for app_name, tool_names in tools_by_app.items():
-            app = app_from_slug(app_name)
-            integration = AgentrIntegration(name=app_name)
-            # TODO: Import with name param, some apps are written incorrectly and hence passing name fails
-            app_instance = app(integration=integration)
-            tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
-        return
+            self._load_tools(app_name, tool_names, tool_manager)
+
+    def _load_tools_from_tool_config(self, tool_config: ToolConfig, tool_manager: ToolManager) -> None:
+        """Load tools from ToolConfig and register them as tools.
+
+        Args:
+            tool_config: The tool configuration containing app names and tools
+            tool_manager: The tool manager to register tools with
+        """
+        for app_name, tool_data in tool_config.agentrServers.items():
+            self._load_tools(app_name, tool_data.tools, tool_manager)
+
+    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."""
+        return await self.tool_manager.call_tool(tool_name, tool_args)

universal_mcp/agents/__init__.py

@@ -1,6 +1,6 @@
-from .auto import AutoAgent
-from .base import BaseAgent
-from .react import ReactAgent
-from .simple import SimpleAgent
+from universal_mcp.agents.autoagent import AutoAgent
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.react import ReactAgent
+from universal_mcp.agents.simple import SimpleAgent
 
 __all__ = ["BaseAgent", "ReactAgent", "SimpleAgent", "AutoAgent"]