universal-mcp 0.1.24rc6__py3-none-any.whl → 0.1.24rc7__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/agentr.py

@@ -28,3 +28,10 @@ class Agentr:
 
     def list_tools(self, format: ToolFormat | None = None) -> list[Tool]:
         return self.manager.list_tools(format=format or self.format)
+
+    def search_tools(
+        self,
+        query: str,
+    ) -> list[str]:
+        """Retrieve a tool to use, given a search query."""
+        return self.registry.search_tools(query)

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,164 @@ 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.
     """
 
     def __init__(self, api_key: str | None = None, base_url: str | None = None):
         base_url = base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
-        self.base_url = base_url.rstrip("/")
+        self.base_url = f"{base_url.rstrip('/')}/v1"
         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
+            base_url=self.base_url,
+            headers={"X-API-KEY": self.api_key},
+            timeout=30,
+            follow_redirects=True,
+            verify=False,
         )
 
-    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},
         )
         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) -> list[dict[str, Any]]:
         """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()
+        return response.json().get("items", [])
+
+    def list_my_apps(self) -> list[dict[str, Any]]:
+        """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) -> list[dict[str, Any]]:
+        """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()
-        data = response.json()
-        return [AppConfig.model_validate(app) for app in data]
+        return response.json().get("items", [])
 
-    def fetch_app(self, app_id: str) -> dict:
+    def get_app_details(self, app_id: str) -> dict[str, Any]:
         """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) -> list[dict[str, Any]]:
+        """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/")
+        response = self.client.get("/tools/")
+        response.raise_for_status()
+        return response.json().get("items", [])
+
+    def get_tool_details(self, tool_id: str) -> dict[str, Any]:
+        """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) -> list[dict[str, Any]]:
+        """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) -> list[dict[str, Any]]:
+        """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.
+        """
+        response = self.client.get("/tools/", params={"search": query, "limit": limit})
         response.raise_for_status()
-        return response.json()
+        return response.json().get("items", [])

universal_mcp/agentr/registry.py

@@ -17,26 +17,22 @@ class AgentrRegistry(ToolRegistry):
         self.client = client or AgentrClient(**kwargs)
         logger.debug("AgentrRegistry initialized successfully")
 
-    async def list_apps(self) -> list[dict[str, str]]:
+    def list_apps(self) -> list[dict[str, str]]:
         """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]:
+    def get_app_details(self, app_id: str) -> dict[str, str]:
         """Get detailed information about a specific app from AgentR.
 
         Args:
@@ -46,23 +42,11 @@ 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,
-            }
+            return {}
 
     def load_tools(self, tools: list[str] | None, tool_manager: ToolManager) -> None:
         """Load tools from AgentR and register them as tools.
@@ -89,3 +73,15 @@ class AgentrRegistry(ToolRegistry):
             app_instance = app(integration=integration)
             tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
         return
+
+    def search_tools(self, query: str, limit: int = 20) -> list[str]:
+        """Search for tools in AgentR.
+
+        Args:
+            query: The query to search for
+
+        Returns:
+            List of tool names
+        """
+        return self.client.search_all_tools(query, limit)
+    

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.auto 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"]

universal_mcp/agents/auto.py

@@ -16,8 +16,8 @@ from universal_mcp.tools import ToolManager
 from universal_mcp.tools.adapters import ToolFormat
 from universal_mcp.tools.registry import ToolRegistry
 
-from .base import BaseAgent
-from .llm import get_llm
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
 
 # Auto Agent
 # Working
@@ -61,9 +61,9 @@ class AutoAgent(BaseAgent):
     def __init__(self, name: str, instructions: str, model: str, app_registry: ToolRegistry):
         super().__init__(name, instructions, model)
         self.app_registry = app_registry
-        self.llm_tools = get_llm(model, tags=["tools"])
-        self.llm_choice = get_llm(model, tags=["choice"])
-        self.llm_quiet = get_llm(model, tags=["quiet"])
+        self.llm_tools = load_chat_model(model, tags=["tools"])
+        self.llm_choice = load_chat_model(model, tags=["choice"])
+        self.llm_quiet = load_chat_model(model, tags=["quiet"])
         self.tool_manager = ToolManager()
 
         self.task_analysis_prompt = """You are a task analysis expert. Given a task description and available apps, determine:
@@ -522,7 +522,7 @@ Be friendly and concise, but list each set of apps clearly. Do not return any ot
             return result
 
         # Get all available apps from platform manager
-        available_apps = await self.app_registry.list_apps()
+        available_apps =  self.app_registry.list_apps()
 
         logger.info(f"Found {len(available_apps)} available apps")
 
@@ -563,10 +563,10 @@ if __name__ == "__main__":
 
     # Create platform manager
     app_registry = AgentrRegistry(api_key=agentr_api_key)
-    want_instructions = input("Do you want to add a system prompt/instructions? (Y/N)")
+    want_instructions = input("Do you want to add a system prompt/instructions? (Y/N): ")
     instructions = "" if want_instructions.upper() == "N" else input("Enter your instructions/system prompt: ")
 
-    agent = AutoAgent("Auto Agent", instructions, "gpt-4.1", app_registry=app_registry)
+    agent = AutoAgent("Auto Agent", instructions, "azure/gpt-4.1", app_registry=app_registry)
 
     print("AutoAgent created successfully!")
     print(f"Agent name: {agent.name}")

universal_mcp/agents/autoagent/__init__.py

@@ -0,0 +1,35 @@
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.tools.registry import ToolRegistry
+
+from universal_mcp.agents.autoagent.graph import create_agent
+
+
+class AutoAgent(BaseAgent):
+    def __init__(
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        tool_registry: ToolRegistry | None = None,
+        tool_manager: ToolManager | None = None,
+    ):
+        super().__init__(name, instructions, model, tool_registry)
+        self.tool_registry = tool_registry or AgentrRegistry()
+        self.tool_manager = tool_manager or ToolManager()
+        self.model = model
+        self.name = name
+        self.instructions = instructions
+        self._graph = self._build_graph()
+
+    def _build_graph(self):
+        builder = create_agent(self.tool_registry, self.tool_manager, self.instructions)
+        return builder.compile()
+
+    @property
+    def graph(self):
+        return self._graph
+
+
+__all__ = ["AutoAgent"]

universal_mcp/agents/autoagent/__main__.py

@@ -0,0 +1,21 @@
+import asyncio
+
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.autoagent import AutoAgent
+
+
+async def main():
+    agent = AutoAgent(
+        name="autoagent",
+        instructions="You are a helpful assistant that can use tools to help the user.",
+        model="azure/gpt-4o",
+        tool_registry=AgentrRegistry(),
+    )
+    result = await agent.run(
+        user_input="Send an email to Manoj from my google mail account, manoj@agentr.dev, with the subject 'Hello from auto agent' and the body 'testing'"
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp/agents/autoagent/context.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import Annotated
+
+from universal_mcp.agents.autoagent.prompts import SYSTEM_PROMPT
+
+
+@dataclass(kw_only=True)
+class Context:
+    """The context for the agent."""
+
+    system_prompt: str = field(
+        default=SYSTEM_PROMPT,
+        metadata={
+            "description": "The system prompt to use for the agent's interactions. "
+            "This prompt sets the context and behavior for the agent."
+        },
+    )
+
+    model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="anthropic/claude-4-sonnet-20250514",
+        metadata={
+            "description": "The name of the language model to use for the agent's main interactions. "
+            "Should be in the form: provider/model-name."
+        },
+    )

universal_mcp/agents/autoagent/graph.py

@@ -0,0 +1,119 @@
+import json
+from datetime import UTC, datetime
+from typing import cast
+
+from langchain_core.messages import AIMessage, ToolMessage
+from langchain_core.tools import tool
+from langgraph.graph import END, START, StateGraph
+from langgraph.runtime import Runtime
+
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolFormat
+
+from universal_mcp.agents.autoagent.context import Context
+from universal_mcp.agents.autoagent.prompts import SYSTEM_PROMPT
+from universal_mcp.agents.autoagent.state import State
+
+
+def create_agent(tool_registry: ToolRegistry, tool_manager: ToolManager, instructions: str = ""):
+    @tool()
+    def retrieve_tools(query: str) -> list[str]:
+        """Retrieve tools using a search query. Use multiple times if you require tools for different tasks."""
+        tools = tool_registry.search_tools(query)
+        my_connections = tool_registry.client.list_my_connections()
+        connected_apps = set(connection["app_id"] for connection in my_connections)
+        filtered_tools = [tool for tool in tools if tool["app_id"] in connected_apps]
+        if len(filtered_tools) == 0:
+            return tools
+        return filtered_tools
+    
+    @tool()
+    def ask_user(question: str) -> str:
+        """Ask the user a question. Use this tool to ask the user for any missing information for performing a task, or when you have multiple apps to choose from for performing a task."""
+        full_question = question
+        return f"ASKING_USER: {full_question}"
+
+    def call_model(
+        state: State,
+        runtime: Runtime[Context],
+    ):
+        system_prompt = runtime.context.system_prompt if runtime.context.system_prompt else SYSTEM_PROMPT
+        system_prompt = system_prompt.format(system_time=datetime.now(tz=UTC).isoformat())
+
+        messages = [{"role": "system", "content": system_prompt + "\n" + instructions}, *state["messages"]]
+        model = load_chat_model(runtime.context.model)
+        # Load tools from tool registry
+        tool_registry.load_tools(tools=state["selected_tool_ids"], tool_manager=tool_manager)
+        loaded_tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
+        model_with_tools = model.bind_tools([retrieve_tools, ask_user, *loaded_tools], tool_choice="auto")
+        response = cast(AIMessage, model_with_tools.invoke(messages))
+        return {"messages": [response]}
+
+    # Define the conditional edge that determines whether to continue or not
+    def should_continue(state: State):
+        messages = state["messages"]
+        last_message = messages[-1]
+        # If there is no function call, then we finish
+        if not last_message.tool_calls:
+            return END
+        # Otherwise if there is, we continue
+        else:
+            return "tools"
+    
+    def tool_router(state: State):
+        last_message = state["messages"][-1]
+        if isinstance(last_message, ToolMessage):
+            return "agent"
+        else:
+            return END
+
+
+    async def tool_node(state: State):
+        outputs = []
+        tool_ids = state["selected_tool_ids"]
+        for tool_call in state["messages"][-1].tool_calls:
+            if tool_call["name"] == retrieve_tools.name:
+                tool_result = retrieve_tools.invoke(tool_call["args"])
+                tool_ids = [tool["id"] for tool in tool_result]
+                outputs.append(
+                    ToolMessage(
+                        content=json.dumps(tool_result),
+                        name=tool_call["name"],
+                        tool_call_id=tool_call["id"],
+                    )
+                )
+            elif tool_call["name"] == ask_user.name:
+                outputs.append(
+                    ToolMessage(
+                        content=json.dumps("The user has been asked the question, and the run will wait for the user's response."),
+                        name=tool_call["name"],
+                        tool_call_id=tool_call["id"],
+                    )
+                )
+                ai_message = AIMessage(content=tool_call["args"]["question"])
+                outputs.append(ai_message)
+            else:
+                tool_manager.clear_tools()
+                tool_registry.load_tools([tool_call["name"]], tool_manager=tool_manager)
+                tool_result = await tool_manager.call_tool(tool_call["name"], tool_call["args"])
+                outputs.append(
+                    ToolMessage(
+                        content=json.dumps(tool_result),
+                        name=tool_call["name"],
+                        tool_call_id=tool_call["id"],
+                    )
+                )
+        return {"messages": outputs, "selected_tool_ids": tool_ids}
+
+    builder = StateGraph(State, context_schema=Context)
+
+    builder.add_node("agent", call_model)
+    builder.add_node("tools", tool_node)
+
+    builder.add_edge(START, "agent")
+    builder.add_conditional_edges("agent", should_continue)
+    builder.add_conditional_edges("tools", tool_router)
+
+    return builder

universal_mcp/agents/autoagent/prompts.py

@@ -0,0 +1,5 @@
+"""Default prompts used by the agent."""
+
+SYSTEM_PROMPT = """You are a helpful AI assistant. When you lack tools for any task you should use the `retrieve_tools` function to unlock relevant tools. Whenever you need to ask the user for any information, or choose between multiple different applications, you can ask the user using the `ask_user` function.
+
+System time: {system_time}"""

universal_mcp/agents/autoagent/state.py

@@ -0,0 +1,27 @@
+from typing import Annotated
+
+from langgraph.prebuilt.chat_agent_executor import AgentState
+
+
+def _enqueue(left: list, right: list) -> list:
+    """Treat left as a FIFO queue, append new items from right (preserve order),
+    keep items unique, and cap total size to 20 (drop oldest items)."""
+    max_size = 30
+    preferred_size = 20
+    if len(right) > preferred_size:
+        preferred_size = min(max_size, len(right))
+    queue = list(left or [])
+
+    for item in right[:preferred_size] or []:
+        if item in queue:
+            queue.remove(item)
+        queue.append(item)
+
+    if len(queue) > preferred_size:
+        queue = queue[-preferred_size:]
+
+    return queue
+
+
+class State(AgentState):
+    selected_tool_ids: Annotated[list[str], _enqueue]

universal_mcp/agents/autoagent/studio.py

@@ -0,0 +1,25 @@
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.autoagent import create_agent
+from universal_mcp.tools import ToolManager
+
+tool_registry = AgentrRegistry()
+tool_manager = ToolManager()
+
+
+
+apps = tool_registry.client.list_all_apps()
+names = [app["name"] for app in apps]
+
+instructions = """
+You are a helpful assistant that can use tools to help the user. If a task requires multiple steps, you should perform separate different searches for different actions.
+These are the list of applications you can use to help the user:
+{names}
+"""
+graph = create_agent(tool_registry, tool_manager, instructions=instructions)
+
+
+
+
+
+
+

universal_mcp/agents/autoagent/utils.py

@@ -0,0 +1,13 @@
+from langchain_core.messages import BaseMessage
+
+
+def get_message_text(msg: BaseMessage) -> str:
+    """Get the text content of a message."""
+    content = msg.content
+    if isinstance(content, str):
+        return content
+    elif isinstance(content, dict):
+        return content.get("text", "")
+    else:
+        txts = [c if isinstance(c, str) else (c.get("text") or "") for c in content]
+        return "".join(txts).strip()

universal_mcp/agents/base.py

@@ -7,7 +7,7 @@ from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.types import Command
 
-from .llm import get_llm
+from .llm import load_chat_model
 from .utils import RichCLI
 
 
@@ -18,7 +18,7 @@ class BaseAgent:
         self.model = model
         self.memory = memory or MemorySaver()
         self._graph = None
-        self.llm = get_llm(model)
+        self.llm = load_chat_model(model)
         self.cli = RichCLI()
 
     async def _build_graph(self):
@@ -47,6 +47,7 @@ class BaseAgent:
         return await self._graph.ainvoke(
             {"messages": [{"role": "user", "content": user_input}]},
             config={"configurable": {"thread_id": thread_id}},
+            context={"system_prompt": self.instructions, "model": self.model},
         )
 
     async def run_interactive(self, thread_id: str = str(uuid4())):

universal_mcp/agents/codeact/test.py

@@ -1,10 +1,10 @@
 from universal_mcp.agentr import Agentr
 from universal_mcp.agents.codeact import create_codeact
 from universal_mcp.agents.codeact.sandbox import eval_unsafe
-from universal_mcp.agents.llm import get_llm
+from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.tools.adapters import ToolFormat
 
-model = get_llm("gpt-4.1")
+model = load_chat_model("gpt-4.1")
 
 agentr = Agentr()
 agentr.load_tools(["google-mail_send_email"])

universal_mcp/agents/hil.py

@@ -7,7 +7,7 @@ from langgraph.graph.message import add_messages
 from langgraph.types import Interrupt, interrupt
 
 from .base import BaseAgent
-from .llm import get_llm
+from .llm import load_chat_model
 
 
 class State(TypedDict):
@@ -70,7 +70,7 @@ def handle_interrupt(interrupt: Interrupt) -> str | bool:
 class HilAgent(BaseAgent):
     def __init__(self, name: str, instructions: str, model: str):
         super().__init__(name, instructions, model)
-        self.llm = get_llm(model)
+        self.llm = load_chat_model(model)
         self._graph = self._build_graph()
 
     def chatbot(self, state: State):

universal_mcp/agents/llm.py

@@ -1,10 +1,28 @@
+from langchain_anthropic import ChatAnthropic
+from langchain_core.language_models import BaseChatModel
+from langchain_google_vertexai.model_garden import ChatAnthropicVertex
 from langchain_openai import AzureChatOpenAI
 
 
-def get_llm(model: str, tags: list[str] | None = None):
-    return AzureChatOpenAI(model=model, api_version="2024-12-01-preview", azure_deployment=model, tags=tags)
+def load_chat_model(fully_specified_name: str, tags: list[str] | None = None) -> BaseChatModel:
+    """Load a chat model from a fully specified name.
+
+    Args:
+        fully_specified_name (str): String in the format 'provider/model'.
+    """
+    provider, model = fully_specified_name.split("/", maxsplit=1)
+    if provider == "google_anthropic_vertex":
+        return ChatAnthropicVertex(model=model, temperature=0.2, location="asia-east1", tags=tags)
+    elif provider == "anthropic":
+        return ChatAnthropic(
+            model=model, temperature=1, thinking={"type": "enabled", "budget_tokens": 2048}, max_tokens=4096, tags=tags
+        )  # pyright: ignore[reportCallIssue]
+    elif provider == "azure":
+        return AzureChatOpenAI(model=model, api_version="2024-12-01-preview", azure_deployment=model, tags=tags)
+    else:
+        raise ValueError(f"Unsupported provider: {provider}")
 
 
 if __name__ == "__main__":
-    llm = get_llm("gpt-4.1")
+    llm = load_chat_model("azure/gpt-4.1")
     print(llm.invoke("Hello, world!"))

universal_mcp/agents/react.py

@@ -60,5 +60,7 @@ if __name__ == "__main__":
         model="gpt-4o",
         tools=ToolConfig(agentrServers={"google-mail": {"tools": ["send_email"]}}),
     )
-    result = asyncio.run(agent.run(user_input="Send an email with the subject 'Hello' to john.doe@example.com"))
+    result = asyncio.run(
+        agent.run(user_input="Send an email with the subject 'testing react agent' to manoj@agentr.dev")
+    )
     print(result["messages"][-1].content)

universal_mcp/agents/simple.py

@@ -5,8 +5,8 @@ from langgraph.graph import END, START, StateGraph
 from langgraph.graph.message import add_messages
 from typing_extensions import TypedDict
 
-from .base import BaseAgent
-from .llm import get_llm
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
 
 
 class State(TypedDict):
@@ -16,7 +16,7 @@ class State(TypedDict):
 class SimpleAgent(BaseAgent):
     def __init__(self, name: str, instructions: str, model: str):
         super().__init__(name, instructions, model)
-        self.llm = get_llm(model)
+        self.llm = load_chat_model(model)
         self._graph = self._build_graph()
 
     def _build_graph(self):

universal_mcp/tools/registry.py

@@ -1,6 +1,8 @@
 from abc import ABC, abstractmethod
 from typing import Any
 
+from universal_mcp.tools.manager import ToolManager
+
 
 class ToolRegistry(ABC):
     """Abstract base class for platform-specific functionality.
@@ -11,7 +13,7 @@ class ToolRegistry(ABC):
     """
 
     @abstractmethod
-    async def list_apps(self) -> list[dict[str, Any]]:
+    def list_apps(self) -> list[dict[str, Any]]:
         """Get list of available apps from the platform.
 
         Returns:
@@ -20,7 +22,7 @@ class ToolRegistry(ABC):
         pass
 
     @abstractmethod
-    async def get_app_details(self, app_id: str) -> dict[str, Any]:
+    def get_app_details(self, app_id: str) -> dict[str, Any]:
         """Get detailed information about a specific app.
 
         Args:
@@ -32,10 +34,18 @@ class ToolRegistry(ABC):
         pass
 
     @abstractmethod
-    async def load_tools(self, tools: list[str]) -> None:
+    def load_tools(self, tools: list[str], tool_manager: ToolManager) -> None:
         """Load tools from the platform and register them as tools.
 
         Args:
             tools: The list of tools to load
         """
         pass
+
+    @abstractmethod
+    def search_tools(
+        self,
+        query: str,
+    ) -> list[str]:
+        """Retrieve a tool to use, given a search query."""
+        pass

{universal_mcp-0.1.24rc6.dist-info → universal_mcp-0.1.24rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc6
+Version: 0.1.24rc7
 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
@@ -9,9 +9,12 @@ Requires-Python: >=3.11
 Requires-Dist: black>=25.1.0
 Requires-Dist: cookiecutter>=2.6.0
 Requires-Dist: gql>=4.0.0
+Requires-Dist: httpx-aiohttp>=0.1.8
 Requires-Dist: jinja2>=3.1.3
 Requires-Dist: jsonref>=1.1.0
 Requires-Dist: keyring>=25.6.0
+Requires-Dist: langchain-anthropic>=0.3.19
+Requires-Dist: langchain-google-vertexai>=2.0.28
 Requires-Dist: langchain-mcp-adapters>=0.1.9
 Requires-Dist: langchain-openai>=0.3.27
 Requires-Dist: langgraph-cli[inmem]>=0.3.4

{universal_mcp-0.1.24rc6.dist-info → universal_mcp-0.1.24rc7.dist-info}/RECORD

@@ -6,26 +6,34 @@ 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=jeUEkUnwdGWo3T_qSRSF83u0fYpuydaWzdKlCYBlCQA,770
-universal_mcp/agentr/README.md,sha256=xXM8JzPyrM2__pGhxHrGEUn9uP2y2bdF00wwcQtBUCI,6441
+universal_mcp/agentr/README.md,sha256=t15pVgkCwZM5wzgLgrf0Zv6hVL7dPmKXvAeTf8CiXPQ,6641
 universal_mcp/agentr/__init__.py,sha256=ogOhH_OJwkoUZu_2nQJc7-vEGmYQxEjOE511-6ubrX0,217
-universal_mcp/agentr/agentr.py,sha256=JfawuREfXAyeNUE7o58DzTPhmQXuwsB_Da7c1Gf3Qxw,1059
-universal_mcp/agentr/client.py,sha256=oyF6VKq56UMVf5L1WnFTMSZ85W8Qcy-5HZ5XOGiIELM,4139
+universal_mcp/agentr/agentr.py,sha256=kTUiBpDl4ODuXit9VE_ZXW28IKpCqEnJDNtMXi2B3Pc,1245
+universal_mcp/agentr/client.py,sha256=B4pjIpfD5nDCZ9qldKIqlBV8DISrkTRrajCIQK4r4Hs,6232
 universal_mcp/agentr/integration.py,sha256=V5GjqocqS02tRoI8MeV9PL6m-BzejwBzgJhOHo4MxAE,4212
-universal_mcp/agentr/registry.py,sha256=b9sr5JyT3HLj3e7GFpdXpT7ofGwLQc--y8k2DqF5dE0,3542
+universal_mcp/agentr/registry.py,sha256=BOxy9iuJagKLmH9komaabwXvUglrsWbpRX8WY9xJ7lI,3115
 universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
-universal_mcp/agents/__init__.py,sha256=vgixOLTCcCmSweENV7GSAuOPyHXlE4XAbvOXyr4MrRA,185
-universal_mcp/agents/auto.py,sha256=o__71BCOHSfaj7Xt0PhsamVXdeP4o7irhtmu1q6-3Fo,25336
-universal_mcp/agents/base.py,sha256=aplcZ-OKva3hFMB5uzoAPCB0ZDh3BL3FlJV39sJYYZ8,4057
+universal_mcp/agents/__init__.py,sha256=ZkdQ71fn838LvYdyln6fL1mUMUUCZRZMyqos4aW2_I4,265
+universal_mcp/agents/auto.py,sha256=UUx3p9riLww2OwRg0pg10mWzWdDNydBrKJ-UdwzAQSk,25411
+universal_mcp/agents/base.py,sha256=uRb-flv_pdKfDJnHID1c-loYt-EvlAgFmB1_wJQNhUs,4152
 universal_mcp/agents/cli.py,sha256=7GdRBpu9rhZPiC2vaNQXWI7K-0yCnvdlmE0IFpvy2Gk,539
-universal_mcp/agents/hil.py,sha256=CTgX7CoFEyTFIaNaL-id2WALOPd0VBb79pHkQK8quM8,3671
-universal_mcp/agents/llm.py,sha256=YNxN43bVhGfdYs09yPkdkGCKJkj-2UNqkB1EFmtnUS4,309
-universal_mcp/agents/react.py,sha256=cpE4wzySnyEdhz-c1T1FDA3w68nRByz7yWFt8FefUBo,2361
-universal_mcp/agents/simple.py,sha256=UfmQIIff--_Y0DQ6oivRciHqSZvRqy_qwQn_UYVzYy8,1146
+universal_mcp/agents/hil.py,sha256=6xi0hhK5g-rhCrAMcGbjcKMReLWPC8rnFZMBOF3N_cY,3687
+universal_mcp/agents/llm.py,sha256=0HUI2Srh3RWtGyrjJCKqsroEgc1Rtkta3T8I1axl1mg,1232
+universal_mcp/agents/react.py,sha256=kAyTS68xzBLWRNgjJrLSP85o1ligz_ziatdlMZAavnA,2385
+universal_mcp/agents/simple.py,sha256=CXmwJq7jvxAoDJifNK7jKJTMKG4Pvre75x-k2CE-ZEM,1202
 universal_mcp/agents/tools.py,sha256=7Vdw0VZYxXVAzAYSpRKWHzVl9Ll6NOnVRlc4cTXguUQ,1335
 universal_mcp/agents/utils.py,sha256=7kwFpD0Rv6JqHG-LlNCVwSu_xRX-N119mUmiBroHJL4,4109
+universal_mcp/agents/autoagent/__init__.py,sha256=Vfm8brM9TNXCjKbVXV-CAPg_BVnYHOn6RVmkS0EaNV0,1072
+universal_mcp/agents/autoagent/__main__.py,sha256=FUSETuCDMpp7VSis0UFDnpI32HmQuJYaAXaOX5fQl-4,622
+universal_mcp/agents/autoagent/context.py,sha256=1ic3sIL14XZeiMjpkwysLImRTQFKXRFSx7rvgVh4plY,802
+universal_mcp/agents/autoagent/graph.py,sha256=f_TPcMk0t4JgM1gYs4sLFIeCrTGAzecc2rN0MPsmxvs,5116
+universal_mcp/agents/autoagent/prompts.py,sha256=DwLHwvsISuNrxeua0tKxTQbkU8u9gljCpk3P18VGk4w,386
+universal_mcp/agents/autoagent/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
+universal_mcp/agents/autoagent/studio.py,sha256=FWmZTAH54euF0ePG6xCBNwklBjdmjZ3jAOBoTrwNcqs,656
+universal_mcp/agents/autoagent/utils.py,sha256=AFq-8scw_WlSZxDnTzxSNrOSiGYsIlqkqtQLDWf_rMU,431
 universal_mcp/agents/codeact/__init__.py,sha256=5D_I3lI_3tWjZERRoFav_bPe9UDaJ53pDzZYtyixg3E,10097
 universal_mcp/agents/codeact/sandbox.py,sha256=lGRzhuXTHCB1qauuOI3bH1-fPTsyL6Lf9EmMIz4C2xQ,1039
-universal_mcp/agents/codeact/test.py,sha256=bva-KkBNbGZn2f9nmmo9SNPQnY24Ni5gLHhJ5I0cm0k,481
+universal_mcp/agents/codeact/test.py,sha256=AI3qWszpM46hF4wzuQm6A8g_UkhGmcg9KhHtk9u14ro,497
 universal_mcp/agents/codeact/utils.py,sha256=VuMvLTxBBh3pgaJk8RWj5AK8XZFF-1gnZJ6jFLeM_CI,1690
 universal_mcp/applications/__init__.py,sha256=HrCnGdAT7w4puw2_VulBfjOLku9D5DuMaOwAuQzu6nI,2067
 universal_mcp/applications/application.py,sha256=pGF9Rb2D6qzlaSwlcfZ-dNqPtsLkQTqL3jpsRuJ6-qE,23835
@@ -44,7 +52,7 @@ universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESo
 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=24Rkn5Uvv_AuYAtjeMq986bJ7uzTaGE1290uB9eDtRE,10435
-universal_mcp/tools/registry.py,sha256=XsmVZL1rY5XgIBPTmvKKBWFLAvB3d9LfYMb11b4wSPI,1169
+universal_mcp/tools/registry.py,sha256=EA-xJ6GCYGajUVCrRmPIpr9Xekwxnqhmso8ztfsTeE8,1401
 universal_mcp/tools/tools.py,sha256=Lk-wUO3rfhwdxaRANtC7lQr5fXi7nclf0oHzxNAb79Q,4927
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
 universal_mcp/utils/common.py,sha256=3aJK3AnBkmYf-dbsFLaEu_dGuXQ0Qi2HuqYTueLVhXQ,10968
@@ -65,8 +73,8 @@ universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vH
 universal_mcp/utils/openapi/test_generator.py,sha256=h44gQXEXmrw4pD3-XNHKB7T9c2lDomqrJxVO6oszCqM,12186
 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.24rc6.dist-info/METADATA,sha256=5KFnUe9auDhLti6G6uogy93a3RuJIBc9un01LNoVBgU,3015
-universal_mcp-0.1.24rc6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.24rc6.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.24rc6.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.24rc6.dist-info/RECORD,,
+universal_mcp-0.1.24rc7.dist-info/METADATA,sha256=agZ4cb79U2UCRPE6V_NXT5pL-_gAxB2Gz04jsc9rVCs,3143
+universal_mcp-0.1.24rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc7.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc7.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc7.dist-info/RECORD,,