universal-mcp-agents 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

universal_mcp/agents/builder/builder.py

@@ -1,42 +1,26 @@
 import json
-from collections import defaultdict
 
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.messages import HumanMessage
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import END, START, StateGraph
 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 (
-    AGENT_BUILDER_INSTRUCTIONS,
-    AGENT_FROM_CONVERSATION_PROMPT,
-    TASK_SYNTHESIS_PROMPT,
+    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
-
-
-async def generate_agent(llm: BaseChatModel, task: str, old_agent: Agent | None = None) -> Agent:
-    """Generates an agent from a task, optionally modifying an existing one."""
-    prompt_parts = [AGENT_BUILDER_INSTRUCTIONS]
-    if old_agent:
-        prompt_parts.append(
-            "\nThe user wants to modify the following agent design. "
-            "Incorporate their feedback into a new design.\n\n"
-            f"**User Feedback:** {task}\n\n"
-            f"{old_agent.model_dump_json(indent=2)}"
-        )
-    else:
-        prompt_parts.append(f"\n\n**Task:** {task}")
-
-    prompt = "\n".join(prompt_parts)
-    structured_llm = llm.with_structured_output(Agent)
-    agent = await structured_llm.ainvoke(prompt)
-    return agent
+from universal_mcp.agents.builder.helper import (
+    _extract_tools_from_history,
+    _clean_conversation_history,
+    _merge_tool_configs,
+)
 
 
 class BuilderAgent(BaseAgent):
@@ -57,169 +41,174 @@ class BuilderAgent(BaseAgent):
             **kwargs,
         )
         self.registry = registry
-        self.llm: BaseChatModel = load_chat_model(model, thinking=False)
+        self.llm = load_chat_model(model, thinking=False)
 
-    def _entry_point_router(self, state: BuilderState):
+    async def invoke(
+        self,
+        thread_id: str,
+        user_input: dict,
+    ):
         """
-        Determines the entry point of the graph based on the input format and conversation history.
-        - If input is a JSON with 'conversation_history', it builds from the conversation.
-        - If an agent has already been generated, it assumes a modification is requested.
-        - Otherwise, it starts a fresh build from a text prompt.
+        Overrides BaseAgent.invoke to build or modify an agent.
+        This is the primary entry point for the Builder Agent.
         """
-        last_message_content = state["messages"][-1].content
-        try:
-            # Case 1: Input is a JSON for building from a conversation
-            payload = json.loads(last_message_content)
-            if isinstance(payload, dict) and "conversation_history" in payload and "tool_config" in payload:
-                logger.info("Routing to: build from conversation history.")
-                return "synthesize_from_conversation"
-        except (json.JSONDecodeError, TypeError):
-            # Input is not a valid JSON, proceed as an interactive build
-            pass
-
-        # Case 2: It's an interactive build, check for modification vs. new
-        if state.get("generated_agent"):
-            logger.info("Routing to: modify existing agent.")
-            return "synthesize_new_task"
-        else:
-            logger.info("Routing to: new agent build.")
-            return "prepare_for_build"
-
-    async def _prepare_for_build(self, state: BuilderState):
-        """Sets the initial user task to begin the build process."""
-        last_message = state["messages"][-1]
-        task = last_message.content
-        yield {
-            "user_task": task,
-        }
-
-    async def _create_agent(self, state: BuilderState):
-        """Creates or updates the agent definition from a user_task."""
-        task = state["user_task"]
-        agent = state.get("generated_agent")
+        keys = ("userInput", "agent", "tools", "messages")
+        userInput, agent_data, tools, messages = (user_input.get(k) for k in keys)
+        agent = Agent(**agent_data) if agent_data else None
+
+        await self.ainit()
+        graph = self._graph
+
+        initial_state = BuilderState(
+            user_task=userInput,
+            generated_agent=agent,
+            tool_config=tools,
+            messages=[],
+        )
 
-        generated_agent = await generate_agent(self.llm, task, agent)
-        yield {
-            "generated_agent": generated_agent,
-        }
+        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.")
 
-    async def _get_tool_config_for_task(self, task: str) -> ToolConfig:
-        """Helper method to find and configure tools for a given task string."""
-        tool_finder_graph = build_tool_node_graph(self.llm, self.registry)
-        initial_state = {
-            "original_task": task,
-            "decomposition_attempts": 0,
-        }
-        final_state = await tool_finder_graph.ainvoke(initial_state)
-        execution_plan = final_state.get("execution_plan")
 
-        if not execution_plan:
-            return {}
+        run_metadata = { "agent_name": self.name, "is_background_run": False }
 
-        apps_with_tools = defaultdict(list)
-        for step in execution_plan:
-            app_id = step.get("app_id")
-            tool_ids = step.get("tool_ids")
-            if app_id and tool_ids:
-                apps_with_tools[app_id].extend(tool_ids)
-
-        return {app_id: list(set(tools)) for app_id, tools in apps_with_tools.items()}
-
-    async def _create_tool_config(self, state: BuilderState):
-        """Creates the tool configuration for the agent."""
-        task = state["user_task"]
-        tool_config = await self._get_tool_config_for_task(task)
-        yield {
-            "tool_config": tool_config,
+        config = {
+            "configurable": {"thread_id": thread_id},
+            "metadata": run_metadata,
+            "run_id": thread_id,
+            "run_name" : self.name
         }
 
-    async def _synthesize_new_task_from_feedback(self, state: BuilderState):
-        """Synthesizes a new user_task from the original task and subsequent user feedback."""
-        original_task = next((msg.content for msg in state["messages"] if isinstance(msg, HumanMessage)), None)
-        modification_request = state["messages"][-1].content
-
-        if not original_task:
-            raise ValueError("Could not find the original task in the conversation history.")
-
-        synthesis_prompt = TASK_SYNTHESIS_PROMPT.format(
-            original_task=original_task,
-            modification_request=modification_request,
-        )
-
-        response = await self.llm.ainvoke(synthesis_prompt)
-        new_synthesized_task = response.content.strip()
-        logger.info(f"The new synthesized task is: {new_synthesized_task}")
-        yield {
-            "user_task": new_synthesized_task,
-        }
+        final_state = await graph.ainvoke(initial_state, config=config)
+        return final_state
 
-    async def _synthesize_from_conversation(self, state: BuilderState):
+    def _entry_point_router(self, state: BuilderState):
         """
-        Takes conversation history and used tools from input to synthesize a complete agent profile.
-        This is a one-shot generation.
+        Determines the entry point of the graph based on the initial state.
         """
-        content_str = state["messages"][-1].content
-        initial_input = json.loads(content_str)
+        if state.get("generated_agent"):
+            logger.info("Routing to: modify_agent.")
+            return "modify_agent"
+        else:
+            logger.info("Routing to: create_agent.")
+            return "create_agent"
 
-        conversation_history = initial_input.get("conversation_history")
-        tool_config = initial_input.get("tool_config")
+    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),
+        )
 
-        if not conversation_history or not tool_config:
-            raise ValueError("Input must be a dictionary containing 'conversation_history' and 'tool_config'.")
+        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}'.")
 
-        prompt = AGENT_FROM_CONVERSATION_PROMPT.format(
+        return Command(
+            update={"generated_agent": generated_agent},
+            goto="create_or_update_tool_config",
+        )
+
+    async def _modify_agent(self, state: BuilderState):
+        """Modifies an existing agent based on new user feedback and/or conversation."""
+        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(
+            existing_instructions=existing_agent.instructions,
+            modification_request=modification_request,
             conversation_history=json.dumps(conversation_history, indent=2),
-            tool_config=json.dumps(tool_config, indent=2),
         )
 
         structured_llm = self.llm.with_structured_output(Agent)
-        generated_agent_profile = await structured_llm.ainvoke(prompt)
-
-        yield {
-            "generated_agent": generated_agent_profile,
-            "tool_config": tool_config,
-            "messages": [
-                AIMessage(
-                    content=f"Successfully generated agent '{generated_agent_profile.name}' from the conversation history."
-                )
-            ],
-        }
+        modified_agent = await structured_llm.ainvoke(prompt)
+
+        logger.info(f"Successfully modified agent '{modified_agent.name}'.")
+        
+        return Command(
+            update={"generated_agent": modified_agent},
+            goto="create_or_update_tool_config"
+        )
+
+    async def _get_tool_config_for_task(self, task: str) -> ToolConfig:
+        """Helper method to find and configure tools for a given task string."""
+        if not task:
+            return {}
+        tool_finder_graph = build_tool_node_graph(self.llm, self.registry)
+        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."""
         builder = StateGraph(BuilderState)
 
-        # Add nodes
-        builder.add_node("prepare_for_build", self._prepare_for_build)
         builder.add_node("create_agent", self._create_agent)
-        builder.add_node("create_tool_config", self._create_tool_config)
-        builder.add_node("synthesize_new_task", self._synthesize_new_task_from_feedback)
-        builder.add_node("synthesize_from_conversation", self._synthesize_from_conversation)
+        builder.add_node("modify_agent", self._modify_agent)
+        builder.add_node("create_or_update_tool_config", self._create_or_update_tool_config)
 
-        # The conditional entry point decides the workflow
         builder.add_conditional_edges(
             START,
             self._entry_point_router,
-            {
-                "prepare_for_build": "prepare_for_build",
-                "synthesize_new_task": "synthesize_new_task",
-                "synthesize_from_conversation": "synthesize_from_conversation",
-            },
         )
 
-        # Path for a fresh interactive build
-        builder.add_edge("prepare_for_build", "create_agent")
-        builder.add_edge("prepare_for_build", "create_tool_config")
-
-        # Path for modifying an existing build
-        builder.add_edge("synthesize_new_task", "create_agent")
-        builder.add_edge("synthesize_new_task", "create_tool_config")
-
-        # Path for building from conversation ends after its single step
-        builder.add_edge("synthesize_from_conversation", END)
-
-        # Interactive creation nodes lead to the end of the run
-        builder.add_edge("create_agent", END)
-        builder.add_edge("create_tool_config", END)
-
-        return builder.compile(checkpointer=self.memory)
+        return builder.compile(checkpointer=self.memory)

universal_mcp/agents/builder/helper.py

@@ -0,0 +1,73 @@
+from collections import defaultdict
+import collections
+
+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,
+    returning them in a structured ToolConfig format.
+
+    This function identifies messages with a "type" of "tool", extracts the
+    tool's name from the "name" key, and filters out a predefined list of
+    excluded tools. The remaining tool names are expected to be in an
+    "app_id__tool_id" format. These are then organized into a dictionary
+    mapping each app_id to a sorted list of its associated tool_ids.
+    """
+    apps_with_tools = collections.defaultdict(set)
+    excluded_tools = {"search_tools", "load_tools"}
+
+    for message in history:
+        if message.get("type") == "tool":
+            full_tool_name = message.get("name")
+            if not full_tool_name or full_tool_name in excluded_tools:
+                continue
+
+            if "__" in full_tool_name:
+                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()
+    }
+
+
+def _clean_conversation_history(history: list[dict]) -> list[dict]:
+    """
+    Filters a raw conversation history, keeping only messages relevant for
+    agent synthesis (human, ai, and tool messages with a name containing double underscores).
+    """
+    cleaned_history = []
+    for message in history:
+        msg_type = message.get("type")
+
+        if msg_type in ["human", "ai"]:
+            cleaned_history.append(message)
+        elif msg_type == "tool" and isinstance(message.get("name"), str) and "__" in message["name"]:
+            cleaned_history.append(message)
+
+    return cleaned_history
+
+
+def _merge_tool_configs(old_config: ToolConfig, new_config: ToolConfig) -> ToolConfig:
+    """Merges two tool configurations, taking the union of tools for each app."""
+    if not old_config:
+        return new_config
+    if not new_config:
+        return old_config
+
+    # Start with a copy of the old configuration
+    merged_config = defaultdict(set)
+    for app, tools in old_config.items():
+        merged_config[app].update(tools)
+
+    # Add the new tools, ensuring uniqueness
+    for app, tools in new_config.items():
+        merged_config[app].update(tools)
+
+    # 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

universal_mcp/agents/builder/prompts.py

@@ -1,173 +1,54 @@
-AGENT_BUILDER_INSTRUCTIONS = r"""
-You are a specialized Agent Generation AI, tasked with creating intelligent, effective, and context-aware AI agents based on user requests.
-
-When given a user's request, immediately follow this structured process:
-
-# 1. Intent Breakdown
-- Clearly identify the primary goal the user wants the agent to achieve.
-- Recognize any special requirements, constraints, formatting requests, or interaction rules.
-- Summarize your understanding briefly to ensure alignment with user intent.
+NEW_AGENT_PROMPT = r"""
+# ROLE & GOAL
+You are a specialized Agent Generation AI. Your primary function is to create a complete, high-quality AI agent profile based on the information provided.
 
-# 2. Agent Profile Definition
-- **Name (2-4 words)**: Concise, clear, and memorable name reflecting core functionality.
-- **Description (1-2 sentences)**: Captures the unique value and primary benefit to users.
-- **Expertise**: Precise domain-specific expertise area. Avoid vague or overly general titles.
-- **Instructions**: Compose detailed, highly actionable system instructions that directly command the agent's behavior. Respond in markdown as this text will be rendered in a rich text editor. Write instructions as clear imperatives, without preamble, assuming the agent identity is already established externally.
-- **Schedule**: If the user specifies a schedule, you should also provide a cron expression for the agent to run on. The schedule should be in a proper cron expression and nothing more. Do not respond with any other information or explain your reasoning for the schedule, otherwise this will cause a parsing error that is undesirable.
+# INPUTS
+1.  **User Task (Optional):** A brief, initial request from the user. This might be vague or specific.
+2.  **Conversation History (Optional):** A transcript of a conversation. This is the **primary source of truth**. If the conversation history is provided, it should be prioritized over the User Task to understand the user's full, potentially multi-step, objective.
 
-## ROLE & RESPONSIBILITY
-- Clearly state the agent's primary mission, e.g., "Your primary mission is...", "Your core responsibility is...".
-- Outline the exact tasks it handles, specifying expected input/output clearly.
+# INSTRUCTIONS
+Analyze the available inputs to fully understand the user's intent. Synthesize this understanding into a complete agent profile according to the specified JSON schema.
 
-## INTERACTION STYLE
-- Define exactly how to communicate with users: tone, format, response structure.
-- Include explicit commands, e.g., "Always wrap responses in \`\`\`text\`\`\` blocks.", "Never add greetings or meta-information.", "Always provide outputs in user's requested languages."
+- The first line of the `instructions` field in your output MUST be a single, complete sentence that serves as the definitive task for the agent. This sentence should be synthesized from your analysis of the inputs.
+- The rest of the `instructions` should provide clear, actionable commands for the agent, covering its role, responsibilities, interaction style, and output formatting.
 
-## OUTPUT FORMATTING RULES
-- Clearly specify formatting standards required by the user (e.g., JSON, plain text, markdown).
-- Include explicit examples to illustrate correct formatting.
+# TASK
+Based on the following inputs, generate a complete agent profile.
 
-## LIMITATIONS & CONSTRAINTS
-- Explicitly define boundaries of the agent's capabilities.
-- Clearly state what the agent must never do or say.
-- Include exact phrases for declining requests outside scope.
+**User Task:**
+{user_task}
 
-## REAL-WORLD EXAMPLES
-Provide two explicit interaction examples showing:
-- User's typical request.
-- Final agent response demonstrating perfect compliance.
+**Conversation History:**
+{conversation_history}
 
-Create an agent that feels thoughtfully designed, intelligent, and professionally reliable, perfectly matched to the user's original intent.
+**YOUR JSON OUTPUT:**
 """
 
-
-TASK_SYNTHESIS_PROMPT = r"""
+MODIFY_AGENT_PROMPT = r"""
 # ROLE & GOAL
-You are a 'Task Synthesizer' AI. Your sole purpose is to combine an original user task and a subsequent modification request into a single, complete, and coherent new task. This new task must be a standalone instruction that accurately reflects the user's final intent and can be used to configure a new AI agent from scratch.
+You are an expert Agent Modification AI. Your task is to intelligently update an existing AI agent's profile by integrating a user's modification request.
 
 # CORE PRINCIPLES
-1.  **Preserve All Details:** You must retain all specific, unmodified details from the original task (e.g., email addresses, subjects, search queries, file names).
-2.  **Seamless Integration:** The user's modification must be integrated perfectly into the original task's context, replacing or adding information as required.
-3.  **Clarity and Directness:** The final task should be a direct command, phrased as if it were the user's very first request.
-4.  **Strict Output Format:** Your output MUST BE ONLY the new synthesized task string. Do not include any preamble, explanation, or quotation marks.
-
----
-# EXAMPLES
-
-**EXAMPLE 1: Changing the application for an email task**
-
-**Original Task:**
-"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"
-
-**Modification Request:**
-"Please use my Outlook account for this instead of Gmail."
-
-**New Synthesized Task:**
-Send an email to manoj@agentr.dev with the subject 'Hello' and body 'This is a test of the Outlook agent.' from my Outlook account
-
----
-**EXAMPLE 2: Modifying the scope and source for a calendar task**
-
-**Original Task:**
-"Show me events from today's Google Calendar"
-
-**Modification Request:**
-"Actually, I need to see the whole week, not just today. And can you check my Microsoft 365 calendar?"
-
-**New Synthesized Task:**
-Show me events for the whole week from my Microsoft 365 calendar
-
----
-**EXAMPLE 3: Changing the target and tool for a web search task**
-
-**Original Task:**
-"Find the best restaurants in Goa using exa web search"
-
-**Modification Request:**
-"Could you look for hotels instead of restaurants, and please use Perplexity for it."
-
-**New Synthesized Task:**
-Find the best hotels in Goa using Perplexity.
-
----
-**EXAMPLE 4: Altering the final action of a multi-step task**
+1.  **Synthesize, Don't Just Add:** Do not simply append the modification request. You must seamlessly integrate the user's feedback into the agent's existing instructions, creating a new, coherent set of commands.
+2.  **Holistic Update:** The modification may require changes to not only the instructions but also the agent's name, description, and expertise. You must re-evaluate the entire profile.
+3.  **Prioritize New Information:** The user's latest modification request and any new conversation history are the primary drivers for the changes.
 
-**Original Task:**
-"search reddit for posts on elon musk and then post a meme on him on linkedin"
-
-**Modification Request:**
-"Let's not post anything. Just find the posts and then summarize the key points into a text file for me."
-
-**New Synthesized Task:**
-search reddit for posts on elon musk and then summarize the key points into a text file
-
----
-# YOUR TASK
+# INPUTS
+1.  **Existing Agent Instructions:** The original instructions that define the agent's current behavior.
+2.  **Modification Request:** The user's new input, specifying the desired changes.
+3.  **Conversation History (Optional):** A transcript of the conversation that may provide additional context for the modification.
 
-Now, perform this synthesis for the following inputs.
+# TASK
+Update the agent profile based on the user's feedback.
 
-**Original Task:**
-{original_task}
+**Existing Agent Instructions:**
+{existing_instructions}
 
 **Modification Request:**
 {modification_request}
 
-**New Synthesized Task:**
-"""
-
-AGENT_FROM_CONVERSATION_PROMPT = r"""
-# ROLE & GOAL
-You are a highly intelligent 'Agent Analyst' AI. Your sole purpose is to analyze a raw conversation transcript between a user and an AI assistant and a definitive list of tools the assistant used. From this data, you must synthesize a complete, reusable AI agent profile.
-
-# INPUTS
-1.  **Conversation History:** A transcript of the dialogue.
-2.  **Used Tools:** A definitive list of tool configurations (`{{app_id: [tool_names]}}`) that were successfully used to fulfill the user's requests in the conversation.
-
-# 1. Intent Breakdown
-- Clearly identify the primary goal the user wants the agent to achieve.
-- Recognize any special requirements, constraints, formatting requests, or interaction rules.
-- Summarize your understanding briefly to ensure alignment with user intent.
-
-# 2. Agent Profile Definition
-- **Name (2-4 words)**: Concise, clear, and memorable name reflecting core functionality.
-- **Description (1-2 sentences)**: Captures the unique value and primary benefit to users.
-- **Expertise**: Precise domain-specific expertise area. Avoid vague or overly general titles.
-- **Instructions**: Compose detailed, highly actionable system instructions that directly command the agent's behavior. Respond in markdown as this text will be rendered in a rich text editor. Write instructions as clear imperatives, without preamble, assuming the agent identity is already established externally.
-- **Schedule**: If the user specifies a schedule, you should also provide a cron expression for the agent to run on. The schedule should be in a proper cron expression and nothing more. Do not respond with any other information or explain your reasoning for the schedule, otherwise this will cause a parsing error that is undesirable.
-
-## ROLE & RESPONSIBILITY
-- Clearly state the agent's primary mission, e.g., "Your primary mission is...", "Your core responsibility is...".
-- Outline the exact tasks it handles, specifying expected input/output clearly.
-
-## INTERACTION STYLE
-- Define exactly how to communicate with users: tone, format, response structure.
-- Include explicit commands, e.g., "Always wrap responses in \`\`\`text\`\`\` blocks.", "Never add greetings or meta-information.", "Always provide outputs in user's requested languages."
-
-## OUTPUT FORMATTING RULES
-- Clearly specify formatting standards required by the user (e.g., JSON, plain text, markdown).
-- Include explicit examples to illustrate correct formatting.
-
-## LIMITATIONS & CONSTRAINTS
-- Explicitly define boundaries of the agent's capabilities.
-- Clearly state what the agent must never do or say.
-- Include exact phrases for declining requests outside scope.
-
-## REAL-WORLD EXAMPLES
-Provide two explicit interaction examples showing:
-- User's typical request.
-- Final agent response demonstrating perfect compliance.
-
-Create an agent that feels thoughtfully designed, intelligent, and professionally reliable, perfectly matched to the user's original intent.
-
-# YOUR TASK
-
-Now, perform this analysis for the following inputs.
-
-**INPUT - Conversation History:**
+**Conversation History:**
 {conversation_history}
 
-**INPUT - Used Tools:**
-{tool_config}
-
-**YOUR JSON OUTPUT:**
-"""
+**YOUR UPDATED JSON OUTPUT:**
+"""

universal_mcp/agents/builder/state.py

@@ -21,4 +21,4 @@ class BuilderState(TypedDict):
     user_task: str | None
     generated_agent: Agent | None
     tool_config: ToolConfig | None
-    messages: Annotated[Sequence[BaseMessage], add_messages]
+    messages: Annotated[Sequence[BaseMessage], add_messages]