universal-mcp-agents 0.1.19rc1__py3-none-any.whl → 0.1.20rc1__py3-none-any.whl

universal_mcp/agents/codeact0/tools.py

@@ -1,13 +1,13 @@
 import asyncio
+import json
 from collections import defaultdict
-from typing import Any
+from typing import Annotated, Any
 
 from langchain_core.tools import tool
-from universal_mcp.tools.registry import ToolRegistry
+from pydantic import Field
+from universal_mcp.agentr.registry import AgentrRegistry
 from universal_mcp.types import ToolFormat
 
-MAX_LENGHT = 100
-
 
 def enter_playbook_mode():
     """Call this function to enter playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
@@ -19,77 +19,180 @@ def exit_playbook_mode():
     return
 
 
-def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
+def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
     """Create the meta tools for searching and loading tools"""
 
     @tool
-    async def search_functions(queries: list[str]) -> str:
-        """Search for relevant functions given list of queries.
-        Each single query should be atomic (doable with a single function).
-        For tasks requiring multiple functions, add separate queries for each subtask"""
-        try:
-            # Fetch all connections
-            connections = await tool_registry.list_connected_apps()
-            connected_apps = {connection["app_id"] for connection in connections}
-
-            app_tools = defaultdict(set)
-            MAX_LENGTH = 20
-
-            # Process all queries concurrently
-            search_tasks = []
-            for query in queries:
-                search_tasks.append(_search_query_tools(query))
-
-            query_results = await asyncio.gather(*search_tasks)
-
-            # Aggregate results with limit per app and automatic deduplication
-            for tools_list in query_results:
-                for tool in tools_list:
-                    app = tool["id"].split("__")[0]
-                    tool_id = tool["id"]
-
-                    # Check if within limit and add to set (automatically deduplicates)
-                    if len(app_tools[app]) < MAX_LENGTH:
-                        cleaned_desc = tool["description"].split("Context:")[0].strip()
-                        app_tools[app].add(f"{tool_id}: {cleaned_desc}")
-
-            # Build result string efficiently
-            result_parts = []
-            for app, tools in app_tools.items():
-                app_status = "connected" if app in connected_apps else "NOT connected"
-                result_parts.append(f"Tools from {app} (status: {app_status} by user):")
-                # Convert set to sorted list for consistent output
-                for tool in sorted(tools):
-                    result_parts.append(f" - {tool}")
-                result_parts.append("")  # Empty line between apps
-
-            result_parts.append("Call load_functions to select the required functions only.")
-            return "\n".join(result_parts)
-
-        except Exception as e:
-            return f"Error: {e}"
-
-    async def _search_query_tools(query: str) -> list[dict]:
-        """Helper function to search apps and tools for a single query."""
-        # Start both searches concurrently
-        tools_search_task = tool_registry.search_tools(query, limit=10)
-        apps_search_task = tool_registry.search_apps(query, limit=4)
-
-        # Wait for both to complete
-        tools_from_general_search, apps_list = await asyncio.gather(tools_search_task, apps_search_task)
-
-        # Create tasks for searching tools from each app
-        app_tool_tasks = [tool_registry.search_tools(query, limit=5, app_id=app["id"]) for app in apps_list]
-
-        # Wait for all app-specific tool searches to complete
-        app_tools_results = await asyncio.gather(*app_tool_tasks)
-
-        # Combine all results
-        tools_list = list(tools_from_general_search)
-        for app_tools in app_tools_results:
-            tools_list.extend(app_tools)
-
-        return tools_list
+    async def search_functions(
+        queries: Annotated[
+            list[str] | str | None,
+            Field(description="A single query or a list of queries to search for relevant functions"),
+        ] = None,
+        app_id: Annotated[
+            str | None,
+            Field(description="The ID or common name of a specific application to search within"),
+        ] = None,
+    ) -> str:
+        """
+        Searches for relevant functions across applications based on queries and/or a specific app.
+        This function operates in three modes:
+
+        1.  **Global Search (provide `queries` only):**
+            - Use when the user wants to perform an action without specifying an application.
+            - The system will search across all available functions.
+            - Example: For "how can I create a presentation?", call with queries=["create presentation"].
+
+        2.  **App Discovery (provide `app_id` only):**
+            - Use when the user asks about the capabilities of a specific application.
+            - The `app_id` can be the common name of the app (e.g., "Gmail", "Google Drive").
+            - This will return all available functions for that application, up to a limit.
+            - Example: For "what can you do with Gmail?", call with app_id="Gmail".
+
+        3.  **Scoped Search (provide `queries` AND `app_id`):**
+            - Use when the user wants to perform an action within a specific application.
+            - This performs a targeted search only within the specified app's functions.
+            - Example: For "how do I find an email in Gmail?", call with queries=["find email"], app_id="Gmail".
+        """
+        if isinstance(queries, str):  # Handle JSON string input
+            try:
+                queries = json.loads(queries)
+            except json.JSONDecodeError:
+                # If it's a single query as a string, convert to list
+                queries = [queries] if queries else None
+
+        if not queries and not app_id:
+            raise ValueError("You must provide 'queries', an 'app_id', or both.")
+
+        registry = tool_registry
+        connections = await registry.list_connected_apps()
+        connected_app_ids = {connection["app_id"] for connection in connections}
+
+        canonical_app_id = None
+        found_tools_result = []
+
+        if app_id:
+            relevant_apps = await registry.search_apps(query=app_id, distance_threshold=0.7)
+            if not relevant_apps:
+                return {
+                    "found_tools": [],
+                    "message": f"Search failed. Application '{app_id}' was not found.",
+                }
+            canonical_app_id = relevant_apps[0]["id"]
+
+        if canonical_app_id and not queries:
+            all_app_tools = await registry.search_tools(query="", app_id=canonical_app_id, limit=20)
+
+            tool_list = []
+            for tool in all_app_tools:
+                cleaned_description = tool.get("description", "").split("Context:")[0].strip()
+                tool_list.append({"id": tool["id"], "description": cleaned_description})
+
+            found_tools_result.append(
+                {
+                    "app_id": canonical_app_id,
+                    "connection_status": "connected" if canonical_app_id in connected_app_ids else "not_connected",
+                    "tools": tool_list,
+                }
+            )
+
+        else:
+            query_results = []
+            prioritized_app_id_list = []
+
+            if canonical_app_id:
+                prioritized_app_id_list = [canonical_app_id]
+            else:
+                # 1. Perform an initial broad search for tools.
+                initial_tool_search_tasks = [registry.search_tools(query=q, distance_threshold=0.7) for q in queries]
+                initial_tool_results = await asyncio.gather(*initial_tool_search_tasks)
+
+                # 2. Search for relevant apps.
+                app_search_tasks = [registry.search_apps(query=q, distance_threshold=0.7) for q in queries]
+                app_search_results = await asyncio.gather(*app_search_tasks)
+
+                # 3. Create a prioritized list of app IDs for the final search.
+                # Apps found via search_apps are considered higher priority and come first.
+                app_ids_from_apps = {app["id"] for result_list in app_search_results for app in result_list}
+                # Use a list to maintain order.
+                prioritized_app_id_list.extend(list(app_ids_from_apps))
+
+                # Add app_ids from the initial tool search, ensuring no duplicates.
+                app_ids_from_tools = {tool["app_id"] for result_list in initial_tool_results for tool in result_list}
+
+                for tool_app_id in app_ids_from_tools:
+                    if tool_app_id not in app_ids_from_apps:
+                        prioritized_app_id_list.append(tool_app_id)
+
+            # 4. Perform the final, comprehensive tool search across the prioritized list of apps.
+            if prioritized_app_id_list:
+                # print(f"Prioritized app IDs for final search: {prioritized_app_id_list}")
+                final_tool_search_tasks = []
+                for app_id_to_search in prioritized_app_id_list:
+                    for query in queries:
+                        final_tool_search_tasks.append(
+                            registry.search_tools(query=query, app_id=app_id_to_search, distance_threshold=0.7)
+                        )
+                query_results = await asyncio.gather(*final_tool_search_tasks)
+
+            # 5. Aggregate all found tools for easy lookup.
+            aggregated_tools = defaultdict(dict)
+            for tool_list in query_results:
+                for tool in tool_list:
+                    app_id_from_tool = tool.get("app_id", "unknown")
+                    tool_id = tool.get("id")
+                    if not tool_id or tool_id in aggregated_tools[app_id_from_tool]:
+                        continue
+                    cleaned_description = tool.get("description", "").split("Context:")[0].strip()
+                    aggregated_tools[app_id_from_tool][tool_id] = {
+                        "id": tool_id,
+                        "description": cleaned_description,
+                    }
+
+            # 6. Build the final results list, respecting the prioritized app order.
+            for app_id_from_list in prioritized_app_id_list:
+                if app_id_from_list in aggregated_tools and aggregated_tools[app_id_from_list]:
+                    found_tools_result.append(
+                        {
+                            "app_id": app_id_from_list,
+                            "connection_status": "connected"
+                            if app_id_from_list in connected_app_ids
+                            else "not_connected",
+                            "tools": list(aggregated_tools[app_id_from_list].values()),
+                        }
+                    )
+
+        # Build result string efficiently
+        result_parts = []
+        apps_in_results = {app["app_id"] for app in found_tools_result}
+        connected_apps_in_results = apps_in_results.intersection(connected_app_ids)
+
+        for app in found_tools_result:
+            app_id = app["app_id"]
+            connection_status = app["connection_status"]
+            tools = app["tools"]
+
+            app_status = "connected" if connection_status == "connected" else "NOT connected"
+            result_parts.append(f"Tools from {app_id} (status: {app_status} by user):")
+
+            for tool in tools:
+                tool_id = tool["id"]
+                description = tool["description"]
+                result_parts.append(f" - {tool_id}: {description}")
+            result_parts.append("")  # Empty line between apps
+
+        # Add connection status information
+        if len(connected_apps_in_results) == 0 and len(apps_in_results) > 0:
+            result_parts.append(
+                "Connection Status: None of the apps in the results are connected. You must ask the user to choose the application."
+            )
+        elif len(connected_apps_in_results) > 1:
+            connected_list = ", ".join(connected_apps_in_results)
+            result_parts.append(
+                f"Connection Status: Multiple apps are connected ({connected_list}). You must ask the user to select which application they want to use."
+            )
+
+        result_parts.append("Call load_functions to select the required functions only.")
+        return "\n".join(result_parts)
 
     @tool
     async def load_functions(tool_ids: list[str]) -> str:
@@ -105,34 +208,46 @@ def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
 
     @tool
     async def web_search(query: str) -> dict:
-        """
-        Get an LLM answer to a question informed by Exa search results.
+        """Get an LLM answer to a question informed by Perplexity web search results.
+        Useful when you need information from a wide range of real-time sources on the web.
+        Do not use this when you need to access contents of a specific webpage.
 
-        This tool performs an Exa `/answer` request, which:
-        1. Provides a **direct answer** for factual queries (e.g., "What is the capital of France?" → "Paris")
+        This tool performs a Perplexity request via `perplexity__answer_with_search`, which:
+        1. Provides a **direct answer** for factual queries with citation(s)
         2. Generates a **summary with citations** for open-ended questions
-        (e.g., "What is the state of AI in healthcare?" → A detailed summary with source links)
 
         Args:
             query (str): The question or topic to answer.
+
         Returns:
-            dict: A structured response containing only:
-                - answer (str): Generated answer
-                - citations (list[dict]): List of cited sources
+            dict: A structured response containing:
+                - answer (str): Generated answer with markdown formatting and citation numbers [1][2]
+                - citations (list[str]): List of source URLs corresponding to citation numbers
         """
-        await tool_registry.export_tools(["exa__answer"], ToolFormat.LANGCHAIN)
-        response = await tool_registry.call_tool("exa__answer", {"query": query, "text": True})
+        await tool_registry.export_tools(["perplexity__answer_with_search"], ToolFormat.LANGCHAIN)
+
+        response = await tool_registry.call_tool(
+            "perplexity__answer_with_search",
+            {
+                "query": query,
+                "model": "sonar",
+                "temperature": 1.0,
+                "system_prompt": (
+                    "You are a helpful AI assistant that answers questions using real-time information from the web."
+                ),
+            },
+        )
 
         # Extract only desired fields
         return {
-            "answer": response.get("answer"),
+            "answer": response.get("content"),
             "citations": response.get("citations", []),
         }
 
     return {"search_functions": search_functions, "load_functions": load_functions, "web_search": web_search}
 
 
-async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> tuple[list[str], list[str]]:
+async def get_valid_tools(tool_ids: list[str], registry: AgentrRegistry) -> tuple[list[str], list[str]]:
     """For a given list of tool_ids, validates the tools and returns a list of links for the apps that have not been logged in"""
     correct, incorrect = [], []
     connections = await registry.list_connected_apps()
@@ -173,7 +288,7 @@ async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> tuple[
             continue
         if app not in connected_apps and app not in unconnected:
             unconnected.add(app)
-            text = registry.client.get_authorization_url(app)
+            text = registry.authorise_app(app_id=app)
             start = text.find(":") + 1
             end = text.find(". R", start)
             url = text[start:end].strip()

{universal_mcp_agents-0.1.19rc1.dist-info → universal_mcp_agents-0.1.20rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.19rc1
+Version: 0.1.20rc1
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

universal_mcp_agents-0.1.20rc1.dist-info/RECORD

@@ -0,0 +1,44 @@
+universal_mcp/agents/__init__.py,sha256=Rh6vKqpwuZ2joC9nzLFHUI1G7jzbwwC3p0mgpH5qRgo,1112
+universal_mcp/agents/base.py,sha256=wkqa_W2R6sFgjTMXn2bWVfjarHYDsLvGbG8nN-jRp6E,7175
+universal_mcp/agents/cli.py,sha256=bXdpgxsOMjclm1STHJgx10ocX9EebQ11DrxH0p6KMZk,943
+universal_mcp/agents/hil.py,sha256=_5PCK6q0goGm8qylJq44aSp2MadP-yCPvhOJYKqWLMo,3808
+universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
+universal_mcp/agents/react.py,sha256=8XQvJ0HLVgc-K0qn9Ml48WGcgUGuIKtL67HatlT6Da0,3334
+universal_mcp/agents/sandbox.py,sha256=Int2O8JNFPlB8c7gb86KRxlNbuV0zdz5_NCo_GMcCds,2876
+universal_mcp/agents/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
+universal_mcp/agents/utils.py,sha256=P6W9k6XAOBp6tdjC2VTP4tE0B2M4-b1EDmr-ylJ47Pw,7765
+universal_mcp/agents/bigtool/__init__.py,sha256=mZG8dsaCVyKlm82otxtiTA225GIFLUCUUYPEIPF24uw,2299
+universal_mcp/agents/bigtool/__main__.py,sha256=0i-fbd2yQ90qa8n2nM3luqoJVN9Reh5HZXR5oK7SAck,445
+universal_mcp/agents/bigtool/agent.py,sha256=mtCDNN8WjE2hjJjooDqusmbferKBHeJMHrhXUPUWaVc,252
+universal_mcp/agents/bigtool/context.py,sha256=ny7gd-vvVpUOYAeQbAEUT0A6Vm6Nn2qGywxTzPBzYFg,929
+universal_mcp/agents/bigtool/graph.py,sha256=2Sy0dtevTWeT3hJDq4BDerZFvk_zJqx15j8VH2XLq8Y,5848
+universal_mcp/agents/bigtool/prompts.py,sha256=Joi5mCzZX63aM_6eBrMOKuNRHjTkceVIibSsGBGqhYE,2041
+universal_mcp/agents/bigtool/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
+universal_mcp/agents/bigtool/tools.py,sha256=-u80ta6xEaqzEMSzDVe3QZiTZm3YlgLkBD8WTghzClw,6315
+universal_mcp/agents/builder/__main__.py,sha256=VJDJOr-dJJerT53ibh5LVqIsMJ0m0sG2UlzFB784pKw,11680
+universal_mcp/agents/builder/builder.py,sha256=mh3MZpMVB1FE1DWzvMW9NnfiaF145VGn8cJzKSYUlzY,8587
+universal_mcp/agents/builder/helper.py,sha256=8igR1b3Gy_N2u3WxHYKIWzvw7F5BMnfpO2IU74v6vsw,2680
+universal_mcp/agents/builder/prompts.py,sha256=8Xs6uzTUHguDRngVMLak3lkXFkk2VV_uQXaDllzP5cI,4670
+universal_mcp/agents/builder/state.py,sha256=7DeWllxfN-yD6cd9wJ3KIgjO8TctkJvVjAbZT8W_zqk,922
+universal_mcp/agents/codeact0/__init__.py,sha256=8-fvUo1Sm6dURGI-lW-X3Kd78LqySYbb5NMkNJ4NDwg,76
+universal_mcp/agents/codeact0/__main__.py,sha256=_7qSz97YnRgYJTESkALS5_eBIGHiMjA5rhr3IAeBvVo,896
+universal_mcp/agents/codeact0/agent.py,sha256=qUcNniw8DyvEfpEuaWA9LDqDe0eiRPEHrZtysfdKY8k,14238
+universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
+universal_mcp/agents/codeact0/langgraph_agent.py,sha256=8nz2wq-LexImx-l1y9_f81fK72IQetnCeljwgnduNGY,420
+universal_mcp/agents/codeact0/llm_tool.py,sha256=q-hiqkKtjVmpyNceFoRgo7hvKh4HtQf_I1VudRUEPR0,11075
+universal_mcp/agents/codeact0/prompts.py,sha256=IZwiGLYISr_oXeNwhPJLNpE5wYd5zyntEdEUGH21OD8,10720
+universal_mcp/agents/codeact0/sandbox.py,sha256=Xw4tbUV_6haYIZZvteJi6lIYsW6ni_3DCRCOkslTKgM,4459
+universal_mcp/agents/codeact0/state.py,sha256=B1XF5ni9RvN6p5POHkPTm-KjEx5c8wRB7O1EJM8pbSQ,1297
+universal_mcp/agents/codeact0/tools.py,sha256=G580vy-m_BqlHc_j0yvLV5T_2d2G0JrD_eDhvDdJ9JA,13614
+universal_mcp/agents/codeact0/utils.py,sha256=jAZItSd3KGDkY9PquSWRIFCj9N26K9Kt0HKQ_jwvvSQ,15944
+universal_mcp/agents/shared/__main__.py,sha256=XxH5qGDpgFWfq7fwQfgKULXGiUgeTp_YKfcxftuVZq8,1452
+universal_mcp/agents/shared/prompts.py,sha256=yjP3zbbuKi87qCj21qwTTicz8TqtkKgnyGSeEjMu3ho,3761
+universal_mcp/agents/shared/tool_node.py,sha256=DC9F-Ri28Pam0u3sXWNODVgmj9PtAEUb5qP1qOoGgfs,9169
+universal_mcp/applications/filesystem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/filesystem/app.py,sha256=0TRjjm8YnslVRSmfkXI7qQOAlqWlD1eEn8Jm0xBeigs,5561
+universal_mcp/applications/llm/__init__.py,sha256=_XGRxN3O1--ZS5joAsPf8IlI9Qa6negsJrwJ5VJXno0,46
+universal_mcp/applications/llm/app.py,sha256=oqX3byvlFRmeRo4jJJxUBGy-iTDGm2fplMEKA2pcMtw,12743
+universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
+universal_mcp_agents-0.1.20rc1.dist-info/METADATA,sha256=49lAde7iqPxxgwPAb7BZCERlIkajP0EoiiuvtA7hy24,881
+universal_mcp_agents-0.1.20rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.20rc1.dist-info/RECORD,,

universal_mcp/agents/codeact/__init__.py

@@ -1,3 +0,0 @@
-from .agent import CodeActAgent
-
-__all__ = ["CodeActAgent"]

universal_mcp/agents/codeact/__main__.py

@@ -1,33 +0,0 @@
-import asyncio
-
-from langgraph.checkpoint.memory import MemorySaver
-from rich import print
-from universal_mcp.agentr.registry import AgentrRegistry
-
-from universal_mcp.agents.codeact.agent import CodeActAgent
-from universal_mcp.agents.utils import messages_to_list
-
-
-async def main():
-    memory = MemorySaver()
-    agent = CodeActAgent(
-        name="CodeAct Agent",
-        instructions="Be very concise in your answers.",
-        model="anthropic:claude-4-sonnet-20250514",
-        tools={"google_mail": ["list_messages"]},
-        registry=AgentrRegistry(),
-        memory=memory,
-    )
-    print("Starting agent...")
-    # await agent.ainit()
-    # await agent.run_interactive()
-    # async for event in agent.stream(
-    #     user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
-    # ):
-    #     print(event.content, end="")
-    result = await agent.invoke(user_input="Get the 50th fibonacci number")
-    print(messages_to_list(result["messages"]))
-
-
-if __name__ == "__main__":
-    asyncio.run(main())