universal-mcp-agents 0.1.19rc1__py3-none-any.whl → 0.1.24rc3__py3-none-any.whl

universal_mcp/agents/unified/agent.py

@@ -1,289 +0,0 @@
-import json
-import re
-from typing import Literal, cast
-
-from langchain_core.messages import AIMessage, ToolMessage
-from langchain_core.tools import StructuredTool
-from langchain_core.tools import tool as create_tool
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.graph import START, StateGraph
-from langgraph.types import Command, RetryPolicy
-from loguru import logger
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig, ToolFormat
-
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.agents.utils import convert_tool_ids_to_dict, filter_retry_on, get_message_text
-
-from .llm_tool import smart_print
-from .prompts import (
-    PLAYBOOK_CONFIRMING_PROMPT,
-    PLAYBOOK_GENERATING_PROMPT,
-    PLAYBOOK_PLANNING_PROMPT,
-    create_default_prompt,
-)
-from .sandbox import eval_unsafe
-from .state import CodeActState
-from .tools import create_meta_tools, enter_playbook_mode, get_valid_tools
-from .utils import inject_context, smart_truncate
-
-
-class UnifiedAgent(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        memory: BaseCheckpointSaver | None = None,
-        tools: ToolConfig | None = None,
-        registry: ToolRegistry | None = None,
-        playbook_registry: object | None = None,
-        sandbox_timeout: int = 20,
-        **kwargs,
-    ):
-        super().__init__(
-            name=name,
-            instructions=instructions,
-            model=model,
-            memory=memory,
-            **kwargs,
-        )
-        self.model_instance = load_chat_model(model)
-        self.tools_config = tools or {}
-        self.registry = registry
-        self.playbook_registry = playbook_registry
-        self.sandbox_timeout = sandbox_timeout
-        self.eval_fn = eval_unsafe
-        if self.tools_config and not self.registry:
-            raise ValueError("Registry must be provided with tools")
-
-    async def _build_graph(self):  # noqa: PLR0915
-        meta_tools = create_meta_tools(self.registry)
-        additional_tools = [smart_print, meta_tools["web_search"]]
-        self.additional_tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in additional_tools]
-        self.default_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
-
-        async def call_model(state: CodeActState) -> Command[Literal["sandbox", "execute_tools"]]:
-            self.exported_tools = []
-
-            selected_tool_ids = state.get("selected_tool_ids", [])
-            self.exported_tools = await self.registry.export_tools(selected_tool_ids, ToolFormat.LANGCHAIN)
-            all_tools = self.exported_tools + self.additional_tools
-            self.final_instructions, self.tools_context = create_default_prompt(all_tools, self.instructions)
-            messages = [{"role": "user", "content": self.final_instructions}] + state["messages"]
-
-            if state.get("output"):
-                messages.append(
-                    {
-                        "role": "system",
-                        "content": f"The last code execution resulted in this output:\n{state['output']}",
-                    }
-                )
-
-            # Run the model and potentially loop for reflection
-            model_with_tools = self.model_instance.bind_tools(
-                tools=[
-                    enter_playbook_mode,
-                    meta_tools["search_functions"],
-                    meta_tools["load_functions"],
-                ],
-                tool_choice="auto",
-            )
-            response = cast(AIMessage, model_with_tools.invoke(messages))
-            response_text = get_message_text(response)
-            code_match = re.search(r"```python\n(.*?)\n```", response_text, re.DOTALL)
-
-            if code_match:
-                code = code_match.group(1).strip()
-                return Command(goto="sandbox", update={"messages": [response], "code": code, "output": ""})
-            elif response.tool_calls:
-                return Command(goto="execute_tools", update={"messages": [response]})
-            else:
-                return Command(update={"messages": [response]})
-
-        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "playbook", "sandbox"]]:
-            """Execute tool calls"""
-            last_message = state["messages"][-1]
-            tool_calls = last_message.tool_calls if isinstance(last_message, AIMessage) else []
-
-            tool_messages = []
-            new_tool_ids = []
-            ask_user = False
-            ai_msg = ""
-            tool_result = ""
-
-            for tool_call in tool_calls:
-                try:
-                    if tool_call["name"] == "enter_playbook_mode":
-                        tool_message = ToolMessage(
-                            content=json.dumps("Entered Playbook Mode."),
-                            name=tool_call["name"],
-                            tool_call_id=tool_call["id"],
-                        )
-                        return Command(
-                            goto="playbook",
-                            update={"playbook_mode": "planning", "messages": [tool_message]},  # Entered Playbook mode
-                        )
-                    elif tool_call["name"] == "load_functions":  # Handle load_functions separately
-                        valid_tools, unconnected_links = await get_valid_tools(
-                            tool_ids=tool_call["args"]["tool_ids"], registry=self.registry
-                        )
-                        new_tool_ids.extend(valid_tools)
-                        # Create tool message response
-                        tool_result = f"Successfully loaded {len(valid_tools)} tools: {valid_tools}"
-                        links = "\n".join(unconnected_links)
-                        if links:
-                            ask_user = True
-                            ai_msg = f"Please login to the following app(s) using the following links and let me know in order to proceed:\n {links} "
-                    elif tool_call["name"] == "search_functions":
-                        tool_result = await meta_tools["search_functions"].ainvoke(tool_call["args"])
-                except Exception as e:
-                    tool_result = f"Error during {tool_call}: {e}"
-
-                tool_message = ToolMessage(
-                    content=json.dumps(tool_result),
-                    name=tool_call["name"],
-                    tool_call_id=tool_call["id"],
-                )
-                tool_messages.append(tool_message)
-
-            if ask_user:
-                tool_messages.append(AIMessage(content=ai_msg))
-                return Command(update={"messages": tool_messages, "selected_tool_ids": new_tool_ids})
-
-            return Command(goto="call_model", update={"messages": tool_messages, "selected_tool_ids": new_tool_ids})
-
-        def sandbox(state: CodeActState) -> Command[Literal["call_model"]]:
-            code = state.get("code")
-
-            if not code:
-                logger.error("Sandbox called without code")
-                return Command(
-                    goto="call_model",
-                    update={"output": "Sandbox was called without any code to execute."},
-                )
-
-            previous_add_context = state.get("add_context", {})
-            add_context = inject_context(previous_add_context, self.tools_context)
-            existing_context = state.get("context", {})
-            context = {**existing_context, **add_context}
-            # Execute the script in the sandbox
-
-            output, new_context, new_add_context = self.eval_fn(
-                code, context, previous_add_context, 180
-            )  # default timeout 3 min
-            output = smart_truncate(output)
-
-            return Command(
-                goto="call_model",
-                update={
-                    "output": output,
-                    "code": "",
-                    "context": new_context,
-                    "add_context": new_add_context,
-                },
-            )
-
-        def playbook(state: CodeActState) -> Command[Literal["call_model"]]:
-            playbook_mode = state.get("playbook_mode")
-            if playbook_mode == "planning":
-                planning_instructions = self.instructions + PLAYBOOK_PLANNING_PROMPT
-                messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
-
-                response = self.model_instance.invoke(messages)
-                response = cast(AIMessage, response)
-                response_text = get_message_text(response)
-                # Extract plan from response text between triple backticks
-                plan_match = re.search(r"```(.*?)```", response_text, re.DOTALL)
-                if plan_match:
-                    plan = plan_match.group(1).strip()
-                else:
-                    plan = response_text.strip()
-                return Command(update={"messages": [response], "playbook_mode": "confirming", "plan": plan})
-
-            elif playbook_mode == "confirming":
-                confirmation_instructions = self.instructions + PLAYBOOK_CONFIRMING_PROMPT
-                messages = [{"role": "system", "content": confirmation_instructions}] + state["messages"]
-                response = self.model_instance.invoke(messages, stream=False)
-                response = get_message_text(response)
-                if "true" in response.lower():
-                    return Command(goto="playbook", update={"playbook_mode": "generating"})
-                else:
-                    return Command(goto="playbook", update={"playbook_mode": "planning"})
-
-            elif playbook_mode == "generating":
-                generating_instructions = self.instructions + PLAYBOOK_GENERATING_PROMPT
-                messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
-                response = cast(AIMessage, self.model_instance.invoke(messages))
-                raw_content = get_message_text(response)
-                func_code = raw_content.strip()
-                func_code = func_code.replace("```python", "").replace("```", "")
-                func_code = func_code.strip()
-
-                # Extract function name (handle both regular and async functions)
-                match = re.search(r"^\s*(?:async\s+)?def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", func_code, re.MULTILINE)
-                if match:
-                    function_name = match.group(1)
-                else:
-                    function_name = "generated_playbook"
-
-                # Save or update an Agent using the helper registry
-                saved_note = ""
-                try:
-                    if not self.playbook_registry:
-                        raise ValueError("Playbook registry is not configured")
-
-                    # Build instructions payload embedding the plan and function code
-                    instructions_payload = {
-                        "playbookPlan": state["plan"],
-                        "playbookScript": {
-                            "name": function_name,
-                            "code": func_code,
-                        },
-                    }
-
-                    # Convert tool ids list to dict
-                    tool_dict = convert_tool_ids_to_dict(state["selected_tool_ids"])
-
-                    res = self.playbook_registry.create_agent(
-                        name=function_name,
-                        description=f"Generated playbook: {function_name}",
-                        instructions=instructions_payload,
-                        tools=tool_dict,
-                        visibility="private",
-                    )
-                    saved_note = f"Successfully created your playbook! Check it out here: [View Playbook](https://wingmen.info/agents/{res.id})"
-                except Exception as e:
-                    saved_note = f"Failed to save generated playbook as Agent '{function_name}': {e}"
-
-                # Mock tool call for exit_playbook_mode (for testing/demonstration)
-                mock_exit_tool_call = {"name": "exit_playbook_mode", "args": {}, "id": "mock_exit_playbook_123"}
-                mock_assistant_message = AIMessage(content=saved_note, tool_calls=[mock_exit_tool_call])
-
-                # Mock tool response for exit_playbook_mode
-                mock_exit_tool_response = ToolMessage(
-                    content=json.dumps(f"Exited Playbook Mode.{saved_note}"),
-                    name="exit_playbook_mode",
-                    tool_call_id="mock_exit_playbook_123",
-                )
-
-                return Command(
-                    update={"messages": [mock_assistant_message, mock_exit_tool_response], "playbook_mode": "normal"}
-                )
-
-        def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
-            """Route to either normal mode or playbook creation"""
-            if state.get("playbook_mode") in ["planning", "confirming", "generating"]:
-                return "playbook"
-
-            return "call_model"
-
-        agent = StateGraph(state_schema=CodeActState)
-        agent.add_node(call_model, retry_policy=RetryPolicy(max_attempts=3, retry_on=filter_retry_on))
-        agent.add_node(sandbox)
-        agent.add_node(playbook)
-        agent.add_node(execute_tools)
-        agent.add_conditional_edges(START, route_entry)
-        # agent.add_edge(START, "call_model")
-        return agent.compile(checkpointer=self.memory)

universal_mcp/agents/unified/prompts.py

@@ -1,192 +0,0 @@
-import inspect
-import re
-from collections.abc import Sequence
-
-from langchain_core.tools import StructuredTool
-
-uneditable_prompt = """
-You are **Wingmen**, an AI Assistant created by AgentR — a creative, straight-forward, and direct principal software engineer with access to tools.
-
-Your job is to answer the user's question or perform the task they ask for.
-- Answer simple questions (which do not require you to write any code or access any external resources) directly. Note that any operation that involves using ONLY print functions should be answered directly.
-- For tasks requiring operations or access to external resources, you should achieve the task by writing Python code snippets inside markdown blocks (e.g., ```python ... ```).
-- You also have access to two tools for finding and loading more python functions- `search_functions` and `load_functions`, which you must use for finding functions for using different external applications. Prefer pre-loaded or functions already available when possible, and prioritize connected applications over unconnected ones. When this is not enough to break a tie between similar applications, ask the user.
-- In writing or natural language processing tasks DO NOT answer directly. Instead write python code using the AI functions provided to you for tasks like summarizing, text generation, classification, data extraction from text or unstructured data, etc. Avoid hardcoded approaches to classification, data extraction.
-- The code you write will be executed in a sandbox environment, and you can use the output of previous executions in your code. variables, functions, imports are retained.
-- Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is NOT visible to the user, so after the task is complete, you have to give the output to the user in a markdown format.
-- If needed, feel free to ask for more information from the user to clarify the task.
-
-GUIDELINES for writing code:
-- Variables defined at the top level of previous code snippets can be referenced in your code.
-- External functions which return a dict or list[dict] are ambiguous. Therefore, you MUST explore the structure of the returned data using `smart_print()` statements before using it, printing keys and values. `smart_print` truncates long strings from data, preventing huge output logs.
-- When an operation involves running a fixed set of steps on a list of items, run one run correctly and then use a for loop to run the steps on each item in the list.
-- In a single code snippet, try to achieve as much as possible.
-- You can only import libraries that come pre-installed with Python. For external functions, use the search and load tools to access them in the code.
-- For displaying final results to the user, you must present your output in markdown format, including image links, so that they are rendered and displayed to the user. The code output is NOT visible to the user.
-- Call all functions using keyword arguments only, never positional arguments.
-- Async Functions (Critical): Use them only as follows-
-Case 1: Top-level await without asyncio.run()
-    Wrap in async function and call with asyncio.run():
-    async def main():
-        result = await some_async_function()
-        return result
-    asyncio.run(main())
-Case 2: Using asyncio.run() directly
-If code already contains asyncio.run(), use as-is — do not wrap again:
-    asyncio.run(some_async_function())
-Rules:
-- Never use await outside an async function
-- Never use await asyncio.run()
-- Never nest asyncio.run() calls
-"""
-
-
-def make_safe_function_name(name: str) -> str:
-    """Convert a tool name to a valid Python function name."""
-    # Replace non-alphanumeric characters with underscores
-    safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
-    # Ensure the name doesn't start with a digit
-    if safe_name and safe_name[0].isdigit():
-        safe_name = f"tool_{safe_name}"
-    # Handle empty name edge case
-    if not safe_name:
-        safe_name = "unnamed_tool"
-    return safe_name
-
-
-def dedent(text):
-    """Remove any common leading whitespace from every line in `text`.
-
-    This can be used to make triple-quoted strings line up with the left
-    edge of the display, while still presenting them in the source code
-    in indented form.
-
-    Note that tabs and spaces are both treated as whitespace, but they
-    are not equal: the lines "  hello" and "\\thello" are
-    considered to have no common leading whitespace.
-
-    Entirely blank lines are normalized to a newline character.
-    """
-    # Look for the longest leading string of spaces and tabs common to
-    # all lines.
-    margin = None
-    _whitespace_only_re = re.compile("^[ \t]+$", re.MULTILINE)
-    _leading_whitespace_re = re.compile("(^[ \t]*)(?:[^ \t\n])", re.MULTILINE)
-    text = _whitespace_only_re.sub("", text)
-    indents = _leading_whitespace_re.findall(text)
-    for indent in indents:
-        if margin is None:
-            margin = indent
-
-        # Current line more deeply indented than previous winner:
-        # no change (previous winner is still on top).
-        elif indent.startswith(margin):
-            pass
-
-        # Current line consistent with and no deeper than previous winner:
-        # it's the new winner.
-        elif margin.startswith(indent):
-            margin = indent
-
-        # Find the largest common whitespace between current line and previous
-        # winner.
-        else:
-            for i, (x, y) in enumerate(zip(margin, indent)):
-                if x != y:
-                    margin = margin[:i]
-                    break
-
-    # sanity check (testing/debugging only)
-    if 0 and margin:
-        for line in text.split("\n"):
-            assert not line or line.startswith(margin), f"line = {line!r}, margin = {margin!r}"
-
-    if margin:
-        text = re.sub(r"(?m)^" + margin, "", text)
-    return text
-
-
-def indent(text, prefix, predicate=None):
-    """Adds 'prefix' to the beginning of selected lines in 'text'.
-
-    If 'predicate' is provided, 'prefix' will only be added to the lines
-    where 'predicate(line)' is True. If 'predicate' is not provided,
-    it will default to adding 'prefix' to all non-empty lines that do not
-    consist solely of whitespace characters.
-    """
-    if predicate is None:
-        # str.splitlines(True) doesn't produce empty string.
-        #  ''.splitlines(True) => []
-        #  'foo\n'.splitlines(True) => ['foo\n']
-        # So we can use just `not s.isspace()` here.
-        def predicate(s):
-            return not s.isspace()
-
-    prefixed_lines = []
-    for line in text.splitlines(True):
-        if predicate(line):
-            prefixed_lines.append(prefix)
-        prefixed_lines.append(line)
-
-    return "".join(prefixed_lines)
-
-
-def create_default_prompt(
-    tools: Sequence[StructuredTool],
-    base_prompt: str | None = None,
-):
-    system_prompt = uneditable_prompt.strip() + (
-        "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
-    )
-    tools_context = {}
-
-    for tool in tools:
-        if hasattr(tool, "func") and tool.func is not None:
-            tool_callable = tool.func
-            is_async = False
-        elif hasattr(tool, "coroutine") and tool.coroutine is not None:
-            tool_callable = tool.coroutine
-            is_async = True
-        system_prompt += f'''{"async " if is_async else ""}def {tool.name} {str(inspect.signature(tool_callable))}:
-    """{tool.description}"""
-    ...
-    '''
-        safe_name = make_safe_function_name(tool.name)
-        tools_context[safe_name] = tool_callable
-
-    if base_prompt and base_prompt.strip():
-        system_prompt += f"Your goal is to perform the following task:\n\n{base_prompt}"
-
-    return system_prompt, tools_context
-
-
-PLAYBOOK_PLANNING_PROMPT = """Now, you are tasked with creating a reusable playbook from the user's previous workflow.
-
-TASK: Analyze the conversation history and code execution to create a step-by-step plan for a reusable function. Do not include the searching and loading of tools. Assume that the tools have already been loaded.
-
-Your plan should:
-1. Identify the key steps in the workflow
-2. Mark user-specific variables that should become the main playbook function parameters using `variable_name` syntax. Intermediate variables should not be highlighted using ``
-3. Keep the logic generic and reusable
-4. Be clear and concise
-
-Example:
-```
-1. Connect to database using `db_connection_string`
-2. Query user data for `user_id`
-3. Process results and calculate `metric_name`
-4. Send notification to `email_address`
-```
-
-Now create a plan based on the conversation history. Enclose it between ``` and ```. Ask the user if the plan is okay."""
-
-
-PLAYBOOK_CONFIRMING_PROMPT = """Now, you are tasked with confirming the playbook plan. Return True if the user is happy with the plan, False otherwise. Do not say anything else in your response. The user response will be the last message in the chain.
-"""
-
-PLAYBOOK_GENERATING_PROMPT = """Now, you are tasked with generating the playbook function. Return the function in Python code.
-Do not include any other text in your response.
-The function should be a single, complete piece of code that can be executed independently, based on previously executed code snippets that executed correctly.
-The parameters of the function should be the same as the final confirmed playbook plan.
-Do not include anything other than python code in your response
-"""

universal_mcp/agents/unified/tools.py

@@ -1,188 +0,0 @@
-import asyncio
-from collections import defaultdict
-from typing import Any
-
-from langchain_core.tools import tool
-from universal_mcp.tools.registry import ToolRegistry
-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."""
-    return
-
-
-def exit_playbook_mode():
-    """Call this function to exit playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
-    return
-
-
-def create_meta_tools(tool_registry: ToolRegistry) -> 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
-
-    @tool
-    async def load_functions(tool_ids: list[str]) -> str:
-        """Load specific functions by their IDs for use in subsequent steps.
-
-        Args:
-            tool_ids: Function ids in the form 'app__function'. Example: 'google_mail__send_email'
-
-        Returns:
-            Confirmation message about loaded functions
-        """
-        return f"Successfully loaded {len(tool_ids)} functions: {tool_ids}"
-
-    @tool
-    async def web_search(query: str) -> dict:
-        """
-        Get an LLM answer to a question informed by Exa search results.
-
-        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")
-        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
-        """
-        await tool_registry.export_tools(["exa__answer"], ToolFormat.LANGCHAIN)
-        response = await tool_registry.call_tool("exa__answer", {"query": query, "text": True})
-
-        # Extract only desired fields
-        return {
-            "answer": response.get("answer"),
-            "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]]:
-    """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()
-    connected_apps = {connection["app_id"] for connection in connections}
-    unconnected = set()
-    unconnected_links = []
-    app_tool_list: dict[str, set[str]] = {}
-
-    # Group tool_ids by app for fewer registry calls
-    app_to_tools: dict[str, list[tuple[str, str]]] = {}
-    for tool_id in tool_ids:
-        if "__" not in tool_id:
-            incorrect.append(tool_id)
-            continue
-        app, tool_name = tool_id.split("__", 1)
-        app_to_tools.setdefault(app, []).append((tool_id, tool_name))
-
-    # Fetch all apps concurrently
-    async def fetch_tools(app: str):
-        try:
-            tools_dict = await registry.list_tools(app)
-            return app, {tool_unit["name"] for tool_unit in tools_dict}
-        except Exception:
-            return app, None
-
-    results = await asyncio.gather(*(fetch_tools(app) for app in app_to_tools))
-
-    # Build map of available tools per app
-    for app, tools in results:
-        if tools is not None:
-            app_tool_list[app] = tools
-
-    # Validate tool_ids
-    for app, tool_entries in app_to_tools.items():
-        available = app_tool_list.get(app)
-        if available is None:
-            incorrect.extend(tool_id for tool_id, _ in tool_entries)
-            continue
-        if app not in connected_apps and app not in unconnected:
-            unconnected.add(app)
-            text = registry.client.get_authorization_url(app)
-            start = text.find(":") + 1
-            end = text.find(". R", start)
-            url = text[start:end].strip()
-            markdown_link = f"[{app}]({url})"
-            unconnected_links.append(markdown_link)
-        for tool_id, tool_name in tool_entries:
-            if tool_name in available:
-                correct.append(tool_id)
-            else:
-                incorrect.append(tool_id)
-
-    return correct, unconnected_links