universal-mcp-agents 0.1.14__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):
@@ -116,7 +117,7 @@ class BaseAgent:
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
             "run_id": thread_id,
-            "run_name" : self.name
+            "run_name": self.name,
         }
 
         result = await self._graph.ainvoke(

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,4 +1,5 @@
 from universal_mcp.agentr.registry import AgentrRegistry
+
 from universal_mcp.agents.bigtool import BigToolAgent
 
 

universal_mcp/agents/bigtool/graph.py

@@ -11,9 +11,10 @@ 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
-from universal_mcp.agents.utils import filter_retry_on
 
 load_dotenv()
 
@@ -96,13 +97,16 @@ def build_graph(
         for tool_call in tool_calls:
             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)
+                    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
-                        ai_msg = f"Please login to the following app(s) using the following links and let me know in order to proceed:\n {'\n'.join(unconnected_links)} "
+                        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"])
@@ -115,7 +119,6 @@ def build_graph(
             except Exception as e:
                 tool_result = f"Error during {tool_call}: {e}"
 
-
             tool_message = ToolMessage(
                 content=json.dumps(tool_result),
                 name=tool_call["name"],

universal_mcp/agents/bigtool/tools.py

@@ -34,9 +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:
-                        cleaned_desc = tool['description'].split("Context:")[0].strip()
-                        app_tools[app].append(f"{tool['id']}: {cleaned_desc}")
+                    cleaned_desc = tool["description"].split("Context:")[0].strip()
+                    app_tools[app].append(f"{tool['id']}: {cleaned_desc}")
 
             # Build result string efficiently
             result_parts = []
@@ -133,7 +132,7 @@ async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> tuple[
             app_tool_list[app] = tools
 
     # Validate tool_ids
-    for app, tool_entries in app_to_tools.items():        
+    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)
@@ -142,7 +141,7 @@ async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> tuple[
             unconnected.add(app)
             text = registry.client.get_authorization_url(app)
             start = text.find(":") + 1
-            end = text.find(".", start)
+            end = text.find(". R", start)
             url = text[start:end].strip()
             markdown_link = f"[{app}]({url})"
             unconnected_links.append(markdown_link)

universal_mcp/agents/builder/__main__.py

@@ -19,7 +19,7 @@ async def run_interactive_build():
     agent = BuilderAgent(
         name="Builder Agent",
         instructions="You are a builder agent that creates other agents.",
-        model="azure/gpt-4.1",
+        model="anthropic/claude-4-sonnet-20250514",
         registry=registry,
         memory=memory,
     )
@@ -40,9 +40,15 @@ async def run_interactive_build():
         logger.info(f"\n--- Conversation Turn {i + 1} ---")
         logger.info(f"User Request: '{user_input}'")
 
-        # The first turn is a new build (agent=None).
-        # Subsequent turns are modifications, passing the previously generated agent.
-        result = await agent.invoke(user_input=user_input, thread_id=thread_id, agent=latest_agent, tools=latest_tools)
+        # 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)
 
         # Update the latest state for the next turn
         latest_agent = result.get("generated_agent")
@@ -67,7 +73,7 @@ async def run_interactive_build():
 
 async def run_conversation_build():
     """Simulates a one-shot agent build from a conversation history payload."""
-    logger.info("\n\n--- SCENARIO 3: AGENT BUILD FROM CONVERSATION HISTORY ---")
+    logger.info("\n\n--- SCENARIO 2: AGENT BUILD FROM CONVERSATION HISTORY ---")
 
     registry = AgentrRegistry()
     agent = BuilderAgent(
@@ -87,7 +93,11 @@ async def run_conversation_build():
             "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": "tool", "content": "\"Successfully loaded 1 tools: ['zenquotes__get_random_quote']\"", "name": "zenquotes__get_random_quote"},
+        {
+            "type": "tool",
+            "content": "\"Successfully loaded 1 tools: ['zenquotes__get_random_quote']\"",
+            "name": "zenquotes__get_random_quote",
+        },
         {"type": "ai", "content": ""},
         {
             "type": "tool",
@@ -104,7 +114,11 @@ async def run_conversation_build():
             "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": "tool", "content": "\"Successfully loaded 1 tools: ['google_mail__send_email']\"", "name": "google_mail__send_email"},
+        {
+            "type": "tool",
+            "content": "\"Successfully loaded 1 tools: ['google_mail__send_email']\"",
+            "name": "google_mail__send_email",
+        },
         {"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. ✅"},
@@ -113,11 +127,14 @@ async def run_conversation_build():
     logger.info(f"Payload Conversation History Length: {len(sample_conversation_history)} messages")
 
     thread_id = str(uuid4())
-    result = await agent.invoke(
-        thread_id=thread_id,
-        user_input="Generate an agent from the provided conversation.",  # This input is for logging/tracing
-        messages=sample_conversation_history,
-    )
+
+    # 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")
@@ -146,7 +163,7 @@ async def run_modification_with_manual_tool():
     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 2: MODIFY AGENT WITH MANUAL TOOL ADDITION ---")
+    logger.info("\n\n--- SCENARIO 3: MODIFY AGENT WITH MANUAL TOOL ADDITION ---")
 
     registry = AgentrRegistry()
     memory = MemorySaver()
@@ -163,38 +180,47 @@ async def run_modification_with_manual_tool():
     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_result = await agent.invoke(user_input=initial_request, thread_id=thread_id)
+    # 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}'")
 
-    final_result = await agent.invoke(
-        user_input=modification_request,
-        thread_id=thread_id,
-        agent=initial_agent,
-        tools=manually_modified_tools,
-    )
+    # 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()
+    # await run_modification_with_manual_tool()
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

universal_mcp/agents/builder/builder.py

@@ -1,26 +1,24 @@
+import asyncio
 import json
 
 from langchain_core.messages import HumanMessage
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import END, START, StateGraph
+from langgraph.types import Command
 from loguru import logger
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig
-from langgraph.types import Command
 
 from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.builder.prompts import (
-    NEW_AGENT_PROMPT,
-    MODIFY_AGENT_PROMPT,
-)
-from universal_mcp.agents.builder.state import Agent, BuilderState
-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.builder.helper import (
-    _extract_tools_from_history,
     _clean_conversation_history,
+    _extract_tools_from_history,
     _merge_tool_configs,
 )
+from universal_mcp.agents.builder.prompts import _build_prompt
+from universal_mcp.agents.builder.state import Agent, BuilderState
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.agents.shared.tool_node import build_tool_node_graph
 
 
 class BuilderAgent(BaseAgent):
@@ -69,16 +67,15 @@ class BuilderAgent(BaseAgent):
         if messages:
             initial_state["messages"] = [HumanMessage(content=json.dumps(messages))]
         elif not userInput and not agent:
-             raise ValueError("Either 'user_input' or 'messages' must be provided for a new agent.")
-
+            raise ValueError("Either 'user_input' or 'messages' must be provided for a new agent.")
 
-        run_metadata = { "agent_name": self.name, "is_background_run": False }
+        run_metadata = {"agent_name": self.name, "is_background_run": False}
 
         config = {
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
             "run_id": thread_id,
-            "run_name" : self.name
+            "run_name": self.name,
         }
 
         final_state = await graph.ainvoke(initial_state, config=config)
@@ -88,70 +85,109 @@ class BuilderAgent(BaseAgent):
         """
         Determines the entry point of the graph based on the initial state.
         """
-        if state.get("generated_agent"):
+        has_agent = state.get("generated_agent") is not None
+        has_messages = bool(state.get("messages"))
+        has_user_task = bool(state.get("user_task"))
+
+        if has_agent:
             logger.info("Routing to: modify_agent.")
             return "modify_agent"
+        elif has_messages:
+            logger.info("Routing to: create_agent_from_history.")
+            return "create_agent_from_history"
+        elif has_user_task:
+            logger.info("Routing to: create_agent_from_input.")
+            return "create_agent_from_input"
         else:
-            logger.info("Routing to: create_agent.")
-            return "create_agent"
-
-    async def _create_agent(self, state: BuilderState):
-        """Generates a new agent profile from scratch."""
-        if not state.get("user_task") and not state["messages"]:
-            raise ValueError("To create a new agent, provide either a 'user_task' or 'messages'.")
-        
-        user_task = state.get("user_task") or "Not provided"
-        conversation_history = []
-
-        if state["messages"]:
-            content_str = state["messages"][-1].content
-            raw_history = json.loads(content_str)
-            conversation_history = _clean_conversation_history(raw_history)
-
-        prompt = NEW_AGENT_PROMPT.format(
-            user_task=user_task,
-            conversation_history=json.dumps(conversation_history, indent=2),
+            raise ValueError("Invalid initial state. Cannot determine route.")
+
+    async def _create_agent_from_input(self, state: BuilderState) -> Command:
+        """SCENARIO 1: Generates a new agent from a single user_input, running agent and tool creation in parallel."""
+        user_task = state["user_task"]
+        logger.info(f"Creating new agent from input: '{user_task}'")
+
+        structured_llm = self.llm.with_structured_output(Agent)
+
+        async def _task_generate_agent():
+            prompt = _build_prompt(user_task=user_task)
+            return await structured_llm.ainvoke(prompt)
+
+        async def _task_find_tools():
+            return await self._get_tool_config_for_task(user_task)
+
+        # Run agent creation and tool finding concurrently for max efficiency
+        agent_profile, tool_config = await asyncio.gather(_task_generate_agent(), _task_find_tools())
+
+        logger.info(f"Successfully created agent '{agent_profile.name}' with tools: {tool_config}")
+
+        return Command(
+            update={"generated_agent": agent_profile, "tool_config": tool_config},
+            goto=END,
         )
 
+    async def _create_agent_from_history(self, state: BuilderState) -> Command:
+        """SCENARIO 2: Generates an agent by synthesizing a conversation history."""
+        user_task = state.get("user_task")
+
+        content_str = state["messages"][-1].content
+        raw_history = json.loads(content_str)
+        conversation_history = _clean_conversation_history(raw_history)
+
+        logger.info(f"Creating new agent from conversation history (length: {len(conversation_history)}).")
+
+        # 1. Generate the agent profile first to get the definitive instructions
+        tools_from_history = _extract_tools_from_history(raw_history)
+        prompt = _build_prompt(
+            user_task=user_task,
+            conversation_history=conversation_history,
+            tool_config=tools_from_history,
+        )
         structured_llm = self.llm.with_structured_output(Agent)
         generated_agent = await structured_llm.ainvoke(prompt)
-        
-        logger.info(f"Successfully created new agent '{generated_agent.name}'.")
+        logger.info(f"Successfully generated agent profile for '{generated_agent.name}'.")
+
+        # 2. Synthesize tool configuration based on the new instructions and history
+        tools_from_instructions = await self._get_tool_config_for_task(generated_agent.instructions)
+
+        final_tool_config = _merge_tool_configs(tools_from_history, tools_from_instructions)
+        logger.info(f"Final synthesized tool configuration: {final_tool_config}")
 
         return Command(
-            update={"generated_agent": generated_agent},
-            goto="create_or_update_tool_config",
+            update={
+                "generated_agent": generated_agent,
+                "tool_config": final_tool_config,
+            },
+            goto=END,
         )
 
-    async def _modify_agent(self, state: BuilderState):
-        """Modifies an existing agent based on new user feedback and/or conversation."""
+    async def _modify_agent(self, state: BuilderState) -> Command:
+        """SCENARIO 3: Modifies an existing agent and re-evaluates its tool configuration."""
         existing_agent = state["generated_agent"]
-        
-        if not state.get("user_task") and not state["messages"]:
-            raise ValueError("To modify an agent, provide either a 'user_task' or 'messages'.")
-        
-        modification_request = state.get("user_task") or "No direct modification request provided."
-        
-        conversation_history = []
-        if state["messages"]:
-            content_str = state["messages"][-1].content
-            raw_history = json.loads(content_str)
-            conversation_history = _clean_conversation_history(raw_history)
-
-        prompt = MODIFY_AGENT_PROMPT.format(
+        modification_request = state["user_task"]
+        existing_tools = state["tool_config"]
+
+        logger.info(f"Modifying existing agent '{existing_agent.name}' with request: '{modification_request}'")
+
+        # 1. Generate the modified agent profile to get the new definitive instructions
+        prompt = _build_prompt(
             existing_instructions=existing_agent.instructions,
             modification_request=modification_request,
-            conversation_history=json.dumps(conversation_history, indent=2),
         )
-
         structured_llm = self.llm.with_structured_output(Agent)
         modified_agent = await structured_llm.ainvoke(prompt)
+        logger.info(f"Successfully generated modified agent profile for '{modified_agent.name}'.")
+
+        # 2. Update tool configuration based on the NEW instructions, preserving existing tools
+        tools_from_new_instructions = await self._get_tool_config_for_task(modified_agent.instructions)
+        final_tool_config = _merge_tool_configs(existing_tools, tools_from_new_instructions)
+        logger.info(f"Final updated tool configuration: {final_tool_config}")
 
-        logger.info(f"Successfully modified agent '{modified_agent.name}'.")
-        
         return Command(
-            update={"generated_agent": modified_agent},
-            goto="create_or_update_tool_config"
+            update={
+                "generated_agent": modified_agent,
+                "tool_config": final_tool_config,
+            },
+            goto=END,
         )
 
     async def _get_tool_config_for_task(self, task: str) -> ToolConfig:
@@ -162,53 +198,16 @@ class BuilderAgent(BaseAgent):
         final_state = await tool_finder_graph.ainvoke({"original_task": task})
         return final_state.get("execution_plan") or {}
 
-    async def _create_or_update_tool_config(self, state: BuilderState):
-        """
-        Creates or updates the tool configuration by synthesizing tools from multiple sources:
-        1.  Existing tool config (if any).
-        2.  Tools extracted from conversation history.
-        3.  Tools inferred from the agent's primary instructions.
-        4.  Tools inferred from the user's direct input/task.
-        """
-        # 1. Get the existing configuration, if it exists
-        final_tool_config = state.get("tool_config") or {}
-        
-        # 2. Extract tools directly from the conversation history
-        if state["messages"]:
-            content_str = state["messages"][-1].content
-            raw_history = json.loads(content_str)
-            history_tool_config = _extract_tools_from_history(raw_history)
-            final_tool_config = _merge_tool_configs(final_tool_config, history_tool_config)
-
-        # 3. Find tools based on the agent's synthesized instructions (even if modifying)
-        instructions_task = state["generated_agent"].instructions
-        instructions_tool_config = await self._get_tool_config_for_task(instructions_task)
-        final_tool_config = _merge_tool_configs(final_tool_config, instructions_tool_config)
-        
-        # 4. Find tools based on the direct user input (when creating a new agent)
-        user_task = state.get("user_task")
-        if user_task:
-            user_task_tool_config = await self._get_tool_config_for_task(user_task)
-            final_tool_config = _merge_tool_configs(final_tool_config, user_task_tool_config)
-
-        logger.info(f"Final synthesized tool configuration: {final_tool_config}")
-
-        return Command(
-            update={"tool_config": final_tool_config},
-            goto=END,
-        )
-
     async def _build_graph(self):
-        """Builds the conversational agent graph."""
+        """Builds the conversational agent graph with the new, scenario-based structure."""
         builder = StateGraph(BuilderState)
 
-        builder.add_node("create_agent", self._create_agent)
+        # Add the three self-contained nodes for each scenario
+        builder.add_node("create_agent_from_input", self._create_agent_from_input)
+        builder.add_node("create_agent_from_history", self._create_agent_from_history)
         builder.add_node("modify_agent", self._modify_agent)
-        builder.add_node("create_or_update_tool_config", self._create_or_update_tool_config)
 
-        builder.add_conditional_edges(
-            START,
-            self._entry_point_router,
-        )
+        # The entry point router directs to one of the three nodes, and they all go to END
+        builder.add_conditional_edges(START, self._entry_point_router)
 
-        return builder.compile(checkpointer=self.memory)
+        return builder.compile(checkpointer=self.memory)

universal_mcp/agents/builder/helper.py

@@ -1,9 +1,10 @@
-from collections import defaultdict
 import collections
+from collections import defaultdict
 
 from loguru import logger
 from universal_mcp.types import ToolConfig
 
+
 def _extract_tools_from_history(history: list[dict]) -> ToolConfig:
     """
     Parses a conversation history to find and extract all tool names,
@@ -28,10 +29,7 @@ def _extract_tools_from_history(history: list[dict]) -> ToolConfig:
                 app_id, tool_id = full_tool_name.split("__", 1)
                 apps_with_tools[app_id].add(tool_id)
 
-    return {
-        app_id: sorted(list(tools))
-        for app_id, tools in apps_with_tools.items()
-    }
+    return {app_id: sorted(list(tools)) for app_id, tools in apps_with_tools.items()}
 
 
 def _clean_conversation_history(history: list[dict]) -> list[dict]:
@@ -70,4 +68,4 @@ def _merge_tool_configs(old_config: ToolConfig, new_config: ToolConfig) -> ToolC
     # Convert the sets back to sorted lists for consistent output
     final_config = {app: sorted(list(tool_set)) for app, tool_set in merged_config.items()}
     logger.info(f"Merged tool configuration: {final_config}")
-    return final_config
+    return final_config