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

universal_mcp/agents/codeact/sandbox.py

@@ -1,27 +1,51 @@
+import asyncio
 import builtins
 import contextlib
 import io
 from typing import Any
 
 
-def eval_unsafe(code: str, _locals: dict[str, Any]) -> tuple[str, dict[str, Any]]:
-    # Store original keys before execution
-    original_keys = set(_locals.keys())
+async def eval_unsafe(code: str, _locals: dict[str, Any], timeout: int = 10) -> 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.
     try:
-        with contextlib.redirect_stdout(io.StringIO()) as f:
-            # Execute the code in the provided locals context
-            # Using exec to allow dynamic code execution
-            # This is a simplified version; in production, consider security implications
-            exec(code, builtins.__dict__, _locals)
-        result += f.getvalue()
-        if not result:
-            result = "<code ran, no output printed to stdout>"
-    except Exception as e:
-        result += f"Error during execution: {repr(e)}"
-
-    # Determine new variables created during execution
-    new_keys = set(_locals.keys()) - original_keys
-    new_vars = {key: _locals[key] for key in new_keys}
-    return result, new_vars
+        output = await asyncio.wait_for(asyncio.to_thread(sync_eval_in_thread), timeout=timeout)
+    except asyncio.TimeoutError:
+        output = f"Error: Code execution timed out after {timeout} seconds."
+    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/codeact/state.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+from langgraph.graph import MessagesState
+
+
+class CodeActState(MessagesState):
+    """State for CodeAct agent."""
+
+    script: str | None
+    """The Python code script to be executed."""

universal_mcp/agents/codeact/utils.py

@@ -1,5 +1,7 @@
 import re
 
+from universal_mcp.logger import logger
+
 BACKTICK_PATTERN = r"(?:^|\n)```(.*?)(?:```(?:\n|$))"
 
 
@@ -37,7 +39,12 @@ def extract_and_combine_codeblocks(text: str) -> str:
     """
     # Find all code blocks in the text using regex
     # Pattern matches anything between triple backticks, with or without a language identifier
-    code_blocks = re.findall(BACKTICK_PATTERN, text, re.DOTALL)
+    try:
+        code_blocks = re.findall(BACKTICK_PATTERN, text, re.DOTALL)
+    except Exception as e:
+        logger.error(f"Error extracting code blocks: {e}")
+        logger.error(f"Text: {text}")
+        return ""
 
     if not code_blocks:
         return ""
@@ -46,15 +53,15 @@ def extract_and_combine_codeblocks(text: str) -> str:
     processed_blocks = []
     for block in code_blocks:
         # Strip leading and trailing whitespace
-        block = block.strip()
+        cleaned_block = block.strip()
 
         # If the first line looks like a language identifier, remove it
-        lines = block.split("\n")
+        lines = cleaned_block.split("\n")
         if lines and (not lines[0].strip() or " " not in lines[0].strip()):
             # First line is empty or likely a language identifier (no spaces)
-            block = "\n".join(lines[1:])
+            cleaned_block = "\n".join(lines[1:])
 
-        processed_blocks.append(block)
+        processed_blocks.append(cleaned_block)
 
     # Combine all codeblocks with newlines between them
     combined_code = "\n\n".join(processed_blocks)

universal_mcp/agents/hil.py

@@ -63,12 +63,7 @@ def handle_interrupt(interrupt: Interrupt) -> str | bool:
         value = input("Do you accept this? (y/n): " + interrupt.value["question"])
         return value.lower() in ["y", "yes"]
     elif interrupt_type == "choice":
-        value = input(
-            "Enter your choice: "
-            + interrupt.value["question"]
-            + " "
-            + ", ".join(interrupt.value["choices"])
-        )
+        value = input("Enter your choice: " + interrupt.value["question"] + " " + ", ".join(interrupt.value["choices"]))
         if value in interrupt.value["choices"]:
             return value
         else:

universal_mcp/agents/planner/__init__.py

@@ -26,9 +26,7 @@ class PlannerAgent(BaseAgent):
         self.executor_agent_cls = executor_agent_cls
 
     def _build_system_message(self):
-        return DEVELOPER_PROMPT.format(
-            name=self.name, instructions=self.instructions
-        )
+        return DEVELOPER_PROMPT.format(name=self.name, instructions=self.instructions)
 
     async def _build_graph(self):
         return build_graph(

universal_mcp/agents/planner/graph.py

@@ -18,9 +18,7 @@ def build_graph(llm, registry, instructions, model, executor_agent_cls):
         task = state["messages"][-1].content
         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(
-            {"original_task": task, "messages": state["messages"]}
-        )
+        tool_finder_state = await tool_finder_graph.ainvoke({"original_task": task, "messages": state["messages"]})
 
         if not tool_finder_state.get("apps_required"):
             logger.info("Tool finder determined no apps are required.")

universal_mcp/agents/react.py

@@ -4,6 +4,7 @@ from loguru import logger
 from universal_mcp.agentr.registry import AgentrRegistry
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig, ToolFormat
+from rich import print
 
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
@@ -40,7 +41,18 @@ class ReactAgent(BaseAgent):
         self.llm = load_chat_model(model)
         self.tools = tools or {}
         if "ui" not in self.tools:
-            self.tools["ui"] = ["create_bar_chart", "create_line_chart", "create_pie_chart", "create_table", "http_get", "http_post", "http_put", "http_delete", "http_patch", "read_file"]
+            self.tools["ui"] = [
+                "create_bar_chart",
+                "create_line_chart",
+                "create_pie_chart",
+                "create_table",
+                "http_get",
+                "http_post",
+                "http_put",
+                "http_delete",
+                "http_patch",
+                "read_file",
+            ]
         self.max_iterations = max_iterations
         self.registry = registry
 
@@ -54,7 +66,6 @@ class ReactAgent(BaseAgent):
         else:
             tools = []
 
-
         logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
         return create_react_agent(
             self.llm,
@@ -75,10 +86,7 @@ async def main():
         tools={"google-mail": ["send_email"]},
         registry=AgentrRegistry(),
     )
-    result = await agent.invoke(
-        "Send an email with the subject 'testing react agent' to manoj@agentr.dev"
-    )
-    from rich import print
+    result = await agent.invoke("Send an email with the subject 'testing react agent' to manoj@agentr.dev")
 
     print(messages_to_list(result["messages"]))
 

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."
@@ -103,10 +116,11 @@ You are an AI assistant that selects the most appropriate tool(s) from a list to
 **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 
+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.
+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}"
@@ -115,4 +129,4 @@ or names. It is always good to have more tools than having insufficent tools.
 {tool_candidates}
 
 **YOUR SELECTED TOOL ID(s):**
-"""
+"""

universal_mcp/agents/shared/tool_node.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Annotated, TypedDict, List, Dict
+from typing import Annotated, TypedDict
 
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
@@ -17,43 +17,50 @@ from universal_mcp.agents.shared.prompts import (
     TOOL_SELECTION_PROMPT,
 )
 
-
 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.")
+    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.")
+    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]
+    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]
+    sub_tasks: list[SubTask]
+    execution_plan: list[SubTask]
     messages: Annotated[list[AnyMessage], add_messages]
 
 
 # --- Graph Builder ---
 
+
 def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGraph:
     """Builds the adaptive LangGraph workflow for tool selection."""
 
@@ -65,19 +72,14 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
 
         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
-            )
+            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
-        ]
-        
+        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,
@@ -85,38 +87,50 @@ 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,19 +138,21 @@ 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({
-                        "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."
-                    })
+                    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": []}
@@ -147,7 +163,11 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
         """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.")]
+            "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:
@@ -157,7 +177,7 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
         """
         logger.info("Consolidating final execution plan.")
         plan = state["execution_plan"]
-        merged_apps: Dict[str, SubTask] = {}
+        merged_apps: dict[str, SubTask] = {}
 
         for step in plan:
             app_id = step["app_id"]
@@ -174,9 +194,8 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
         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}
 
+        return {"execution_plan": final_plan}
 
     # --- Graph Definition ---
 
@@ -184,26 +203,26 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
 
     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("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 not state.get("sub_tasks"):  # Resolution failed or succeeded
             if state.get("execution_plan"):
-                return "consolidate_plan" # MODIFIED: Go to consolidate on success
+                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
+                return "decompose_task"  # Re-try decomposition
         else:
             return "resolve_sub_tasks"
 
     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("consolidate_plan", END)  # NEW EDGE
     workflow.add_edge("handle_planning_failure", END)
 
     return workflow.compile()
@@ -212,15 +231,16 @@ def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGr
 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("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"
-    
+    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,
         "messages": [HumanMessage(content=task)],
@@ -229,17 +249,12 @@ async def main():
 
     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'])}")
+            pass
     else:
-        print("Failed to create an execution plan.")
-        print(f"Final message: {final_state['messages'][-1].content}")
+        pass
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

universal_mcp/agents/simple.py

@@ -4,6 +4,7 @@ from typing import Annotated
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import END, START, StateGraph
 from langgraph.graph.message import add_messages
+from rich import print
 from typing_extensions import TypedDict
 
 from universal_mcp.agents.base import BaseAgent
@@ -52,10 +53,10 @@ class SimpleAgent(BaseAgent):
         graph_builder.add_edge("chatbot", END)
         return graph_builder.compile(checkpointer=self.memory)
 
+
 async def main():
     agent = SimpleAgent("Simple Agent", "Act as a 14 year old kid, reply in Gen-Z lingo", "azure/gpt-5-mini")
     output = await agent.invoke("What is the capital of France?")
-    from rich import print
     print(messages_to_list(output["messages"]))
 
 

universal_mcp/agents/utils.py

@@ -8,9 +8,6 @@ from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.table import Table
-from universal_mcp.tools.manager import ToolManager
-from universal_mcp.types import ToolFormat
-
 
 
 class RichCLI:
@@ -28,9 +25,7 @@ Available commands:
 - `/tools` - List available tools
 - `/exit` - Exit the application
         """
-        self.console.print(
-            Panel(Markdown(welcome_text), title="🤖 AI Agent CLI", border_style="blue")
-        )
+        self.console.print(Panel(Markdown(welcome_text), title="🤖 AI Agent CLI", border_style="blue"))
 
     def display_agent_response(self, response: str, agent_name: str):
         """Display agent response with formatting"""
@@ -54,13 +49,9 @@ Available commands:
                     # Check if type has changed and reset content if so
                     if self.type_ != type_:
                         if type_ == "thinking":
-                            self.content += (
-                                "\n[bold yellow]💭 Thinking:[/bold yellow] :"
-                            )
+                            self.content += "\n[bold yellow]💭 Thinking:[/bold yellow] :"
                         elif type_ == "text":
-                            self.content += (
-                                f"\n[bold green]🤖 {agent_name}[/bold green] :"
-                            )
+                            self.content += f"\n[bold green]🤖 {agent_name}[/bold green] :"
                         self.type_ = type_
                     self.content += chunk
                     content_text = "".join(self.content)
@@ -120,9 +111,7 @@ Available commands:
             value = Prompt.ask(interrupt.value["question"])
             return value
         elif interrupt_type == "bool":
-            value = Prompt.ask(
-                interrupt.value["question"], choices=["y", "n"], default="y"
-            )
+            value = Prompt.ask(interrupt.value["question"], choices=["y", "n"], default="y")
             return value
         elif interrupt_type == "choice":
             value = Prompt.ask(