universal-mcp-agents 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

universal_mcp/agents/bigtool2/graph.py

@@ -1,6 +1,7 @@
 import json
 from datetime import UTC, datetime
 from typing import Literal, cast
+import asyncio
 
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage, ToolMessage
@@ -65,16 +66,58 @@ def build_graph(
 
     @tool
     async def load_tools(tool_ids: list[str]) -> list[str]:
-        """Load the tools for the given tool ids. Returns the tool ids after loading them. Note that tool ids are the complete tool ids, with both the app name and the tool name separated by double underscore (__). e.g. google_mail__send_email"""
-        return tool_ids
+        """
+        Load the tools for the given tool ids. Returns the valid tool ids after loading.
+        Tool ids are of form 'appid__toolid'. Example: 'google_mail__send_email'
+        """
+        correct, incorrect = [], []
+        app_tool_list: dict[str, list[str]] = {}
+
+        # Group tool_ids by app for fewer registry calls
+        app_to_tools: dict[str, list[str]] = {}
+        for tool_id in tool_ids:
+            if "__" not in tool_id:
+                incorrect.append(tool_id)
+                continue
+            app, tool = tool_id.split("__", 1)
+            app_to_tools.setdefault(app, []).append((tool_id, tool))
+
+        # Fetch all apps concurrently
+        async def fetch_tools(app: str):
+            try:
+                tools_dict = await tool_registry.list_tools(app)
+                return app, {tool_unit["name"] for tool_unit in tools_dict}
+            except Exception as e:
+                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
+            for tool_id, tool in tool_entries:
+                if tool in available:
+                    correct.append(tool_id)
+                else:
+                    incorrect.append(tool_id)
+
+        return correct
 
     @tool
     async def web_search(query: str) -> str:
-        """Search the web for the given query. Returns the search results."""
+        """Search the web for the given query. Returns the search results. Do not use for app-specific searches (for example, reddit or linkedin searches should be done using the app's tools)"""
         tool = await tool_registry.export_tools(
-            ["exa__search"], ToolFormat.LANGCHAIN
+            ["exa__search_with_filters"], ToolFormat.LANGCHAIN
         )
-        response = await tool_registry.call_tool("exa__search", {"query": query, "contents": {"summary": True}})
+        response = await tool_registry.call_tool("exa__search_with_filters", {"query": query, "contents": {"summary": True}})
         return response
 
 
@@ -131,10 +174,10 @@ def build_graph(
                     return Command(goto="select_tools", update={"messages": [response]})
                 elif tool_call["name"] == load_tools.name:
                     logger.info("Model requested to load tools.")
+                    selected_tool_ids = await load_tools.ainvoke(tool_call["args"])
                     tool_msg = ToolMessage(
-                        "Loaded tools.", tool_call_id=tool_call["id"]
+                        f"Loaded tools- {selected_tool_ids}", tool_call_id=tool_call["id"]
                     )
-                    selected_tool_ids = tool_call["args"]["tool_ids"]
                     logger.info(f"Loaded tools: {selected_tool_ids}")
                     return Command(
                         goto="call_model",
@@ -194,7 +237,7 @@ def build_graph(
             tool_call = state["messages"][-1].tool_calls[0]
             searched_tools = await search_tools.ainvoke(input=tool_call["args"])
             tool_msg = ToolMessage(
-                f"Available tools: {searched_tools}", tool_call_id=tool_call["id"]
+                f"Available tool_ids: {searched_tools}. Call load_tools to select the required tools only.", tool_call_id=tool_call["id"]
             )
             return Command(goto="call_model", update={"messages": [tool_msg]})
         except Exception as e:

universal_mcp/agents/builder.py

@@ -15,7 +15,7 @@ from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.agents.shared.tool_node import build_tool_node_graph
 from universal_mcp.agents.utils import messages_to_list
-
+from collections import defaultdict
 
 class Agent(BaseModel):
     """Agent that can be created by the builder."""
@@ -146,16 +146,37 @@ class BuilderAgent(BaseAgent):
             ]
         }
         tool_finder_graph = build_tool_node_graph(self.llm, self.registry)
-        tool_config = await tool_finder_graph.ainvoke(
-            {"task": task, "messages": [HumanMessage(content=task)]}
-        )
-        tool_config = tool_config.get("apps_with_tools", {})
+        
+        initial_state = {
+            "original_task": task,
+            "messages": [HumanMessage(content=task)],
+            "decomposition_attempts": 0,
+        }
+        final_state = await tool_finder_graph.ainvoke(initial_state)
+        execution_plan = final_state.get("execution_plan")
+        tool_config = {}
+        if execution_plan:
+            # Use defaultdict to easily group tools by app_id
+            apps_with_tools = defaultdict(list)
+            for step in execution_plan:
+                app_id = step.get("app_id")
+                tool_ids = step.get("tool_ids")
+                if app_id and tool_ids:
+                    apps_with_tools[app_id].extend(tool_ids)
+
+            # Convert to a regular dict and remove any duplicate tool_ids for the same app
+            tool_config = {
+                app_id: list(set(tools)) for app_id, tools in apps_with_tools.items()
+            }
+            final_message = "I have selected the necessary tools for the agent. The agent is ready!"
+        else:
+            # Handle the case where the graph failed to create a plan
+            final_message = "I was unable to find the right tools for this task. Please try rephrasing your request."
+
         yield {
             "tool_config": tool_config,
             "messages": [
-                AIMessage(
-                    content="I have selected the necessary tools for the agent. The agent is ready!"
-                )
+                AIMessage(content=final_message)
             ],
         }
 

universal_mcp/agents/llm.py

@@ -8,7 +8,7 @@ from langchain_openai import AzureChatOpenAI
 
 @lru_cache(maxsize=8)
 def load_chat_model(
-    fully_specified_name: str, temperature: float = 1.0, tags: list[str] | None = None, thinking: bool = False
+    fully_specified_name: str, temperature: float = 1.0, tags: list[str] | None = None, thinking: bool = True
 ) -> BaseChatModel:
     """Load a chat model from a fully specified name.
     Args:

universal_mcp/agents/planner/graph.py

@@ -19,7 +19,7 @@ def build_graph(llm, registry, instructions, model, executor_agent_cls):
         logger.info(f"Running tool finder for task: {task}")
         tool_finder_graph = build_tool_node_graph(llm, registry)
         tool_finder_state = await tool_finder_graph.ainvoke(
-            {"task": task, "messages": state["messages"]}
+            {"original_task": task, "messages": state["messages"]}
         )
 
         if not tool_finder_state.get("apps_required"):

universal_mcp/agents/shared/prompts.py

@@ -0,0 +1,118 @@
+TASK_DECOMPOSITION_PROMPT = """
+You are an expert planner. Your goal is to consolidate a complex user request into the minimum number of high-level sub-tasks required. Each sub-task should correspond to a major, consolidated action within a single target application.
+
+**CORE PRINCIPLES:**
+1.  **App-Centric Grouping:** Group all related actions for a single application into ONE sub-task.
+2.  **Focus on Data Handoffs:** A good decomposition often involves one sub-task to *retrieve* information and a subsequent sub-task to *use* that information.
+3.  **Assume Internal Capabilities:** Do NOT create sub-tasks for abstract cognitive work like 'summarize' or 'analyze'.
+4.  **Simplify Single Actions:** If the user's task is already a single, simple action, the output should be a single sub-task that concisely describes that action. Do not make it identical to the user's input.
+
+**--- EXAMPLES ---**
+
+**EXAMPLE 1:**
+- **User Task:** "Create a Google Doc summarizing the last 5 merged pull requests in my GitHub repo universal-mcp/universal-mcp."
+- **CORRECT DECOMPOSITION:**
+    - "Fetch the last 5 merged pull requests from the GitHub repository 'universal-mcp/universal-mcp'."
+    - "Create a new Google Doc containing the summary of the pull requests."
+
+**EXAMPLE 2:**
+- **User Task:** "Find the best restaurants in Goa using perplexity web search."
+- **CORRECT DECOMPOSITION:**
+    - "Perform a web search using Perplexity to find the best restaurants in Goa."
+
+**--- YOUR TASK ---**
+
+**USER TASK:**
+"{task}"
+
+**YOUR DECOMPOSITION (as a list of strings):**
+"""
+
+
+APP_SEARCH_QUERY_PROMPT = """
+You are an expert at extracting the name of an application or a category of application from a sub-task description. Your goal is to generate a query for an app search engine.
+
+**INSTRUCTIONS:**
+1.  Read the sub-task carefully.
+2.  If an application is explicitly named (e.g., "Perplexity", "Gmail", "GitHub"), your query should be ONLY that name.
+3.  If no specific application is named, generate a query for the *category* of application (e.g., "web search", "email client", "document editor").
+4.  The query should be concise.
+
+**EXAMPLES:**
+- **Sub-task:** "Perform a web search using Perplexity to find the best restaurants in Goa."
+- **Query:** "Perplexity"
+
+- **Sub-task:** "Fetch all marketing emails received from Gmail in the last 7 days."
+- **Query:** "Gmail"
+
+- **Sub-task:** "Find the latest news about artificial intelligence."
+- **Query:** "web search"
+
+**SUB-TASK:**
+"{sub_task}"
+
+**YOUR CONCISE APP SEARCH QUERY:**
+"""
+
+
+TOOL_SEARCH_QUERY_PROMPT = """
+You are an expert at summarizing the core *action* of a sub-task into a concise query for finding a tool. This query should ignore any application names.
+
+**INSTRUCTIONS:**
+1.  Focus only on the verb or action being performed in the sub-task.
+2.  Include key entities related to the action.
+3.  Do NOT include the names of applications (e.g., "Perplexity", "Gmail").
+
+**EXAMPLES:**
+- **Sub-task:** "Perform a web search using Perplexity to find the best restaurants in Goa."
+- **Query:** "web search for restaurants"
+
+- **Sub-task:** "Fetch all marketing emails received from Gmail in the last 7 days."
+- **Query:** "get emails by date"
+
+- **Sub-task:** "Create a new Google Doc and append a summary."
+- **Query:** "create document, append text"
+
+**SUB-TASK:**
+"{sub_task}"
+
+**YOUR CONCISE TOOL SEARCH QUERY:**
+"""
+
+REVISE_DECOMPOSITION_PROMPT = """
+You are an expert planner who revises plans that have failed. Your previous attempt to break down a task resulted in a sub-task that could not be matched with any available tools.
+
+**INSTRUCTIONS:**
+1.  Analyze the original user task and the failed sub-task.
+2.  Generate a NEW, alternative decomposition of the original task.
+3.  This new plan should try to achieve the same overall goal but with different, perhaps broader or more combined, sub-tasks to increase the chance of finding a suitable tool.
+
+**ORIGINAL USER TASK:**
+"{task}"
+
+**FAILED SUB-TASK FROM PREVIOUS PLAN:**
+"{failed_sub_task}"
+
+**YOUR NEW, REVISED DECOMPOSITION (as a list of strings):**
+"""
+
+
+TOOL_SELECTION_PROMPT = """
+You are an AI assistant that selects the most appropriate tool(s) from a list to accomplish a specific sub-task.
+
+**INSTRUCTIONS:**
+1.  Carefully review the sub-task to understand the required action.
+2.  Examine the list of available tools and their descriptions.
+3.  Select the best tool ID that matches the sub-task. You are encouraged to select multiple tools if there are multiple tools with similar capabilties 
+or names. It is always good to have more tools than having insufficent tools.
+4.  If no tool is a good fit, return an empty list.
+5.  Only return the tool IDs.
+
+**SUB-TASK:**
+"{sub_task}"
+
+**AVAILABLE TOOLS:**
+{tool_candidates}
+
+**YOUR SELECTED TOOL ID(s):**
+"""

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,238 @@ 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, finding apps and tools for each using a two-query approach."""
+        sub_tasks = state["sub_tasks"]
+        current_plan = []
+        
+        for i, sub_task in enumerate(sub_tasks):
+            task_desc = sub_task["task"]
+            logger.info(f"Resolving sub-task: '{task_desc}'")
+
+            # 1. Generate App-specific query to find the right application
+            app_query_prompt = APP_SEARCH_QUERY_PROMPT.format(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 app search query: '{app_search_query}'")
+
+            # 2. Search for candidate apps using the app-centric query
+            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": []}
+
+            # 3. 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}'")
+
+            # 4. Find a suitable tool within the candidate apps using the action-centric query
+            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 = "Create a content calendar for next month with trending AI/ML topics using web search and optimal posting times based on my audience analytics in Google Sheets"
+    
     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.6.dist-info → universal_mcp_agents-0.1.8.dist-info}/METADATA

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

@@ -1,9 +1,9 @@
 universal_mcp/agents/__init__.py,sha256=QfYDUZxIYQSqbpGt6NZ3U5tjf7SS1Y9uPzAwmaRoDrA,1186
 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=-JkU2SrIxBk0lbolKCUmJAbC0w2m9mMdaXn7L2-Z-W0,11100
+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
@@ -40,11 +40,12 @@ universal_mcp/agents/codeact/test.py,sha256=MT0v4HChoJU4MGb7oIDlG8lvBUymroXjAkP-
 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.6.dist-info/METADATA,sha256=jFTf1cj81KgPlJ4emHKZzS5lbEkcw6_qdCbRsJokMeM,798
-universal_mcp_agents-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.6.dist-info/RECORD,,
+universal_mcp/agents/shared/prompts.py,sha256=bsKRElJg0TxlAeN5PDZF5t3Ev-DjY8nQbgy13cpDbGw,4794
+universal_mcp/agents/shared/tool_node.py,sha256=dMyogozYQe63NmEk1r77ktvaTOOS-Jwg58w1pOMfPII,10222
+universal_mcp/applications/ui/app.py,sha256=7boYUxrq0MIV6Qhdn6cneymb3yJ4DGsaIt8YSRNcyow,11354
+universal_mcp_agents-0.1.8.dist-info/METADATA,sha256=VGar7rLNCXaOLC2zwK0etQ1t9sedD0zTvKciUz99uDA,848
+universal_mcp_agents-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.8.dist-info/RECORD,,