universal-mcp-agents 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

universal_mcp/agents/shared/tool_node.py

@@ -1,260 +1,206 @@
 import asyncio
+from collections import defaultdict
 from typing import Annotated, TypedDict
 
 from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
+from langchain_core.messages import AIMessage, AnyMessage
 from langgraph.graph import END, StateGraph
 from langgraph.graph.message import add_messages
+from langgraph.types import Command
 from loguru import logger
 from pydantic import BaseModel, Field
 from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig
 
 from universal_mcp.agents.shared.prompts import (
-    APP_SEARCH_QUERY_PROMPT,
-    REVISE_DECOMPOSITION_PROMPT,
-    TASK_DECOMPOSITION_PROMPT,
-    TOOL_SEARCH_QUERY_PROMPT,
+    APP_SELECTION_PROMPT,
+    TOOL_SEARCH_QUERIES_PROMPT,
     TOOL_SELECTION_PROMPT,
 )
 
-MAX_DECOMPOSITION_ATTEMPTS = 2
+MAX_RETRIES = 1
 
-# --- Pydantic Models for Structured LLM Outputs ---
 
+class SearchQueries(BaseModel):
+    queries: list[str] = Field(description="A list of search queries for finding tools.")
 
-class TaskDecomposition(BaseModel):
-    sub_tasks: list[str] = Field(description="A list of sub-task descriptions.")
 
-
-class SearchQuery(BaseModel):
-    query: str = Field(description="A concise search query.")
+class AppSelection(BaseModel):
+    app_ids: list[str] = Field(description="The IDs of the selected applications.")
 
 
 class ToolSelection(BaseModel):
     tool_ids: list[str] = Field(description="The IDs of the selected tools.")
 
 
-# --- LangGraph Agent State ---
-
-
-class SubTask(TypedDict, total=False):
-    """Represents a single step in the execution plan."""
-
-    task: str
-    status: str  # "pending", "success", "failed"
-    app_id: str
-    tool_ids: list[str]
-    reasoning: str
-
-
 class AgentState(TypedDict):
     """The central state of our agent graph."""
 
     original_task: str
-    decomposition_attempts: int
-    failed_sub_task_info: str  # To inform re-decomposition
-    sub_tasks: list[SubTask]
-    execution_plan: list[SubTask]
+    queries: list[str]
+    candidate_tools: list[dict]
+    execution_plan: ToolConfig
     messages: Annotated[list[AnyMessage], add_messages]
-
-
-# --- Graph Builder ---
+    retry_count: int
 
 
 def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGraph:
-    """Builds the adaptive LangGraph workflow for tool selection."""
+    """Builds a workflow for tool selection with a retry mechanism."""
 
-    async def _decompose_task(state: AgentState) -> AgentState:
-        """Decomposes the main task or revises a failed decomposition."""
-        attempts = state.get("decomposition_attempts", 0)
+    async def _search_for_tools(state: AgentState) -> Command:
+        """
+        Performs a hierarchical search:
+        1. Generates search queries for the task.
+        2. Searches for candidate *applications*.
+        3. Uses an LLM to select the most relevant applications.
+        4. Searches for tools only within the selected applications.
+        If any step fails, it can trigger a retry.
+        """
         task = state["original_task"]
-        failed_info = state.get("failed_sub_task_info")
-
-        if attempts > 0 and failed_info:
-            logger.warning(f"Revising decomposition. Attempt {attempts + 1}.")
-            prompt = REVISE_DECOMPOSITION_PROMPT.format(task=task, failed_sub_task=failed_info)
-        else:
-            logger.info("Performing initial task decomposition.")
-            prompt = TASK_DECOMPOSITION_PROMPT.format(task=task)
-
-        response = await llm.with_structured_output(TaskDecomposition).ainvoke(prompt)
-        sub_tasks = [{"task": sub_task_str, "status": "pending"} for sub_task_str in response.sub_tasks]
-
-        return {
-            "sub_tasks": sub_tasks,
-            "decomposition_attempts": attempts + 1,
-            "messages": [AIMessage(content=f"New plan created with {len(sub_tasks)} steps.")],
-        }
-
-    async def _resolve_sub_tasks(state: AgentState) -> AgentState:
-        """Iterates through sub-tasks, providing full plan context to the app selection prompt."""
-        sub_tasks = state["sub_tasks"]
-        original_task = state["original_task"]
-        current_plan = []
-
-        for i, sub_task in enumerate(sub_tasks):
-            task_desc = sub_task["task"]
-            logger.info(f"Resolving sub-task: '{task_desc}'")
-
-            # 1. Build the FULL context string from the entire plan so far
-            if not current_plan:
-                plan_context_str = "None. This is the first step."
-            else:
-                context_lines = [
-                    f"- The sub-task '{step['task']}' was assigned to app '{step['app_id']}'." for step in current_plan
-                ]
-                plan_context_str = "\n".join(context_lines)
-
-            # 2. Generate the App-specific query using the NEW full-context prompt
-            app_query_prompt = APP_SEARCH_QUERY_PROMPT.format(
-                original_task=original_task, plan_context=plan_context_str, sub_task=task_desc
+        logger.info(f"Starting hierarchical tool search for task: '{task}'")
+
+        prompt = TOOL_SEARCH_QUERIES_PROMPT.format(task=task)
+        response = await llm.with_structured_output(SearchQueries).ainvoke(prompt)
+        queries = response.queries
+        logger.info(f"Generated search queries: {queries}")
+
+        if not queries:
+            logger.error("LLM failed to generate any search queries.")
+            return Command(
+                update={"messages": [AIMessage(content="I could not understand the task to search for tools.")]},
+                goto="handle_failure",
             )
-            app_query_response = await llm.with_structured_output(SearchQuery).ainvoke(app_query_prompt)
-            app_search_query = app_query_response.query
-            logger.info(f"Generated context-aware app search query: '{app_search_query}'")
-
-            # 3. Search for candidate apps (the rest of the logic is the same)
-            candidate_apps = await registry.search_apps(query=app_search_query, limit=5)
-            if not candidate_apps:
-                logger.error(f"No apps found for query '{app_search_query}' from sub-task: '{task_desc}'")
-                return {"failed_sub_task_info": task_desc, "sub_tasks": []}
-
-            # 4. Generate Action-specific query for finding the tool
-            tool_query_prompt = TOOL_SEARCH_QUERY_PROMPT.format(sub_task=task_desc)
-            tool_query_response = await llm.with_structured_output(SearchQuery).ainvoke(tool_query_prompt)
-            tool_search_query = tool_query_response.query
-            logger.info(f"Generated tool search query: '{tool_search_query}'")
-
-            # 5. Find a suitable tool within the candidate apps
-            tool_found = False
-            for app in candidate_apps:
-                app_id = app["id"]
-                logger.info(f"Searching for tools in app '{app_id}' with query '{tool_search_query}'...")
-
-                found_tools = await registry.search_tools(query=tool_search_query, app_id=app_id, limit=5)
-                if not found_tools:
-                    continue
-
-                tool_candidates_str = "\n - ".join([f"{tool['name']}: {tool['description']}" for tool in found_tools])
-                selection_prompt = TOOL_SELECTION_PROMPT.format(sub_task=task_desc, tool_candidates=tool_candidates_str)
-                selection_response = await llm.with_structured_output(ToolSelection).ainvoke(selection_prompt)
-
-                if selection_response.tool_ids:
-                    logger.success(f"Found and selected tool(s) {selection_response.tool_ids} in app '{app_id}'.")
-                    sub_task.update(
-                        {
-                            "status": "success",
-                            "app_id": app_id,
-                            "tool_ids": selection_response.tool_ids,
-                            "reasoning": f"Selected tool(s) {selection_response.tool_ids} from app '{app_id}' for sub-task.",
-                        }
-                    )
-                    current_plan.append(sub_task)
-                    tool_found = True
-                    break
-
-            if not tool_found:
-                logger.error(f"Could not find any suitable tool for sub-task: '{task_desc}'")
-                return {"failed_sub_task_info": task_desc, "sub_tasks": []}
-
-        return {"execution_plan": current_plan, "sub_tasks": []}
-
-    def _handle_planning_failure(state: AgentState) -> AgentState:
-        """Handles the case where all decomposition attempts have failed."""
-        logger.error("Maximum decomposition attempts reached. Planning failed.")
-        return {
-            "messages": [
-                AIMessage(
-                    content="I am unable to create a complete plan for this task with the available tools. Please try rephrasing your request."
-                )
-            ]
-        }
 
-    def _consolidate_plan(state: AgentState) -> AgentState:
-        """
-        NEW: Merges steps in the execution plan that use the same app_id.
-        It combines their tool_ids into a single unique list.
-        """
-        logger.info("Consolidating final execution plan.")
-        plan = state["execution_plan"]
-        merged_apps: dict[str, SubTask] = {}
-
-        for step in plan:
-            app_id = step["app_id"]
-            if app_id not in merged_apps:
-                # Store the first occurrence of this app
-                merged_apps[app_id] = step.copy()
-                merged_apps[app_id]["tool_ids"] = set(step["tool_ids"])
-            else:
-                # If app already seen, just update its set of tool_ids
-                merged_apps[app_id]["tool_ids"].update(step["tool_ids"])
+        # Always store queries for potential retry
+        update_state = {"queries": queries}
 
-        # Convert the merged dictionary back to a list of SubTasks
-        final_plan = []
-        for app_id, step_data in merged_apps.items():
-            step_data["tool_ids"] = sorted(list(step_data["tool_ids"]))
-            final_plan.append(step_data)
+        app_search_tasks = [registry.search_apps(query, distance_threshold=0.7) for query in queries]
+        app_results = await asyncio.gather(*app_search_tasks)
+        unique_apps = {app["id"]: app for app_list in app_results for app in app_list}
 
-        return {"execution_plan": final_plan}
+        if not unique_apps:
+            logger.warning(f"No applications found for queries: {queries}. Triggering retry.")
+            return Command(update=update_state, goto="general_search_and_select")
 
-    # --- Graph Definition ---
+        logger.info(f"Found {len(unique_apps)} candidate applications.")
 
-    workflow = StateGraph(AgentState)
+        app_candidates_str = "\n - ".join([f"{app['id']}: {app['description']}" for app in unique_apps.values()])
+        app_selection_prompt = APP_SELECTION_PROMPT.format(task=task, app_candidates=app_candidates_str)
+        app_selection_response = await llm.with_structured_output(AppSelection).ainvoke(app_selection_prompt)
+        selected_app_ids = app_selection_response.app_ids
 
-    workflow.add_node("decompose_task", _decompose_task)
-    workflow.add_node("resolve_sub_tasks", _resolve_sub_tasks)
-    workflow.add_node("consolidate_plan", _consolidate_plan)  # NEW NODE
-    workflow.add_node("handle_planning_failure", _handle_planning_failure)
+        if not selected_app_ids:
+            logger.warning("LLM did not select any applications from the candidate list. Triggering retry.")
+            return Command(update=update_state, goto="general_search_and_select")
 
-    workflow.set_entry_point("decompose_task")
+        logger.success(f"Selected {len(selected_app_ids)} applications: {selected_app_ids}")
 
-    def should_continue(state: AgentState):
-        if not state.get("sub_tasks"):  # Resolution failed or succeeded
-            if state.get("execution_plan"):
-                return "consolidate_plan"  # MODIFIED: Go to consolidate on success
-            elif state["decomposition_attempts"] >= MAX_DECOMPOSITION_ATTEMPTS:
-                return "handle_planning_failure"
-            else:
-                return "decompose_task"  # Re-try decomposition
-        else:
-            return "resolve_sub_tasks"
+        tool_search_tasks = [
+            registry.search_tools(task, app_id=app_id, distance_threshold=0.8) for app_id in selected_app_ids
+        ]
+        tool_results = await asyncio.gather(*tool_search_tasks)
+        candidate_tools = [tool for tool_list in tool_results for tool in tool_list]
 
-    workflow.add_conditional_edges("decompose_task", lambda s: "resolve_sub_tasks")
-    workflow.add_conditional_edges("resolve_sub_tasks", should_continue)
+        if not candidate_tools:
+            logger.warning(f"No tools found within the selected applications: {selected_app_ids}. Triggering retry.")
+            return Command(update=update_state, goto="general_search_and_select")
 
-    workflow.add_edge("consolidate_plan", END)  # NEW EDGE
-    workflow.add_edge("handle_planning_failure", END)
+        logger.success(f"Found {len(candidate_tools)} candidate tools from selected apps.")
+        update_state["candidate_tools"] = candidate_tools
+        return Command(update=update_state, goto="select_tools_for_plan")
 
-    return workflow.compile()
+    async def _general_search_and_select(state: AgentState) -> Command:
+        """
+        A retry node that performs a general tool search without app filters.
+        """
+        task = state["original_task"]
+        queries = state["queries"]
+        retry_count = state.get("retry_count", 0)
+
+        if retry_count >= MAX_RETRIES:
+            logger.error("Max retries reached. Failing the planning process.")
+            return Command(
+                update={"messages": [AIMessage(content="I could not find any relevant tools after extensive searching.")]},
+                goto="handle_failure",
+            )
 
+        logger.info(f"--- RETRY {retry_count + 1}/{MAX_RETRIES} ---")
+        logger.info("Performing a general tool search without app filters.")
+
+        general_search_tasks = [
+            registry.search_tools(query, distance_threshold=0.85) for query in queries
+        ]
+        tool_results = await asyncio.gather(*general_search_tasks)
+        
+        unique_tools = {tool['id']: tool for tool_list in tool_results for tool in tool_list}
+        candidate_tools = list(unique_tools.values())
+
+        if not candidate_tools:
+            logger.error("General search (retry) also failed to find any tools.")
+            return Command(
+                update={
+                    "messages": [AIMessage(content="I could not find any tools for your request, even with a broader search.")],
+                    "retry_count": retry_count + 1,
+                },
+                goto="handle_failure",
+            )
 
-async def main():
-    """Main function to run the agent."""
-    from universal_mcp.agentr.registry import AgentrRegistry
+        logger.success(f"General search found {len(candidate_tools)} candidate tools.")
+        return Command(
+            update={"candidate_tools": candidate_tools, "retry_count": retry_count + 1},
+            goto="select_tools_for_plan",
+        )
 
-    from universal_mcp.agents.llm import load_chat_model
+    async def _select_tools_for_plan(state: AgentState) -> Command:
+        """Selects the best tools from the candidates and builds the final execution plan."""
+        task = state["original_task"]
+        candidate_tools = state["candidate_tools"]
+        retry_count = state.get("retry_count", 0)
+        logger.info("Starting tool selection from candidate list.")
+
+        tool_candidates_str = "\n - ".join([f"{tool['id']}: {tool['description']}" for tool in candidate_tools])
+        prompt = TOOL_SELECTION_PROMPT.format(task=task, tool_candidates=tool_candidates_str)
+        response = await llm.with_structured_output(ToolSelection).ainvoke(prompt)
+        selected_tool_ids = response.tool_ids
+
+        if not selected_tool_ids:
+            if retry_count >= MAX_RETRIES:
+                logger.error("LLM did not select any tools, even after a retry. Failing.")
+                return Command(
+                    update={"messages": [AIMessage(content="I found potential tools, but could not create a final plan.")]},
+                    goto="handle_failure",
+                )
+            else:
+                logger.warning("LLM did not select any tools from the current candidate list. Triggering general search.")
+                return Command(goto="general_search_and_select")
 
-    registry = AgentrRegistry()
-    llm = load_chat_model("anthropic/claude-4-sonnet-20250514")
 
-    graph = build_tool_node_graph(llm, registry)
+        logger.success(f"Selected {len(selected_tool_ids)} tools for the final plan: {selected_tool_ids}")
 
-    task = "Find my latest order confirmation in Gmail, search for reviews of the main product on perplexity, and then send an email to ankit@agentr.dev telling about the reviews"
+        final_plan = defaultdict(list)
+        for tool_id in selected_tool_ids:
+            if "__" in tool_id:
+                app_id, tool_name = tool_id.split("__", 1)
+                final_plan[app_id].append(tool_name)
 
-    initial_state = {
-        "original_task": task,
-        "messages": [HumanMessage(content=task)],
-        "decomposition_attempts": 0,
-    }
+        sorted_final_plan = {app_id: sorted(tools) for app_id, tools in final_plan.items()}
+        return Command(update={"execution_plan": sorted_final_plan}, goto=END)
 
-    final_state = await graph.ainvoke(initial_state)
+    def _handle_planning_failure(state: AgentState) -> Command:
+        """Handles cases where tool search or selection fails by logging the final error message."""
+        if messages := state.get("messages"):
+            last_message = messages[-1].content
+            logger.error(f"Planning failed. Final message: {last_message}")
+        else:
+            logger.error("Planning failed with no specific message.")
+        return Command(goto=END)
 
-    if final_state.get("execution_plan"):
-        for step in final_state["execution_plan"]:
-            pass
-    else:
-        pass
+    workflow = StateGraph(AgentState)
+    workflow.add_node("search_for_tools", _search_for_tools)
+    workflow.add_node("general_search_and_select", _general_search_and_select)
+    workflow.add_node("select_tools_for_plan", _select_tools_for_plan)
+    workflow.add_node("handle_failure", _handle_planning_failure)
 
+    workflow.set_entry_point("search_for_tools")
 
-if __name__ == "__main__":
-    asyncio.run(main())
+    return workflow.compile()

universal_mcp/agents/utils.py

@@ -9,6 +9,8 @@ from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.table import Table
+from pydantic import ValidationError
+from requests import JSONDecodeError
 
 
 class RichCLI:
@@ -143,3 +145,66 @@ def get_message_text(message: BaseMessage):
         logger.error(f"Error getting message text: {e}")
         logger.error(f"Message: {message}")
         raise e
+
+
+def filter_retry_on(exc: Exception) -> bool:
+    import httpx
+    import requests
+
+    # Transient local/network issues and parsing hiccups
+    if isinstance(
+        exc,
+        (
+            TimeoutError, 
+            ConnectionError, 
+            JSONDecodeError, 
+            ValidationError, 
+        ),
+    ):
+        return True
+
+    # httpx transient request-layer errors
+    if isinstance(
+        exc,
+        (
+            httpx.TimeoutException,
+            httpx.ConnectError,
+            httpx.ReadError,
+        ),
+    ):
+        return True
+
+    if isinstance(exc, (requests.Timeout, requests.ConnectionError)):
+        return True
+
+    # HTTP status based retries: 408 (timeout), 429 (rate limit), and 5xx
+    if isinstance(exc, httpx.HTTPStatusError):
+        status = exc.response.status_code
+        return status == 408 or status == 429 or 500 <= status < 600
+    if isinstance(exc, requests.HTTPError):
+        if exc.response is None:
+            return True
+        status = exc.response.status_code
+        return status == 408 or status == 429 or 500 <= status < 600
+
+    if isinstance(
+        exc,
+        (
+            ValueError,
+            TypeError,
+            ArithmeticError,
+            ImportError,
+            LookupError,
+            NameError,
+            SyntaxError,
+            RuntimeError,
+            ReferenceError,
+            StopIteration,
+            StopAsyncIteration,
+            OSError,
+        ),
+    ):
+        return False
+
+    # Default: do not retry unknown exceptions
+    return False

universal_mcp/applications/ui/app.py

@@ -1,10 +1,10 @@
 import os
 from typing import Any, Literal, TypedDict
 
-from dotenv import load_dotenv
 import httpx
-from universal_mcp.applications.application import BaseApplication
+from dotenv import load_dotenv
 from markitdown import MarkItDown
+from universal_mcp.applications.application import BaseApplication
 
 load_dotenv()
 

{universal_mcp_agents-0.1.12.dist-info → universal_mcp_agents-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.12
+Version: 0.1.14
 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.12.dist-info → universal_mcp_agents-0.1.14.dist-info}/RECORD

@@ -1,45 +1,45 @@
-universal_mcp/agents/__init__.py,sha256=xQ0Yoln3f0MQrqTQhAZ0im7Tp1DawEJ04YPp20Nw1DQ,1244
-universal_mcp/agents/base.py,sha256=le5vy02eXN15u8ntHWCu6Y-LgOmE_DA8tWmPOmLohAk,6908
-universal_mcp/agents/cli.py,sha256=Yv9g8VHOyK__V7me4UcWsWIXiviPz7F1vqMYH1jkCms,1016
+universal_mcp/agents/__init__.py,sha256=kM4mC6Pf6lmaaZF1volo7VtKgA8FDyzb1sNenpB7Ulk,1244
+universal_mcp/agents/base.py,sha256=xQ_zMHTvULaiE4LiE7IfhrLmlBtvJ5zVE9Rq2nJ4Hm4,6976
+universal_mcp/agents/cli.py,sha256=AG9e4iSX3GazT537573YrYT1wSaZYOr42rrYQ7xP3YA,1016
 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/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
-universal_mcp/agents/utils.py,sha256=QeysgwRCHvoe7LpIQkD05y9FGG7us4kWA8ApNj2ACr8,5274
-universal_mcp/agents/bigtool/__init__.py,sha256=uTA6KzZlRhL2reAUazwYmwCHFt9q4hERo27e13ifBX4,2250
+universal_mcp/agents/utils.py,sha256=pZFAqH__csH-gRLlTOnuU8kNix3_t5eC3yIk926FWpQ,6898
+universal_mcp/agents/bigtool/__init__.py,sha256=mZG8dsaCVyKlm82otxtiTA225GIFLUCUUYPEIPF24uw,2299
 universal_mcp/agents/bigtool/__main__.py,sha256=a15OUoqPR938x7eseWtxu0aLX7lRS3nu8k5Ks3giUY4,472
-universal_mcp/agents/bigtool/agent.py,sha256=anXjMgFWS95RYrnQsZJJxYq8HoCB6z9Poi-Uv5fhPis,266
+universal_mcp/agents/bigtool/agent.py,sha256=FsWa7S00RHmzrLd2ms_aR4wJ09h_KFJ8DDzFnADKJOQ,251
 universal_mcp/agents/bigtool/context.py,sha256=ny7gd-vvVpUOYAeQbAEUT0A6Vm6Nn2qGywxTzPBzYFg,929
-universal_mcp/agents/bigtool/graph.py,sha256=DEsuSm9OYWBTeGEmvPk_nv_yb7EvCflHe4pbja5-jC0,4337
-universal_mcp/agents/bigtool/prompts.py,sha256=Rz30qNGdscDG65vMj9d0Vfe7X1pQjBDQBBNc3BuyC94,1886
+universal_mcp/agents/bigtool/graph.py,sha256=SE1IavwrSciIWsb_miekEh3H46UJWpeIOkcp7CsRG_w,5764
+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=ynyEj9mVwKKDhxm76sjspyH51SFi63g2Vydi39pY0qY,5562
-universal_mcp/agents/builder/__main__.py,sha256=XaXpJNwkj5Os1Vn1er8wokPKd4O4WW_L2XkGkvqEhao,4912
-universal_mcp/agents/builder/builder.py,sha256=1p32txpFlG1l6XP1N5UOFAhNnQS02nmvA_uMDO5i-m4,9015
-universal_mcp/agents/builder/prompts.py,sha256=RFzDBdGxF5BsAQL09BVas9RjAwt_Q2ZACghG5pOxqas,8623
-universal_mcp/agents/builder/state.py,sha256=7DeWllxfN-yD6cd9wJ3KIgjO8TctkJvVjAbZT8W_zqk,922
+universal_mcp/agents/bigtool/tools.py,sha256=vlydQQnITS7OPaSzyILf3czrgO3_fEB-i7zItKcEWjU,6377
+universal_mcp/agents/builder/__main__.py,sha256=mGw5xHK53qNGgs6q7s2PPPPWozWPDKXD2AZGQTqCDQc,10750
+universal_mcp/agents/builder/builder.py,sha256=uhUOH6S7F2iWDhpNOpfzVUT1VB0MQnmcEkLPYJs65gY,8151
+universal_mcp/agents/builder/helper.py,sha256=G6IoXB433zAwfOGhDXOIGsf_EC9bbOSGN8WPWGSzmrk,2700
+universal_mcp/agents/builder/prompts.py,sha256=k0IfhWZ10zou3I2e3kczxf2zpY2AsPshjeY_h5oQ1KA,2673
+universal_mcp/agents/builder/state.py,sha256=nJrH-ChSpqv-fsXhvP4UkouVdQw0ji376uFM0aJ91D0,921
 universal_mcp/agents/codeact/__init__.py,sha256=rLE8gvOo5H4YSr71DRq76b3RV3uuotxuAy_VnBVaVwk,60
 universal_mcp/agents/codeact/__main__.py,sha256=W2cHXRwH1dZG3ETIkMwUqA_d62K3IctHP-FDZWDjxdw,1067
-universal_mcp/agents/codeact/agent.py,sha256=RRMeXVgn3Ow2gxhDKszx9hSUYGDTk6yqqDVyNIOu5kI,9778
+universal_mcp/agents/codeact/agent.py,sha256=sKZWokTHcuL68Y6SNyaaHe6_XkWxaIq36TrNmPJfQto,9762
 universal_mcp/agents/codeact/models.py,sha256=2fdAcF5bxWDpljjEwDEdPBflTMShSPwwncHrphRjsYg,222
 universal_mcp/agents/codeact/prompts.py,sha256=EMI-imnd0Ps0Bd2FOvSqgiicvvtFFu0MF9s93PiC_3k,4493
-universal_mcp/agents/codeact/sandbox.py,sha256=gEAmZ08PovnFmCKP7uIQaKXHFLOyrnuSmoh7E_SHhjQ,2307
+universal_mcp/agents/codeact/sandbox.py,sha256=NjN6ISj8psFtHf8V0w24ChJdUMUWkq7OrlbHdzm4wBc,2299
 universal_mcp/agents/codeact/state.py,sha256=WTPfpxDlGRnlr5tZuXMg_KU7GS7TZbnrIKslOvZLbQI,565
 universal_mcp/agents/codeact/utils.py,sha256=JUbT_HYGS_D1BzmzoVpORIe7SGur1KgJguTZ_1tZ4JY,1918
 universal_mcp/agents/codeact0/__init__.py,sha256=rLE8gvOo5H4YSr71DRq76b3RV3uuotxuAy_VnBVaVwk,60
 universal_mcp/agents/codeact0/__main__.py,sha256=V2wLWW9ym3rtiSvPEs-N0Mki7G5dYHzV5dAsAoF-ygQ,1148
-universal_mcp/agents/codeact0/agent.py,sha256=e1v_XVRqblKrAgrkyiPz7bs4atgDRTVHPnZQUjnT_4o,6495
+universal_mcp/agents/codeact0/agent.py,sha256=WmCHhhGN1q2Q1s14FN2kaNBEIVlYRoMpWJOqQEYjaBo,6538
 universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
-universal_mcp/agents/codeact0/langgraph_graph.py,sha256=mP3JrZ1I-Cqhk6E2DMRHUdLFevpyyad-Y3qhERn45JA,550
-universal_mcp/agents/codeact0/legacy_codeact.py,sha256=Lj4oH-AaP1zg6ifBkUxzWJcwMs9X5SepGzzZ6S5QMSg,4096
-universal_mcp/agents/codeact0/llm_tool.py,sha256=GEG8L2crRPyO5la_wlHohuqI9m6xH9KXgQxcP5fCFuU,13814
-universal_mcp/agents/codeact0/prompts.py,sha256=GTUwnxyyUVdeAoAwo4ODGOlEtZStMkoP_lJEFRbDglY,7324
+universal_mcp/agents/codeact0/langgraph_agent.py,sha256=8-Y3-OOEpY_XLcnjvFX-KyAQA5SzBjya3YBrrV9Qh_8,652
+universal_mcp/agents/codeact0/llm_tool.py,sha256=9xgRylNZo3lya33L3iqS7yipJYaHCeUEEBCfjUp71vc,13821
+universal_mcp/agents/codeact0/prompts.py,sha256=VT3v61JkAvZwjQoxwKR3QsYdkbyd_1E8bIm3oABNfMg,7512
 universal_mcp/agents/codeact0/sandbox.py,sha256=tkrhQoV7sAIT5rtd5kpNYEgDz4y82WSHKpMGE6bqthE,3108
 universal_mcp/agents/codeact0/state.py,sha256=kcoCoz-kd0Ukw1YNGDHNggixCK34KzMl2t6GztakSo4,412
-universal_mcp/agents/codeact0/utils.py,sha256=QIT4XIUln9o3H7MOmMen7i-dhDgvM8q0p--oy9Kbkss,15345
+universal_mcp/agents/codeact0/utils.py,sha256=6yeUVsB2CkcrutHjfpMI3KsMJkVpFj3Piag6A2IG0Jc,14733
 universal_mcp/agents/codeact0/usecases/1-unsubscribe.yaml,sha256=DiChHW-mNOcaaiec7f_04_A0Xyf9a2ihzXiPA9-Fw1I,239
 universal_mcp/agents/codeact0/usecases/10-reddit2.yaml,sha256=R3vrZZNv_E-m_SuSJ5tSv11HqMomm8Gtxp_LDhkrnAw,618
-universal_mcp/agents/codeact0/usecases/11-github.yaml,sha256=IRom0gDPcj0w0qa2LSARQbvrwJhLGQRaHI2U2rglcG0,650
+universal_mcp/agents/codeact0/usecases/11-github.yaml,sha256=iu4-vlvopPct9vfAseElLXPUAWN5sMVri4oMbDYlA4s,672
 universal_mcp/agents/codeact0/usecases/2-reddit.yaml,sha256=-dstvFMjsuP9UQM3B_G1HBn7ImNIMxSCNbITpfwgwAY,2525
 universal_mcp/agents/codeact0/usecases/2.1-instructions.md,sha256=0gQBY_A3jT_lgKNiu6GdyEYupbX0Xz2unlCoTQwv-Es,5098
 universal_mcp/agents/codeact0/usecases/2.2-instructions.md,sha256=Cx-VkcC55MrgFxlMBMBCD83jEge_yZgBWKwtuK1OPFc,4458
@@ -55,11 +55,12 @@ universal_mcp/agents/planner/__main__.py,sha256=OfhTfYDZK_ZUfc8sX-Sa6TWk-dNqD2rl
 universal_mcp/agents/planner/graph.py,sha256=70hhIoEZOcYojpiyVSCedgYpnmxVP7aqdn8s6VBu-D4,3228
 universal_mcp/agents/planner/prompts.py,sha256=_JoHqiAvswtqCDu90AGUHmfsu8eWE1-_yI4LLn3pqMU,657
 universal_mcp/agents/planner/state.py,sha256=qqyp-jSGsCxe1US-PRLT4-y1sITAcVE6nCMlQLnvop0,278
-universal_mcp/agents/shared/prompts.py,sha256=VOsXSUEwBXPaAuxJTUF6bgDGr41u6uctUNQSMRt_OJc,6414
-universal_mcp/agents/shared/tool_node.py,sha256=Ua_wzMt4YgIx4zLp3_ZCow-28qORwrZ2FvKqLPt3RlI,10415
+universal_mcp/agents/shared/__main__.py,sha256=u6ezelmT7poaMRr5AfKp3uXGOV7zEwj017j_iAeUcZs,1450
+universal_mcp/agents/shared/prompts.py,sha256=-gNyfhrJFtPEG4YeoJRYKmkmRHsI8a5f5ssxk_AWrOI,3760
+universal_mcp/agents/shared/tool_node.py,sha256=syydbbKFMpu9Gg45yGP-kpN5KvD2oSRXWtqo1YpD6gY,9038
 universal_mcp/applications/llm/__init__.py,sha256=xnpxq4Wl_pevvwtSUtEwcty8_d61ywO1V2YnEXyCREY,46
 universal_mcp/applications/llm/app.py,sha256=iNLU6z2LRZc01GfSKvV0vNzT1LhKAjq_UrSJEmjthjw,6032
-universal_mcp/applications/ui/app.py,sha256=56h9GvkHiELyAVOZvi0YjiowSymlqkJ5GW4O7LmGIPs,9459
-universal_mcp_agents-0.1.12.dist-info/METADATA,sha256=hqXAJNr5hrlsdZHsQwHed6ELV0b0h4q-l8Ar1IpsoEI,878
-universal_mcp_agents-0.1.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.12.dist-info/RECORD,,
+universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
+universal_mcp_agents-0.1.14.dist-info/METADATA,sha256=6a7VjzkIfQdp6b4UfQVAMKFzg2qE8wszgkocVRgqNok,878
+universal_mcp_agents-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.14.dist-info/RECORD,,

universal_mcp/agents/codeact0/langgraph_graph.py

@@ -1,17 +0,0 @@
-from langgraph.checkpoint.memory import MemorySaver
-from universal_mcp.agentr.registry import AgentrRegistry
-
-from universal_mcp.agents.codeact0.agent import CodeActAgent
-
-
-async def agent():
-    memory = MemorySaver()
-    agent_object = await 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,
-    )._build_graph()
-    return agent_object