universal-mcp-agents 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

universal_mcp/agents/shared/tool_node.py

@@ -1,7 +1,5 @@
-# tool_node.py
-
 import asyncio
-from typing import Annotated, TypedDict
+from typing import Annotated, TypedDict, List, Dict
 
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
@@ -10,242 +8,253 @@ from langgraph.graph.message import add_messages
 from loguru import logger
 from pydantic import BaseModel, Field
 from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig
 
-# --- LangGraph Agent ---
+from universal_mcp.agents.shared.prompts import (
+    APP_SEARCH_QUERY_PROMPT,
+    REVISE_DECOMPOSITION_PROMPT,
+    TASK_DECOMPOSITION_PROMPT,
+    TOOL_SEARCH_QUERY_PROMPT,
+    TOOL_SELECTION_PROMPT,
+)
 
 
-class AgentState(TypedDict):
+MAX_DECOMPOSITION_ATTEMPTS = 2
+
+# --- Pydantic Models for Structured LLM Outputs ---
+
+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 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
-    apps_required: bool
-    relevant_apps: list[str]
-    apps_with_tools: ToolConfig
-    messages: Annotated[list[AnyMessage], add_messages]
+    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]
+    messages: Annotated[list[AnyMessage], add_messages]
 
-class ToolSelectionOutput(BaseModel):
-    tool_ids: list[str] = Field(description="The ids of the tools to use")
 
+# --- Graph Builder ---
 
 def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGraph:
-    """Builds the LangGraph workflow."""
-
-    async def _check_if_app_needed(state: AgentState) -> AgentState:
-        """Checks if an external application is needed for the given task."""
-        task = state["task"]
-        prompt = f"""
-            Given the user's task: "{task}"
-            Does this task require an external application to be completed?
-            Your answer should be a simple "Yes" or "No", followed by a brief explanation.
-            For example:
-            Yes, an external application is needed to send emails.
-            No, this is a general question that can be answered directly.
-            """
-        response = await llm.ainvoke(prompt)
-        # Handle both string and list content types
-        if isinstance(response.content, list):
-            content = " ".join([str(item) for item in response.content]).strip()
-        else:
-            content = response.content.strip()
-        reasoning = f"Initial check for app requirement. LLM response: {content}"
-
-        if content.lower().startswith("yes"):
-            return {
-                **state,
-                "messages": [AIMessage(content=content)],
-                "apps_required": True,
-                "reasoning": reasoning,
-            }
-        else:
-            return {
-                **state,
-                "messages": [AIMessage(content=content)],
-                "apps_required": False,
-                "reasoning": reasoning,
-            }
-
-    async def _find_relevant_apps(state: AgentState) -> AgentState:
-        """Identifies relevant apps for the given task, preferring connected apps."""
-        task = state["task"]
-        all_apps = await registry.list_all_apps()
-        connected_apps = await registry.list_connected_apps()
-        prompt = """
-You are an expert at identifying which applications are needed to complete specific tasks.
-
-TASK: "{task}"
-
-AVAILABLE APPS:
-{all_apps}
-
-CONNECTED APPS (user has already authenticated these):
-{connected_apps}
-
-INSTRUCTIONS:
-1. Analyze the task carefully to understand what functionality is required.
-2. Review the available apps and their descriptions to identify which ones could help.
-3. If multiple apps can perform the task, prefer connected apps, but you MUST include all relevant apps.
-4. Consider apps that provide complementary functionality for complex tasks.
-5. Only suggest apps that are directly relevant to the core task requirements.
-6. Your output should be a list of app IDs.
-
-"""
-
-        class AppList(BaseModel):
-            app_list: list[str]
-            reasoning: str
-
-        response = await llm.with_structured_output(AppList).ainvoke(
-            input=prompt.format(
-                task=task, all_apps=all_apps, connected_apps=connected_apps
+    """Builds the adaptive LangGraph workflow for tool selection."""
+
+    async def _decompose_task(state: AgentState) -> AgentState:
+        """Decomposes the main task or revises a failed decomposition."""
+        attempts = state.get("decomposition_attempts", 0)
+        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
             )
-        )
-        app_list = response.app_list
-        reasoning = f"Found relevant apps: {app_list}. Reasoning: {response.reasoning}"
-        logger.info(f"Found relevant apps: {app_list}.")
-
+        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 {
-            **state,
-            "messages": [
-                AIMessage(content=f"Identified relevant apps: {', '.join(app_list)}")
-            ],
-            "relevant_apps": app_list,
-            "reasoning": state.get("reasoning", "") + "\n" + reasoning,
+            "sub_tasks": sub_tasks,
+            "decomposition_attempts": attempts + 1,
+            "messages": [AIMessage(content=f"New plan created with {len(sub_tasks)} steps.")],
         }
 
-    async def _select_tools(task: str, tools: list[dict]) -> list[str]:
-        """Selects the most appropriate tools from a list for a given task."""
-        tool_candidates = [f"{tool['name']}: {tool['description']}" for tool in tools]
-
-        SELECT_TOOL_PROMPT = f"""You are an AI assistant that helps the user perform tasks using various apps (each app has multiple tools).
-You will be provided with a task and a list of tools which might be relevant for this task.
-
-Your goal is to select the most appropriate tool for the given task.
-<task>
-{task}
-</task>
-
-<tool_candidates>
- - {tool_candidates}
-</tool_candidates>
-
-Only return tool ids.
-"""
-
-        response = await llm.with_structured_output(schema=ToolSelectionOutput).ainvoke(
-            input=SELECT_TOOL_PROMPT
-        )
-
-        selected_tool_ids = response.tool_ids
-        return selected_tool_ids
-
-    async def _generate_search_query(task: str) -> str:
-        """Generates a concise search query from the user's task."""
-        prompt = f"""
-You are an expert at summarizing a user's task into a concise search query for finding relevant tools.
-The query should capture all the main actions or intents of the task.
-
-For example:
-Task: "Send an email to abc@the-read-example.com with the subject 'Hello'"
-Query: "send email"
-
-Task: "Create a new contact in my CRM for John Doe"
-Query: "create contact"
-
-Task: "Find the latest news about artificial intelligence"
-Query: "search news"
-
-Task: "Post a message to the #general channel in Slack and create a new issue in Jira"
-Query: "send message, create issue"
-
-Task: "{task}"
-"""
-
-        class SearchQuery(BaseModel):
-            query: str
-
-        response = await llm.with_structured_output(SearchQuery).ainvoke(
-            input=prompt.format(task=task)
-        )
-        query = response.query
-        logger.info(f"Generated search query '{query}' for task '{task}'")
-        return query
-
-    async def _search_tools(state: AgentState) -> AgentState:
-        """Searches for and filters tools in the relevant apps."""
-        task = state["task"]
-        logger.info(f"Searching for tools in relevant apps for task: {task}")
-        search_query = await _generate_search_query(task)
-        apps_with_tools_dict = {}
-        reasoning_steps = []
-        for app_name in state["relevant_apps"]:
-            logger.info(
-                f"Searching for tools in {app_name} for task: {task} with query '{search_query}'"
-            )
-            found_tools = await registry.search_tools(
-                query=search_query, app_id=app_name
-            )
-            selected_tools = await _select_tools(task, found_tools)
-            apps_with_tools_dict[app_name] = selected_tools
-            reasoning_steps.append(
-                f"For '{app_name}', selected tool(s): {', '.join(selected_tools)}."
+    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
             )
-
+            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 {
-            **state,
-            "apps_with_tools": apps_with_tools_dict,
-            "reasoning": state.get("reasoning", "") + "\n" + "\n".join(reasoning_steps),
+            "messages": [AIMessage(content="I am unable to create a complete plan for this task with the available tools. Please try rephrasing your request.")]
         }
 
-    def _handle_no_apps_found(state: AgentState) -> AgentState:
-        """Handles the case where no relevant apps are found."""
-        reasoning = "No suitable application was found among the available apps."
-        return {
-            **state,
-            "apps_with_tools": {},
-            "reasoning": state.get("reasoning", "") + "\n" + reasoning,
-        }
+    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"])
+
+        # 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)
+        
+        return {"execution_plan": final_plan}
+
+
+    # --- Graph Definition ---
 
     workflow = StateGraph(AgentState)
 
-    workflow.add_node("check_if_app_needed", _check_if_app_needed)
-    workflow.add_node("find_relevant_apps", _find_relevant_apps)
-    workflow.add_node("search_tools", _search_tools)
-    workflow.add_node("handle_no_apps_found", _handle_no_apps_found)
-
-    workflow.set_entry_point("check_if_app_needed")
-
-    workflow.add_conditional_edges(
-        "check_if_app_needed",
-        lambda state: "find_relevant_apps" if state["apps_required"] else END,
-    )
-    workflow.add_conditional_edges(
-        "find_relevant_apps",
-        lambda state: "search_tools"
-        if state["relevant_apps"]
-        else "handle_no_apps_found",
-    )
+    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)
+
+    workflow.set_entry_point("decompose_task")
+
+    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"
 
-    workflow.add_edge("search_tools", END)
-    workflow.add_edge("handle_no_apps_found", END)
+    workflow.add_conditional_edges("decompose_task", lambda s: "resolve_sub_tasks")
+    workflow.add_conditional_edges("resolve_sub_tasks", should_continue)
+    
+    workflow.add_edge("consolidate_plan", END) # NEW EDGE
+    workflow.add_edge("handle_planning_failure", END)
 
     return workflow.compile()
 
 
 async def main():
+    """Main function to run the agent."""
     from universal_mcp.agentr.registry import AgentrRegistry
-
     from universal_mcp.agents.llm import load_chat_model
 
     registry = AgentrRegistry()
-    llm = load_chat_model("gemini/gemini-2.5-flash")
+    llm = load_chat_model("anthropic/claude-4-sonnet-20250514")
+    
     graph = build_tool_node_graph(llm, registry)
+
+    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"
+    
     initial_state = {
-        "task": "Send an email to manoj@agentr.dev",
-        "messages": [HumanMessage(content="Send an email to manoj@agentr.dev")],
+        "original_task": task,
+        "messages": [HumanMessage(content=task)],
+        "decomposition_attempts": 0,
     }
-    await graph.ainvoke(initial_state)
+
+    final_state = await graph.ainvoke(initial_state)
+
+    print("\n--- Final Agent State ---")
+    if final_state.get("execution_plan"):
+        print("Successfully created a consolidated execution plan:")
+        for step in final_state["execution_plan"]:
+            print(f"- Sub-task: {step['task']}")
+            print(f"  - App: {step['app_id']}")
+            print(f"  - Tool(s): {', '.join(step['tool_ids'])}")
+    else:
+        print("Failed to create an execution plan.")
+        print(f"Final message: {final_state['messages'][-1].content}")
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

universal_mcp/applications/ui/app.py

@@ -105,7 +105,7 @@ class UiApp(BaseApplication):
     ):
         """Create an interactive table with data.
 
-        The table will automatically have sorting, filtering, and search functionality.
+        The table will automatically have sorting, filtering, and search functionality. Note that this only creates a table on the frontend. Do not mix this up with tables from applications like google_sheet, airtable.
 
         Args:
             title (str): The title of the table.

{universal_mcp_agents-0.1.7.dist-info → universal_mcp_agents-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.7
+Version: 0.1.9
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications
@@ -11,7 +11,8 @@ Requires-Dist: langchain-anthropic>=0.3.19
 Requires-Dist: langchain-google-genai>=2.1.10
 Requires-Dist: langchain-openai>=0.3.32
 Requires-Dist: langgraph>=0.6.6
-Requires-Dist: universal-mcp>=0.1.24rc17
+Requires-Dist: universal-mcp-applications>=0.1.14
+Requires-Dist: universal-mcp>=0.1.24rc21
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'

{universal_mcp_agents-0.1.7.dist-info → universal_mcp_agents-0.1.9.dist-info}/RECORD

@@ -1,9 +1,9 @@
-universal_mcp/agents/__init__.py,sha256=QfYDUZxIYQSqbpGt6NZ3U5tjf7SS1Y9uPzAwmaRoDrA,1186
+universal_mcp/agents/__init__.py,sha256=S4hVzh-bkkvSvvNBFWUSegnRv0_vxeKG_dEhYss32rs,1311
 universal_mcp/agents/base.py,sha256=h_FDAclpFKpaMCSNhBcwIMF0DLbZtyyoy_l71UxY4Aw,6892
-universal_mcp/agents/builder.py,sha256=4RTROLljLzF4S3qrQrkl_mS3EipBBvqnvJflJ45oYCs,7850
+universal_mcp/agents/builder.py,sha256=W7qTfF-TtmebdtjAv32y1Al_KvWilLyUN3p4Ce3X1Eo,8815
 universal_mcp/agents/cli.py,sha256=_rJV6TxBG2amH3o8mVs4pxViaTfkBhz6n5l6xhv4Z3g,1014
 universal_mcp/agents/hil.py,sha256=XfQT8QcuDbiIpUU9N4WSbO2Tm9YNSuwRqyCTWmCWaZo,3818
-universal_mcp/agents/llm.py,sha256=gnyCYW8Ohax8S9CXIfeI7hoBYNO0fa_1hJkIabCGoKY,1788
+universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
 universal_mcp/agents/react.py,sha256=jH42VFAB-BuPUVpaMIspBjjukYEJan-DQxtNamD1o0I,3010
 universal_mcp/agents/simple.py,sha256=Z5Ja12vJIhIHhB68WWH_5opln7FMDUiRfztKOj2Rx-U,1941
 universal_mcp/agents/utils.py,sha256=g_v7IEKtx6CBQK-Nue_weVVie62KQLQjz7izU3kOWPQ,4988
@@ -22,7 +22,7 @@ universal_mcp/agents/bigtool/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpn
 universal_mcp/agents/bigtool2/__init__.py,sha256=wkhjOeAHhIpuciLTbKZT3J2uPIJ0KFZpCDn0xX2plNs,2421
 universal_mcp/agents/bigtool2/__main__.py,sha256=SAHfoLqDEhUj3dF3vSzfetCzPGMC3UPJxBySHujSrDY,669
 universal_mcp/agents/bigtool2/agent.py,sha256=ef9IIxgJmr26eYWQdazrIA-IXHGRwT0XNyPThJR55Tk,436
-universal_mcp/agents/bigtool2/graph.py,sha256=GrFYoV2KDyUuutbiS4xrLk6V-x5LftGenZRuTSLRL30,11126
+universal_mcp/agents/bigtool2/graph.py,sha256=OB_SBfwF47uEx0sy8XnDDdcBv0qjEqg9uJvxu_DIX9E,12749
 universal_mcp/agents/bigtool2/prompts.py,sha256=rQFtZDkwU9z8d4PWdt6jpohGhyab658Xvk8hvNVBFBA,1843
 universal_mcp/agents/bigtool2/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
 universal_mcp/agents/bigtoolcache/__init__.py,sha256=YY7X8-XQ3AC2t_Y9MN9dZk5wTPu7iU6YS8Yhn_akgC0,1844
@@ -34,17 +34,21 @@ universal_mcp/agents/bigtoolcache/prompts.py,sha256=XDU2uJWzwGwt8t3zGjOH16YIrHJC
 universal_mcp/agents/bigtoolcache/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
 universal_mcp/agents/bigtoolcache/tools_all.txt,sha256=g52i00AOh9VTDsAtIAF8vhqtTHQVmzTn61k724niEA0,95408
 universal_mcp/agents/bigtoolcache/tools_important.txt,sha256=PD4klowvARwhbC8dcXMm_sGUWH7cAynX40nXLqeRbdQ,38593
-universal_mcp/agents/codeact/__init__.py,sha256=qm06CsIodscl-XFfriYiPMDn7I_aIg48TTIw2ESgU2w,10263
-universal_mcp/agents/codeact/sandbox.py,sha256=lGRzhuXTHCB1qauuOI3bH1-fPTsyL6Lf9EmMIz4C2xQ,1039
-universal_mcp/agents/codeact/test.py,sha256=MT0v4HChoJU4MGb7oIDlG8lvBUymroXjAkP-ELu2fKw,498
+universal_mcp/agents/codeact/__init__.py,sha256=gULnc3WQoZHsWrMKqyR2r6J-dfo8I25lp84eE5K4fAE,59
+universal_mcp/agents/codeact/__main__.py,sha256=guSg-WpgVtRaRbPoFbAVZVoAi5vfdIHagcYfFiAQzeA,756
+universal_mcp/agents/codeact/agent.py,sha256=lWVKX3-nHprUXXnroUTMOOv0kgPxHlkOa7vQ6ALspSY,6395
+universal_mcp/agents/codeact/prompts.py,sha256=tBscvoGmAd_mMdRS14JH2JGvlk6MldMOkXRTq_YJcz4,3786
+universal_mcp/agents/codeact/sandbox.py,sha256=l7jofgKr3EQblHYvVNFv9rdwKSq7c0_ZHcv7fueFsDo,1698
+universal_mcp/agents/codeact/state.py,sha256=yAIs_-SClTCjdwFopF5LkqiFxppnkQx6MJSfG-tUfOU,342
 universal_mcp/agents/codeact/utils.py,sha256=VuMvLTxBBh3pgaJk8RWj5AK8XZFF-1gnZJ6jFLeM_CI,1690
 universal_mcp/agents/planner/__init__.py,sha256=b5HnTHXvs0y5KBwy9yr8d96MbyObUZ8QWrCFbUhdgGo,1335
 universal_mcp/agents/planner/__main__.py,sha256=OfhTfYDZK_ZUfc8sX-Sa6TWk-dNqD2rl13Ln64mNAtw,771
-universal_mcp/agents/planner/graph.py,sha256=qTXUVXiPWZP73GsY9mQEGmBtA-C1t06jpzgJINNpMFU,3241
+universal_mcp/agents/planner/graph.py,sha256=kF6b2LBNsTAlCiZ1Unz78_yk-UOE5d27r_3i0LZZZ7w,3250
 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/tool_node.py,sha256=FiKY0AhxKIFpzGKGnyRL-6Dzuf0KUDmiQo7IhXmE27s,8861
-universal_mcp/applications/ui/app.py,sha256=y1DcnX1Vg-d1cBtEP0_jUOR2ypbB0X7q4YiQNAg9WdY,11223
-universal_mcp_agents-0.1.7.dist-info/METADATA,sha256=ZIkbodKsCGXwZ3iWEbJ9i5jpZ0F6xrLtlLu-jhgjYPo,798
-universal_mcp_agents-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.7.dist-info/RECORD,,
+universal_mcp/agents/shared/prompts.py,sha256=HB4c6nmAmn9ClO-tZ-Iw2Fz6_PjfDGImU8kXVwB9js8,6415
+universal_mcp/agents/shared/tool_node.py,sha256=31oVSu0Cql2yhSFUOtJvTt4dUoTpPp9K7TQCTr3MhVQ,10793
+universal_mcp/applications/ui/app.py,sha256=7boYUxrq0MIV6Qhdn6cneymb3yJ4DGsaIt8YSRNcyow,11354
+universal_mcp_agents-0.1.9.dist-info/METADATA,sha256=aArQs7AQzGlXFOtXETMKOjfoCIBCmIFoQH2FdyfI-IE,848
+universal_mcp_agents-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.9.dist-info/RECORD,,

universal_mcp/agents/codeact/test.py

@@ -1,16 +0,0 @@
-from universal_mcp.agentr import Agentr
-from universal_mcp.tools.adapters import ToolFormat
-
-from universal_mcp.agents.codeact import create_codeact
-from universal_mcp.agents.codeact.sandbox import eval_unsafe
-from universal_mcp.agents.llm import load_chat_model
-
-model = load_chat_model("gpt-4.1")
-
-agentr = Agentr()
-agentr.load_tools(["google-mail_send_email"])
-
-tools = agentr.list_tools(format=ToolFormat.NATIVE)
-
-code_act = create_codeact(model, tools, eval_unsafe)
-agent = code_act.compile()