universal-mcp-agents 0.1.8__tar.gz → 0.1.9__tar.gz

{universal_mcp_agents-0.1.8 → universal_mcp_agents-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.8
+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

{universal_mcp_agents-0.1.8 → universal_mcp_agents-0.1.9}/bump_and_release.sh

@@ -81,7 +81,6 @@ if [ "$1" = "release" ]; then
     rm -rf .pytest_cache
     rm -rf .ruff_cache
     rm -rf .mypy_cache
-    rm -rf .venv
     rm -rf .cache
     rm -rf .DS_Store
     rm -rf .idea

{universal_mcp_agents-0.1.8 → universal_mcp_agents-0.1.9}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-agents"
-version = "0.1.8"
+version = "0.1.9"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{universal_mcp_agents-0.1.8 → universal_mcp_agents-0.1.9}/src/evals/datasets/tasks.jsonl

@@ -20,3 +20,4 @@
 {"user_input": "Draft personalized LinkedIn outreach messages for 10 potential collaborators in the fintech space based on their recent posts using LinkedIn data in a Google Sheet", "difficulty": 5, "required_tools": {"scraper": ["linkedin_retrieve_profile", "linkedin_list_profile_posts"], "google_sheet": ["create_spreadsheet", "write_values_to_sheet"]}}
 {"user_input": "Monitor my Twitter mentions and DMs from the past 48 hours and create a response priority list in Google Sheets", "difficulty": 4, "required_tools": {"twitter": ["get_user_mentions", "get_dm_events_by_conversation_id"], "google_sheet": ["create_spreadsheet", "write_values_to_sheet", "set_basic_filter"]}}
 {"user_input": "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", "difficulty": 5, "required_tools": {"tavily": ["search_and_summarize"], "google_sheet": ["get_values", "batch_get_values_by_range", "get_spreadsheet_metadata" , "create_spreadsheet", "add_sheet", "add_table"]}}
+{"user_input": "search reddit for posts on elon musk and then post a meme on him on linkedin", "difficulty": 3, "required_tools": {"reddit" : ["search_reddit"], "linkedin": ["create_post"]}}

{universal_mcp_agents-0.1.8 → universal_mcp_agents-0.1.9}/src/universal_mcp/agents/__init__.py

@@ -6,6 +6,7 @@ from universal_mcp.agents.builder import BuilderAgent
 from universal_mcp.agents.planner import PlannerAgent
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
+from universal_mcp.agents.codeact import CodeActAgent
 
 
 def get_agent(agent_name: str):
@@ -23,8 +24,10 @@ def get_agent(agent_name: str):
         return BigToolAgent
     elif agent_name == "bigtool2":
         return BigToolAgent2
+    elif agent_name == "codeact":
+        return CodeActAgent
     else:
-        raise ValueError(f"Unknown agent: {agent_name}. Possible values: auto, react, simple, builder, planner, bigtool, bigtool2")
+        raise ValueError(f"Unknown agent: {agent_name}. Possible values: auto, react, simple, builder, planner, bigtool, bigtool2, codeact")
 
 __all__ = [
     "BaseAgent",

universal_mcp_agents-0.1.9/src/universal_mcp/agents/codeact/__init__.py

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

universal_mcp_agents-0.1.9/src/universal_mcp/agents/codeact/__main__.py

@@ -0,0 +1,25 @@
+import asyncio
+
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.codeact.agent import CodeActAgent
+from universal_mcp.agents.utils import messages_to_list
+
+
+async def main():
+    agent = CodeActAgent(
+        "CodeAct Agent",
+        instructions="Be very concise in your answers.",
+        model="azure/gpt-4o",
+        tools={"google_mail": ["send_email"]},
+        registry=AgentrRegistry(),
+    )
+    result = await agent.invoke(
+        "Send an email to manoj@agentr.dev from my Gmail account with a subject 'testing codeact agent' and body 'This is a test of the codeact agent.'"
+    )
+    from rich import print
+
+    print(messages_to_list(result["messages"]))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp_agents-0.1.9/src/universal_mcp/agents/codeact/agent.py

@@ -0,0 +1,171 @@
+import inspect
+from typing import Callable, Union
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.tools import StructuredTool, tool as create_tool
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.graph import END, StateGraph
+from loguru import logger
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig, ToolFormat
+
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.agents.codeact.prompts import (
+    create_default_prompt,
+    make_safe_function_name,
+    REFLECTION_PROMPT,
+    RETRY_PROMPT,
+)
+from universal_mcp.agents.codeact.sandbox import eval_unsafe
+from universal_mcp.agents.codeact.state import CodeActState
+from universal_mcp.agents.codeact.utils import extract_and_combine_codeblocks
+
+
+class CodeActAgent(BaseAgent):
+    def __init__(
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        memory: BaseCheckpointSaver | None = None,
+        tools: ToolConfig | None = None,
+        registry: ToolRegistry | None = None,
+        *,
+        reflection_prompt: str = None,
+        reflection_model: BaseChatModel = None,
+        max_reflections: int = 3,
+        **kwargs,
+    ):
+        super().__init__(name, instructions, model, memory, **kwargs)
+        self.model_instance = load_chat_model(model)
+        self.tools_config = tools or {}
+        self.registry = registry
+        self.eval_fn = eval_unsafe
+        self.reflection_prompt = reflection_prompt
+        self.reflection_model = reflection_model or self.model_instance
+        self.max_reflections = max_reflections if reflection_prompt else 0
+        self.tools_context = {}
+        self.processed_tools: list[Union[StructuredTool, Callable]] = []
+
+    async def _build_graph(self):
+        if self.tools_config:
+            if not self.registry:
+                raise ValueError("Tools are configured but no registry is provided")
+            # Langchain tools are fine
+            exported_tools = await self.registry.export_tools(
+                self.tools_config, ToolFormat.LANGCHAIN
+            )
+            self.processed_tools = [
+                t if isinstance(t, StructuredTool) else create_tool(t)
+                for t in exported_tools
+            ]
+
+        self.instructions = create_default_prompt(
+            self.processed_tools, self.instructions
+        )
+
+        for tool in self.processed_tools:
+            safe_name = make_safe_function_name(tool.name)
+            tool_callable = (
+                tool.coroutine
+                if hasattr(tool, "coroutine") and tool.coroutine is not None
+                else tool.func
+            )
+            self.tools_context[safe_name] = tool_callable
+
+        agent = StateGraph(CodeActState)
+        agent.add_node("call_model", lambda state, config: self.call_model(state, config))
+        agent.add_node("sandbox", self.sandbox)
+
+        agent.set_entry_point("call_model")
+        agent.add_conditional_edges(
+            "call_model",
+            self.should_run_sandbox,
+            {
+                "sandbox": "sandbox",
+                END: END,
+            },
+        )
+        agent.add_edge("sandbox", "call_model")
+        return agent.compile(checkpointer=self.memory)
+
+    def should_run_sandbox(self, state: CodeActState) -> str:
+        if state.get("script"):
+            return "sandbox"
+        return END
+
+    def call_model(self, state: CodeActState, config: dict) -> dict:
+        context = config.get("context", {})
+        instructions = context.get("system_prompt", self.instructions)
+        model = self.model_instance
+        reflection_model = self.reflection_model
+
+        messages = [{"role": "system", "content": instructions}] + state["messages"]
+
+        response = model.invoke(messages)
+
+        code = extract_and_combine_codeblocks(response.content)
+
+        if self.max_reflections > 0 and code:
+            reflection_count = 0
+            while reflection_count < self.max_reflections:
+                conversation_history = "\n".join(
+                    [
+                        f'<message role="{("user" if m.type == "human" else "assistant")}">\n{m.content}\n</message>'
+                        for m in state["messages"]
+                    ]
+                )
+                conversation_history += (
+                    f'\n<message role="assistant">\n{response.content}\n</message>'
+                )
+
+                formatted_prompt = REFLECTION_PROMPT.format(
+                    conversation_history=conversation_history
+                )
+
+                reflection_messages = [
+                    {"role": "system", "content": self.reflection_prompt},
+                    {"role": "user", "content": formatted_prompt},
+                ]
+                reflection_result = reflection_model.invoke(reflection_messages)
+
+                if "NONE" in reflection_result.content:
+                    break
+
+                retry_prompt = RETRY_PROMPT.format(
+                    reflection_result=reflection_result.content
+                )
+
+                regeneration_messages = [
+                    {"role": "system", "content": instructions},
+                    *state["messages"],
+                    {"role": "assistant", "content": response.content},
+                    {"role": "user", "content": retry_prompt},
+                ]
+                response = model.invoke(regeneration_messages)
+
+                code = extract_and_combine_codeblocks(response.content)
+
+                if not code:
+                    break
+
+                reflection_count += 1
+
+        if code:
+            return {"messages": [response], "script": code}
+        else:
+            return {"messages": [response], "script": None}
+
+    async def sandbox(self, state: CodeActState) -> dict:
+        existing_context = state.get("context", {})
+        context = {**existing_context, **self.tools_context}
+        if inspect.iscoroutinefunction(self.eval_fn):
+            output, new_vars = await self.eval_fn(state["script"], context)
+        else:
+            output, new_vars = self.eval_fn(state["script"], context)
+        new_context = {**existing_context, **new_vars}
+        return {
+            "messages": [{"role": "user", "content": output}],
+            "context": new_context,
+        }

universal_mcp_agents-0.1.9/src/universal_mcp/agents/codeact/prompts.py

@@ -0,0 +1,92 @@
+import inspect
+import re
+from typing import Optional, Sequence
+
+from langchain_core.tools import StructuredTool, tool as create_tool
+
+
+def make_safe_function_name(name: str) -> str:
+    """Convert a tool name to a valid Python function name."""
+    # Replace non-alphanumeric characters with underscores
+    safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
+    # Ensure the name doesn't start with a digit
+    if safe_name and safe_name[0].isdigit():
+        safe_name = f"tool_{safe_name}"
+    # Handle empty name edge case
+    if not safe_name:
+        safe_name = "unnamed_tool"
+    return safe_name
+
+
+def create_default_prompt(
+    tools: Sequence[StructuredTool],
+    base_prompt: Optional[str] = None,
+):
+    """Create default prompt for the CodeAct agent."""
+    prompt = f"{base_prompt}\n\n" if base_prompt else ""
+    prompt += """You will be given a task to perform. You should output either
+- a Python code snippet that provides the solution to the task, or a step towards the solution. Any output you want to extract from the code should be printed to the console. Code should be output in a fenced code block.
+- text to be shown directly to the user, if you want to ask for more information or provide the final answer.
+
+In addition to the Python Standard Library, you can use the following functions:"""
+
+    for tool in tools:
+        # Use coroutine if it exists, otherwise use func
+        tool_callable = (
+            tool.coroutine
+            if hasattr(tool, "coroutine") and tool.coroutine is not None
+            else tool.func
+        )
+        # Create a safe function name
+        safe_name = make_safe_function_name(tool.name)
+        # Determine if it's an async function
+        is_async = inspect.iscoroutinefunction(tool_callable)
+        # Add appropriate function definition
+        prompt += f'''\n{"async " if is_async else ""}def {safe_name}{str(inspect.signature(tool_callable))}:
+    """{tool.description}"""
+    ... 
+'''
+
+    prompt += """
+
+Variables defined at the top level of previous code snippets can be referenced in your code.
+
+Always use print() statements to explore data structures and function outputs. Simply returning values will not display them back to you for inspection. For example, use print(result) instead of just 'result'.
+
+As you don't know the output schema of the additional Python functions you have access to, start from exploring their contents before building a final solution.
+
+IMPORTANT CODING STRATEGY:
+1. Only write code up to the point where you make an API call/tool usage with an output
+2. Print the type/shape and a sample entry of this output, and using that knowledge proceed to write the further code
+
+This means:
+- Write code that makes the API call or tool usage
+- Print the result with type information: print(f"Type: {type(result)}")
+- Print the shape/structure: print(f"Shape/Keys: {result.keys() if isinstance(result, dict) else len(result) if isinstance(result, (list, tuple)) else 'N/A'}")
+- Print a sample entry: print(f"Sample: {result[0] if isinstance(result, (list, tuple)) and len(result) > 0 else result}")
+- Then, based on this knowledge, write the code to process/use this data
+
+Reminder: use Python code snippets to call tools"""
+    return prompt
+
+
+REFLECTION_PROMPT = """
+Review the assistant's latest code for as per the quality rules:
+
+<conversation_history>
+{conversation_history}
+</conversation_history>
+
+If you find ANY of these issues, describe the problem briefly and clearly.
+If NO issues are found, respond with EXACTLY: "NONE"
+"""
+
+RETRY_PROMPT = """
+I need you to completely regenerate your previous response based on this feedback:
+
+'''
+{reflection_result}
+'''
+
+DO NOT reference the feedback directly. Instead, provide a completely new response that addresses the issues.
+"""

universal_mcp_agents-0.1.9/src/universal_mcp/agents/codeact/sandbox.py

@@ -0,0 +1,48 @@
+import asyncio
+import builtins
+import contextlib
+import io
+from typing import Any
+
+
+async def eval_unsafe(code: str, _locals: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+    """
+    Execute code in a non-blocking way and return the output and changed variables.
+    """
+    result = f"Executing code...\n{code}\n\nOutput:\n"
+    result += "=" * 50 + "\n"
+
+    # Create a combined globals/locals environment that includes builtins
+    # and the provided context. This allows nested functions to access tools.
+    execution_env = {**builtins.__dict__, **_locals}
+
+    def sync_eval_in_thread():
+        """Synchronously execute code and capture output."""
+        try:
+            with contextlib.redirect_stdout(io.StringIO()) as f:
+                exec(code, execution_env)
+            output = f.getvalue()
+            if not output:
+                output = "<code ran, no output printed to stdout>"
+            return output
+        except Exception as e:
+            return f"Error during execution: {repr(e)}"
+
+    # Run the synchronous exec in a separate thread to avoid blocking the event loop.
+    output = await asyncio.to_thread(sync_eval_in_thread)
+    result += output
+
+    # Identify all variables that are not part of the original builtins
+    # and were not in the initial _locals, or were changed.
+    changed_vars = {}
+    builtin_keys = set(builtins.__dict__.keys())
+
+    for key, value in execution_env.items():
+        if key in builtin_keys:
+            continue  # Skip builtins
+
+        # Check if the key is new or if the value has changed
+        if key not in _locals or _locals[key] is not value:
+            changed_vars[key] = value
+
+    return result, changed_vars

universal_mcp_agents-0.1.9/src/universal_mcp/agents/codeact/state.py

@@ -0,0 +1,12 @@
+from typing import Any, Optional
+
+from langgraph.graph import MessagesState
+
+
+class CodeActState(MessagesState):
+    """State for CodeAct agent."""
+
+    script: Optional[str]
+    """The Python code script to be executed."""
+    context: dict[str, Any]
+    """Dictionary containing the execution context with available tools and variables."""

{universal_mcp_agents-0.1.8 → universal_mcp_agents-0.1.9}/src/universal_mcp/agents/shared/prompts.py

@@ -6,7 +6,7 @@ You are an expert planner. Your goal is to consolidate a complex user request in
 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.
-
+5.  **General purpose sub tasks:** You also need to realise that these subtasks are going to be used to search for tools and apps. And the names and description of these tools and apps are going to be general in nature so the sub tasks should not be too specific. The task which you will get may be specific in nature but the sub taks must be general. 
 **--- EXAMPLES ---**
 
 **EXAMPLE 1:**
@@ -30,25 +30,37 @@ You are an expert planner. Your goal is to consolidate a complex user request in
 
 
 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.
+You are an expert at selecting an application to perform a specific sub-task. Your goal is to generate a concise 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.
+Analyze the current sub-task in the context of the original user goal and the ENTIRE PLAN so far.
 
-**EXAMPLES:**
-- **Sub-task:** "Perform a web search using Perplexity to find the best restaurants in Goa."
-- **Query:** "Perplexity"
+**CORE INSTRUCTION:** If any application already used in the plan is capable of performing the current sub-task, your query MUST BE the name of that application to ensure continuity and efficiency. Otherwise, generate a concise query for the category of application needed.
 
-- **Sub-task:** "Fetch all marketing emails received from Gmail in the last 7 days."
-- **Query:** "Gmail"
+**--- EXAMPLES ---**
 
-- **Sub-task:** "Find the latest news about artificial intelligence."
-- **Query:** "web search"
+**EXAMPLE 1: Reusing an app from two steps ago**
+- **Original User 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"
+- **Plan So Far:**
+  - The sub-task 'Find order confirmation in Gmail' was assigned to app 'google_mail'.
+  - The sub-task 'Search for product reviews on perplexity' was assigned to app 'perplexity'.
+- **Current Sub-task:** "send an email to ankit@agentr.dev"
+- **CORRECT QUERY:** "google_mail"
 
-**SUB-TASK:**
+**EXAMPLE 2: First Step (No previous context)**
+- **Original User Task:** "Find the best restaurants in Goa."
+- **Plan So Far:** None. This is the first step.
+- **Current Sub-task:** "Perform a web search to find the best restaurants in Goa."
+- **CORRECT QUERY:** "web search"
+
+**--- YOUR TASK ---**
+
+**Original User Task:**
+"{original_task}"
+
+**Plan So Far:**
+{plan_context}
+
+**Current Sub-task:**
 "{sub_task}"
 
 **YOUR CONCISE APP SEARCH QUERY:**
@@ -62,6 +74,7 @@ You are an expert at summarizing the core *action* of a sub-task into a concise
 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").
+4.  You also need to realise that this query is going to be used to search for tools in a particular app. And the names and description of these tools are going to be general in nature so the query should not be too specific. The sub task which you will get may be specific in nature but the query must be general.
 
 **EXAMPLES:**
 - **Sub-task:** "Perform a web search using Perplexity to find the best restaurants in Goa."
@@ -107,6 +120,7 @@ You are an AI assistant that selects the most appropriate tool(s) from a list to
 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.
+6. You should understand that the sub task maybe specific in nature but the tools are made to be general purpose and therefore the tool_candidates you will get will be very general purpose but that should not stop you from selecting the tools as these tools will be given to a very smart agent who will be able to use these tools for the specific sub-taks
 
 **SUB-TASK:**
 "{sub_task}"

{universal_mcp_agents-0.1.8 → universal_mcp_agents-0.1.9}/src/universal_mcp/agents/shared/tool_node.py

@@ -85,38 +85,53 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
         }
 
     async def _resolve_sub_tasks(state: AgentState) -> AgentState:
-        """Iterates through sub-tasks, finding apps and tools for each using a two-query approach."""
+        """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. Generate App-specific query to find the right application
-            app_query_prompt = APP_SEARCH_QUERY_PROMPT.format(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 app search query: '{app_search_query}'")
+            logger.info(f"Generated context-aware app search query: '{app_search_query}'")
 
-            # 2. Search for candidate apps using the app-centric 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": []}
 
-            # 3. Generate Action-specific query for finding the tool
+            # 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}'")
 
-            # 4. Find a suitable tool within the candidate apps using the action-centric 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
@@ -124,7 +139,7 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
                 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({
@@ -136,13 +151,13 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
                     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.")
@@ -219,7 +234,7 @@ async def main():
     
     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"
+    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 = {
         "original_task": task,