universal-mcp-agents 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

universal_mcp/agents/__init__.py

@@ -4,7 +4,7 @@ from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.bigtool import BigToolAgent
 from universal_mcp.agents.builder.builder import BuilderAgent
 from universal_mcp.agents.codeact import CodeActAgent as CodeActScript
-from universal_mcp.agents.codeact0 import CodeActAgent as CodeActRepl
+from universal_mcp.agents.codeact0 import CodeActPlaybookAgent as CodeActRepl
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
 

universal_mcp/agents/base.py

@@ -85,6 +85,7 @@ class BaseAgent:
         event = cast(AIMessageChunk, event)
         event.usage_metadata = aggregate.usage_metadata
         logger.debug(f"Usage metadata: {event.usage_metadata}")
+        event.content = ""  # Clear the message since it would have already been streamed above
         yield event
 
     async def stream_interactive(self, thread_id: str, user_input: str):
@@ -115,6 +116,8 @@ class BaseAgent:
             "recursion_limit": 25,
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
+            "run_id": thread_id,
+            "run_name": self.name,
         }
 
         result = await self._graph.ainvoke(

universal_mcp/agents/bigtool/__init__.py

@@ -56,7 +56,7 @@ class BigToolAgent(BaseAgent):
             compiled_graph = graph_builder.compile(checkpointer=self.memory)
             return compiled_graph
         except Exception as e:
-            raise e
+            raise Exception(f"Failed to build AutoAgent graph: {e}")
 
     @property
     def graph(self):

universal_mcp/agents/bigtool/__main__.py

@@ -2,15 +2,16 @@ import asyncio
 
 from loguru import logger
 from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.bigtoolcache import BigToolAgentCache
+
+from universal_mcp.agents.bigtool import BigToolAgent
 
 
 async def main():
-    agent = BigToolAgentCache(
+    agent = BigToolAgent(
         registry=AgentrRegistry(),
     )
     async for event in agent.stream(
-        user_input="Send an email to manoj@agentr.dev",
+        user_input="Load a supabase tool",
         thread_id="test123",
     ):
         logger.info(event.content)

universal_mcp/agents/bigtool/agent.py

@@ -1,9 +1,10 @@
 from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.bigtoolcache import BigToolAgentCache
+
+from universal_mcp.agents.bigtool import BigToolAgent
 
 
 async def agent():
-    agent_object = await BigToolAgentCache(
+    agent_object = await BigToolAgent(
         registry=AgentrRegistry(),
     )._build_graph()
     return agent_object

universal_mcp/agents/bigtool/graph.py

@@ -7,10 +7,12 @@ from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage, SystemMessage, ToolMessage
 from langchain_core.tools import BaseTool
 from langgraph.graph import StateGraph
-from langgraph.types import Command
+from langgraph.types import Command, RetryPolicy
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolFormat
 
+from universal_mcp.agents.utils import filter_retry_on
+
 from .state import State
 from .tools import get_valid_tools
 
@@ -31,7 +33,12 @@ def build_graph(
 
         # Combine meta tools with currently loaded tools
         if len(state["selected_tool_ids"]) > 0:
-            current_tools = await registry.export_tools(tools=state["selected_tool_ids"], format=ToolFormat.LANGCHAIN)
+            try:
+                current_tools = await registry.export_tools(
+                    tools=state["selected_tool_ids"], format=ToolFormat.LANGCHAIN
+                )
+            except Exception as e:
+                raise Exception(f"Failed to export selected tools: {e}")
         else:
             current_tools = []
         all_tools = (
@@ -48,23 +55,30 @@ def build_graph(
                 seen_names.add(tool.name)
                 unique_tools.append(tool)
 
-        if isinstance(base_model, ChatAnthropic):
-            model_with_tools = base_model.bind_tools(
-                unique_tools,
-                tool_choice="auto",
-                parallel_tool_calls=False,
-                cache_control={"type": "ephemeral", "ttl": "1h"},
-            )
-        else:
-            model_with_tools = base_model.bind_tools(
-                unique_tools,
-                tool_choice="auto",
-                parallel_tool_calls=False,
-            )
+        try:
+            if isinstance(base_model, ChatAnthropic):
+                model_with_tools = base_model.bind_tools(
+                    unique_tools,
+                    tool_choice="auto",
+                    parallel_tool_calls=False,
+                    cache_control={"type": "ephemeral", "ttl": "1h"},
+                )
+            else:
+                model_with_tools = base_model.bind_tools(
+                    unique_tools,
+                    tool_choice="auto",
+                    parallel_tool_calls=False,
+                )
+        except Exception as e:
+            raise Exception(f"Failed to bind tools to model: {e}")
 
         # Get response from model
         messages = [SystemMessage(content=system_prompt), *state["messages"]]
-        response = cast(AIMessage, await model_with_tools.ainvoke(messages))
+
+        try:
+            response = cast(AIMessage, await model_with_tools.ainvoke(messages))
+        except Exception as e:
+            raise Exception(f"Model invocation failed: {e}")
 
         if response.tool_calls:
             return Command(goto="execute_tools", update={"messages": [response]})
@@ -78,27 +92,42 @@ def build_graph(
 
         tool_messages = []
         new_tool_ids = []
+        ask_user = False
 
         for tool_call in tool_calls:
-            if tool_call["name"] == "load_tools":  # Handle load_tools separately
-                valid_tools = await get_valid_tools(tool_ids=tool_call["args"]["tool_ids"], registry=registry)
-                new_tool_ids.extend(valid_tools)
-                # Create tool message response
-                tool_result = f"Successfully loaded {len(valid_tools)} tools: {valid_tools}"
-            elif tool_call["name"] == "search_tools":
-                tool_result = await meta_tools["search_tools"].ainvoke(tool_call["args"])
-            elif tool_call["name"] == "web_search":
-                tool_result = await meta_tools["web_search"].ainvoke(tool_call["args"])
-            else:
-                # Load tools first
-                await registry.export_tools([tool_call["name"]], ToolFormat.LANGCHAIN)
-                tool_result = await registry.call_tool(tool_call["name"], tool_call["args"])
+            try:
+                if tool_call["name"] == "load_tools":  # Handle load_tools separately
+                    valid_tools, unconnected_links = await get_valid_tools(
+                        tool_ids=tool_call["args"]["tool_ids"], registry=registry
+                    )
+                    new_tool_ids.extend(valid_tools)
+                    # Create tool message response
+                    tool_result = f"Successfully loaded {len(valid_tools)} tools: {valid_tools}"
+                    if unconnected_links:
+                        ask_user = True
+                        links = "\n".join(unconnected_links)
+                        ai_msg = f"Please login to the following app(s) using the following links and let me know in order to proceed:\n {links} "
+
+                elif tool_call["name"] == "search_tools":
+                    tool_result = await meta_tools["search_tools"].ainvoke(tool_call["args"])
+                elif tool_call["name"] == "web_search":
+                    tool_result = await meta_tools["web_search"].ainvoke(tool_call["args"])
+                else:
+                    # Load tools first
+                    await registry.export_tools([tool_call["name"]], ToolFormat.LANGCHAIN)
+                    tool_result = await registry.call_tool(tool_call["name"], tool_call["args"])
+            except Exception as e:
+                tool_result = f"Error during {tool_call}: {e}"
+
             tool_message = ToolMessage(
                 content=json.dumps(tool_result),
                 name=tool_call["name"],
                 tool_call_id=tool_call["id"],
             )
             tool_messages.append(tool_message)
+        if ask_user:
+            tool_messages.append(AIMessage(content=ai_msg))
+            return Command(update={"messages": tool_messages, "selected_tool_ids": new_tool_ids})
 
         return Command(goto="agent", update={"messages": tool_messages, "selected_tool_ids": new_tool_ids})
 
@@ -106,8 +135,16 @@ def build_graph(
     workflow = StateGraph(State)
 
     # Add nodes
-    workflow.add_node("agent", agent_node)
-    workflow.add_node("execute_tools", execute_tools_node)
+    workflow.add_node(
+        "agent",
+        agent_node,
+        retry_policy=RetryPolicy(max_attempts=3, retry_on=filter_retry_on, initial_interval=2, backoff_factor=2),
+    )
+    workflow.add_node(
+        "execute_tools",
+        execute_tools_node,
+        retry_policy=RetryPolicy(max_attempts=3, retry_on=filter_retry_on, initial_interval=2, backoff_factor=2),
+    )
 
     # Set entry point
     workflow.set_entry_point("agent")

universal_mcp/agents/bigtool/prompts.py

@@ -5,9 +5,9 @@ SYSTEM_PROMPT = """You are a helpful AI assistant, called {name}.
 **Core Directives:**
 1.  **Always Use Tools for Tasks:** For any user request that requires an action (e.g., sending an email, searching for information, creating an event, displaying a chart), you MUST use a tool. Do not refuse a task if a tool might exist for it.
 
-2. Check if your existing tools or knowledge can handle the user's request. If they can, use them. If they cannot, you must call the `search_tools` function to find the right tools for the user's request.You must not use the same/similar query multiple times in the list. The list should have multiple queries only if the task has clearly different sub-tasks. If you do not find any specific relevant tools, use the pre-loaded generic tools.
+2. Check if your existing tools or knowledge can handle the user's request. If they can, use them. If they cannot, you must call the `search_tools` function to find the right tools for the user's request. You must not use the same/similar query multiple times in the list. The list should have multiple queries only if the task has clearly different sub-tasks. If you do not find any specific relevant tools, use the pre-loaded generic tools. Only use `search_tools` if your existing capabilities cannot handle the request.
 
-3.  **Load Tools:** After looking at the output of `search_tools`, you MUST call the `load_tools` function to load only the tools you want to use. Provide the full tool ids, not just the app names. Use your judgement to eliminate irrelevant apps that came up just because of semantic similarity. However, sometimes, multiple apps might be relevant for the same task. Prefer connected apps over unconnected apps while breaking a tie. If more than one relevant app (or none of the relevant apps) are connected, you must ask the user to choose the app. In case the user asks you to use an app that is not connected, call the apps tools normally. The tool will return a link for connecting that you should pass on to the user.
+3.  **Load Tools:** After looking at the output of `search_tools`, you MUST call the `load_tools` function to load only the tools you want to use. Provide the full tool ids, not just the app names. Use your judgement to eliminate irrelevant apps that came up just because of semantic similarity. However, sometimes, multiple apps might be relevant for the same task. Prefer connected apps over unconnected apps while breaking a tie. If more than one relevant app (or none of the relevant apps) are connected, you must ask the user to choose the app. In case the user asks you to use an app that is not connected, call the apps tools normally. The tool will return a link for connecting that you should pass on to the user. Only load tools if your existing capabilities cannot handle the request.
 
 4.  **Strictly Follow the Process:** Your only job in your first turn is to analyze the user's request and answer using existing tools/knowledge or `search_tools` with a concise query describing the core task. Do not engage in conversation, or extend the conversation beyond the user's request.
 

universal_mcp/agents/bigtool/tools.py

@@ -34,8 +34,8 @@ def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
             for tools_list in query_results:
                 for tool in tools_list:
                     app = tool["id"].split("__")[0]
-                    if len(app_tools[app]) < 5:
-                        app_tools[app].append(f"{tool['id']}: {tool['description']}")
+                    cleaned_desc = tool["description"].split("Context:")[0].strip()
+                    app_tools[app].append(f"{tool['id']}: {cleaned_desc}")
 
             # Build result string efficiently
             result_parts = []
@@ -98,8 +98,13 @@ def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
     return {"search_tools": search_tools, "load_tools": load_tools, "web_search": web_search}
 
 
-async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> list[str]:
+async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> tuple[list[str], list[str]]:
+    """For a given list of tool_ids, validates the tools and returns a list of links for the apps that have not been logged in"""
     correct, incorrect = [], []
+    connections = await registry.list_connected_apps()
+    connected_apps = {connection["app_id"] for connection in connections}
+    unconnected = set()
+    unconnected_links = []
     app_tool_list: dict[str, set[str]] = {}
 
     # Group tool_ids by app for fewer registry calls
@@ -132,10 +137,18 @@ async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> list[s
         if available is None:
             incorrect.extend(tool_id for tool_id, _ in tool_entries)
             continue
+        if app not in connected_apps and app not in unconnected:
+            unconnected.add(app)
+            text = registry.client.get_authorization_url(app)
+            start = text.find(":") + 1
+            end = text.find(". R", start)
+            url = text[start:end].strip()
+            markdown_link = f"[{app}]({url})"
+            unconnected_links.append(markdown_link)
         for tool_id, tool_name in tool_entries:
             if tool_name in available:
                 correct.append(tool_id)
             else:
                 incorrect.append(tool_id)
 
-    return correct
+    return correct, unconnected_links

universal_mcp/agents/builder/__main__.py

@@ -1,12 +1,13 @@
 import asyncio
-import json
 from uuid import uuid4
 
 from langgraph.checkpoint.memory import MemorySaver
 from loguru import logger
 from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.types import ToolConfig
 
 from universal_mcp.agents.builder.builder import BuilderAgent
+from universal_mcp.agents.builder.state import Agent
 
 
 async def run_interactive_build():
@@ -27,30 +28,43 @@ async def run_interactive_build():
 
     conversation_script = [
         "Send an email to manoj@agentr.dev with the subject 'Hello' and body 'This is a test of the Gmail agent.' from my Gmail account.",
-        "Use outlook instead of gmail",
+        "Add the mail to my draft also",
+        "also make a reddit post on r/test with the title 'Test Post' and body 'This is a test post from the Reddit agent.'",
     ]
 
-    final_result = {}
+    # These variables will hold the state between turns
+    latest_agent: Agent | None = None
+    latest_tools: ToolConfig | None = None
+
     for i, user_input in enumerate(conversation_script):
         logger.info(f"\n--- Conversation Turn {i + 1} ---")
         logger.info(f"User Request: '{user_input}'")
 
-        result = await agent.invoke(user_input=user_input, thread_id=thread_id)
-        final_result.update(result)  # Keep updating the final result
+        # Construct the payload based on the current state of the conversation
+        payload = {"userInput": user_input}
+        if latest_agent:
+            # On subsequent turns, pass the existing agent and tools for modification
+            payload["agent"] = latest_agent.model_dump()  # Convert Pydantic model to dict
+            payload["tools"] = latest_tools
+
+        # The invoke method now takes a single payload dictionary
+        result = await agent.invoke(thread_id=thread_id, user_input=payload)
 
-        generated_agent = final_result.get("generated_agent")
-        tool_config = final_result.get("tool_config")
+        # Update the latest state for the next turn
+        latest_agent = result.get("generated_agent")
+        latest_tools = result.get("tool_config")
 
-        if generated_agent:
+        if latest_agent:
             logger.info("--- Generated/Modified Agent ---")
-            logger.info(f"Name: {generated_agent.name}")
-            logger.info(f"Description: {generated_agent.description}")
-            logger.info(f"Expertise: {generated_agent.expertise}")
-            logger.info(f"Instructions:\n{generated_agent.instructions}")
+            logger.info(f"Name: {latest_agent.name}")
+            logger.info(f"Description: {latest_agent.description}")
+            logger.info(f"Expertise: {latest_agent.expertise}")
+            logger.info(f"Instructions:\n{latest_agent.instructions}")
+            logger.info(f"Schedule: {latest_agent.schedule}")
 
-        if tool_config:
+        if latest_tools:
             logger.info("--- Selected Tools ---")
-            tools_str = "\n".join(f"- {app}: {', '.join(tool_ids)}" for app, tool_ids in tool_config.items())
+            tools_str = "\n".join(f"- {app}: {', '.join(tool_ids)}" for app, tool_ids in latest_tools.items())
             logger.info(tools_str)
         else:
             logger.info("--- Selected Tools ---")
@@ -65,35 +79,62 @@ async def run_conversation_build():
     agent = BuilderAgent(
         name="Builder Agent",
         instructions="You build agents from conversation transcripts.",
-        model="anthropic/claude-4-sonnet-20250514",
+        model="azure/gpt-4.1",
         registry=registry,
     )
 
     sample_conversation_history = [
+        {"type": "human", "content": "hi"},
+        {"type": "ai", "content": "Hello! How can I help you today?"},
+        {"type": "human", "content": "use the zenquotes tool to tell me a quote"},
+        {"type": "ai", "content": ""},
+        {
+            "type": "tool",
+            "content": "\"Tools from zenquotes (status: connected by user):\\n - zenquotes__get_random_quote: Fetches a random inspirational quote from the Zen Quotes API via an HTTP request. It parses the JSON response to extract the quote and author, returning them as a single formatted string ('quote - author'). This function is the primary tool provided by the ZenquotesApp.\\n - zenquotes__get_random_quote: Fetches a random inspirational quote from the Zen Quotes API via an HTTP request. It parses the JSON response to extract the quote and author, returning them as a single formatted string ('quote - author'). This function is the primary tool provided by the ZenquotesApp.\\n\\nTools from perplexity (status: NOT connected by user):\\n - perplexity__answer_with_search: Queries the Perplexity Chat Completions API for a web-search-grounded answer. It sends the user's prompt and model parameters to the `/chat/completions` endpoint, then parses the response to return the synthesized content and a list of supporting source citations, ideal for real-time information retrieval.\\n - perplexity__answer_with_search: Queries the Perplexity Chat Completions API for a web-search-grounded answer. It sends the user's prompt and model parameters to the `/chat/completions` endpoint, then parses the response to return the synthesized content and a list of supporting source citations, ideal for real-time information retrieval.\\n\\nCall load_tools to select the required tools only.\"",
+        },
+        {"type": "ai", "content": ""},
         {
-            "type": "human",
-            "content": "Hey, can you look at our main branch on the universal-mcp repo and tell me what the last 3 pull requests were?",
+            "type": "tool",
+            "content": "\"Successfully loaded 1 tools: ['zenquotes__get_random_quote']\"",
+            "name": "zenquotes__get_random_quote",
+        },
+        {"type": "ai", "content": ""},
+        {
+            "type": "tool",
+            "content": '"Decide upon your major definite purpose in life and then organize all your activities around it. - Brian Tracy"',
         },
         {
             "type": "ai",
-            "content": "Of course. The last 3 pull requests are: #101 'Fix login bug', #102 'Update documentation', and #103 'Add new chart component'.",
+            "content": 'Here’s your quote:  \n**"Decide upon your major definite purpose in life and then organize all your activities around it." – Brian Tracy**',
+        },
+        {"type": "human", "content": "send this quote to ankit@agentr.dev using gmail"},
+        {"type": "ai", "content": ""},
+        {
+            "type": "tool",
+            "content": '"Tools from google_mail (status: connected by user):\\n - google_mail__send_email: Composes and immediately sends an email message via the Gmail API. It can function as a reply within an existing conversation if a `thread_id` is provided. This action is distinct from `send_draft`, which sends a previously saved draft message, or `create_draft`, which only saves an email.\\n - google_mail__send_draft: Sends a pre-existing Gmail draft identified by its unique ID. It posts to the `/drafts/send` endpoint, converting a saved draft into a sent message. This function acts on drafts from `create_draft` and differs from `send_email`, which composes and sends an email in one step.\\n - google_mail__create_draft: Saves a new email draft in Gmail with a specified recipient, subject, and body. An optional thread ID can create the draft as a reply within an existing conversation, distinguishing it from `send_email`, which sends immediately.\\n - google_mail__get_draft: Retrieves a specific Gmail draft by its unique ID. This function allows specifying the output format (e.g., full, raw) to control the response detail. Unlike `list_drafts`, it fetches a single, known draft rather than a collection of multiple drafts.\\n\\nCall load_tools to select the required tools only."',
         },
+        {"type": "ai", "content": ""},
         {
-            "type": "human",
-            "content": "Awesome, thanks. Now can you draft a new Google Doc and put that list in there for me?",
+            "type": "tool",
+            "content": "\"Successfully loaded 1 tools: ['google_mail__send_email']\"",
+            "name": "google_mail__send_email",
         },
-        {"type": "ai", "content": "Done. I have created a new Google Doc with the list of the last 3 pull requests."},
+        {"type": "ai", "content": ""},
+        {"type": "tool", "content": '{"id": "199765690b278b56", "threadId": "199765690b278b56", "labelIds": ["SENT"]}'},
+        {"type": "ai", "content": "The quote has been sent to **ankit@agentr.dev** successfully. ✅"},
     ]
-    sample_tool_config = {"github": ["get_pull_requests"], "google_docs": ["create_document"]}
-    wingman_payload = {"conversation_history": sample_conversation_history, "tool_config": sample_tool_config}
 
     logger.info(f"Payload Conversation History Length: {len(sample_conversation_history)} messages")
-    logger.info(f"Payload Tools Provided: {list(sample_tool_config.keys())}")
 
-    # The payload must be passed as a JSON string in the 'user_input'
-    payload_str = json.dumps(wingman_payload)
     thread_id = str(uuid4())
-    result = await agent.invoke(user_input=payload_str, thread_id=thread_id)
+
+    # The payload contains the messages and a high-level instruction for the builder
+    payload = {
+        "userInput": "",
+        "messages": sample_conversation_history,
+    }
+
+    result = await agent.invoke(thread_id=thread_id, user_input=payload)
 
     generated_agent = result.get("generated_agent")
     tool_config = result.get("tool_config")
@@ -116,9 +157,69 @@ async def run_conversation_build():
         logger.error("Error: Tool configuration is missing.")
 
 
+async def run_modification_with_manual_tool():
+    """
+    Simulates a scenario where a user manually adds a tool to an agent's
+    configuration, and then uses the builder to modify the agent for a
+    different reason, expecting the manually added tool to be preserved.
+    """
+    logger.info("\n\n--- SCENARIO 3: MODIFY AGENT WITH MANUAL TOOL ADDITION ---")
+
+    registry = AgentrRegistry()
+    memory = MemorySaver()
+    agent = BuilderAgent(
+        name="Builder Agent",
+        instructions="You are a builder agent that creates other agents.",
+        model="azure/gpt-4.1",
+        registry=registry,
+        memory=memory,
+    )
+
+    thread_id = str(uuid4())
+
+    initial_request = "Send an email to manoj@agentr.dev with the subject 'Hello' using my Gmail account."
+    logger.info(f"User Request: '{initial_request}'")
+
+    # Initial agent creation
+    initial_payload = {"userInput": initial_request}
+    initial_result = await agent.invoke(thread_id=thread_id, user_input=initial_payload)
+
+    initial_agent = initial_result.get("generated_agent")
+    initial_tools = initial_result.get("tool_config")
+
+    logger.info("--- Initial Tools ---")
+    tools_str = "\n".join(f"- {app}: {', '.join(tool_ids)}" for app, tool_ids in initial_tools.items())
+    logger.info(tools_str)
+
+    # Manually add a new tool to the configuration
+    manually_modified_tools = initial_tools.copy()
+    manually_modified_tools["reddit"] = ["create_post"]
+    logger.info("--- Manually Modified Tools ---")
+    tools_str = "\n".join(f"- {app}: {', '.join(tool_ids)}" for app, tool_ids in manually_modified_tools.items())
+    logger.info(tools_str)
+
+    modification_request = "Also add the above email to my draft"
+    logger.info(f"User Request: '{modification_request}'")
+
+    # Prepare payload for modification, passing the existing agent and the manually updated tools
+    modification_payload = {
+        "userInput": modification_request,
+        "agent": initial_agent.model_dump(),  # Convert Pydantic model to dict
+        "tools": manually_modified_tools,
+    }
+
+    final_result = await agent.invoke(thread_id=thread_id, user_input=modification_payload)
+
+    final_tools = final_result.get("tool_config")
+    logger.info("--- Final Tools After Modification (should include manual addition) ---")
+    tools_str = "\n".join(f"- {app}: {', '.join(tool_ids)}" for app, tool_ids in final_tools.items())
+    logger.info(tools_str)
+
+
 async def main():
-    await run_interactive_build()
+    # await run_interactive_build()
     await run_conversation_build()
+    # await run_modification_with_manual_tool()
 
 
 if __name__ == "__main__":