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

universal_mcp/agents/__init__.py

@@ -1,31 +1,30 @@
+from typing import Literal
+
 from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.bigtool2 import BigToolAgent2
-from universal_mcp.agents.bigtoolcache import BigToolAgentCache
-from universal_mcp.agents.builder import BuilderAgent
-from universal_mcp.agents.codeact import CodeActAgent
-from universal_mcp.agents.planner import PlannerAgent
+from universal_mcp.agents.bigtool import BigToolAgent
+from universal_mcp.agents.builder.builder import BuilderAgent
+from universal_mcp.agents.codeact0 import CodeActAgent as CodeActRepl
+from universal_mcp.agents.codeact import CodeActAgent as CodeActScript
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
 
 
-def get_agent(agent_name: str):
+def get_agent(agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-script", "codeact-repl"]):
     if agent_name == "react":
         return ReactAgent
     elif agent_name == "simple":
         return SimpleAgent
     elif agent_name == "builder":
         return BuilderAgent
-    elif agent_name == "planner":
-        return PlannerAgent
-    elif agent_name == "bigtool2":
-        return BigToolAgent2
-    elif agent_name == "bigtoolcache":
-        return BigToolAgentCache
-    elif agent_name == "codeact":
-        return CodeActAgent
+    elif agent_name == "bigtool":
+        return BigToolAgent
+    elif agent_name == "codeact-script":
+        return CodeActScript
+    elif agent_name == "codeact-repl":
+        return CodeActRepl
     else:
         raise ValueError(
-            f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, planner, bigtoolcache, bigtool2, codeact"
+            f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, bigtool, codeact-script, codeact-repl"
         )
 
 
@@ -33,9 +32,8 @@ __all__ = [
     "BaseAgent",
     "ReactAgent",
     "SimpleAgent",
-    "AutoAgent",
-    "BigToolAgent",
-    "PlannerAgent",
     "BuilderAgent",
-    "BigToolAgent2",
+    "BigToolAgent",
+    "CodeActScript",
+    "CodeActRepl",
 ]

universal_mcp/agents/base.py

@@ -2,7 +2,7 @@
 from typing import cast
 from uuid import uuid4
 
-from langchain_core.messages import AIMessage, AIMessageChunk
+from langchain_core.messages import AIMessageChunk
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import StateGraph
 from langgraph.types import Command
@@ -90,7 +90,7 @@ class BaseAgent:
     async def stream_interactive(self, thread_id: str, user_input: str):
         await self.ainit()
         with self.cli.display_agent_response_streaming(self.name) as stream_updater:
-            async for event in self.stream(thread_id, user_input):
+            async for event in self.stream(thread_id=thread_id, user_input=user_input):
                 if isinstance(event.content, list):
                     thinking_content = "".join([c.get("thinking", "") for c in event.content])
                     stream_updater.update(thinking_content, type_="thinking")
@@ -112,6 +112,7 @@ class BaseAgent:
             run_metadata.update(metadata)
 
         run_config = {
+            "recursion_limit": 25,
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
         }
@@ -123,6 +124,11 @@ class BaseAgent:
         )
         return result
 
+    async def get_state(self, thread_id: str):
+        await self.ainit()
+        state = await self._graph.aget_state(config={"configurable": {"thread_id": thread_id}})
+        return state
+
     async def run_interactive(self, thread_id: str = str(uuid4())):
         """Main application loop"""
 
@@ -133,7 +139,7 @@ class BaseAgent:
         # Main loop
         while True:
             try:
-                state = self._graph.get_state(config={"configurable": {"thread_id": thread_id}})
+                state = await self.get_state(thread_id=thread_id)
                 if state.interrupts:
                     value = self.cli.handle_interrupt(state.interrupts[0])
                     self._graph.invoke(
@@ -168,14 +174,11 @@ class BaseAgent:
                         continue
 
                 # Process with agent
-                await self.stream_interactive(thread_id, user_input)
+                await self.stream_interactive(thread_id=thread_id, user_input=user_input)
 
             except KeyboardInterrupt:
                 self.cli.display_info("\nGoodbye! 👋")
                 break
             except Exception as e:
-                import traceback
-
-                traceback.print_exc()
                 self.cli.display_error(f"An error occurred: {str(e)}")
                 break

universal_mcp/agents/{bigtoolcache → bigtool}/__init__.py

@@ -13,7 +13,7 @@ from .prompts import SYSTEM_PROMPT
 from .tools import create_meta_tools
 
 
-class BigToolAgentCache(BaseAgent):
+class BigToolAgent(BaseAgent):
     def __init__(
         self,
         registry: ToolRegistry,
@@ -63,4 +63,4 @@ class BigToolAgentCache(BaseAgent):
         return self._graph
 
 
-__all__ = ["BigToolAgentCache"]
+__all__ = ["BigToolAgent"]

universal_mcp/agents/{bigtoolcache → bigtool}/__main__.py

@@ -2,7 +2,6 @@ import asyncio
 
 from loguru import logger
 from universal_mcp.agentr.registry import AgentrRegistry
-
 from universal_mcp.agents.bigtoolcache import BigToolAgentCache
 
 

universal_mcp/agents/{bigtoolcache → bigtool}/agent.py

@@ -1,5 +1,4 @@
 from universal_mcp.agentr.registry import AgentrRegistry
-
 from universal_mcp.agents.bigtoolcache import BigToolAgentCache
 
 

universal_mcp/agents/{bigtoolcache → bigtool}/graph.py

@@ -8,7 +8,6 @@ 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 loguru import logger
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolFormat
 
@@ -35,7 +34,11 @@ def build_graph(
             current_tools = await registry.export_tools(tools=state["selected_tool_ids"], format=ToolFormat.LANGCHAIN)
         else:
             current_tools = []
-        all_tools = [meta_tools["search_tools"], meta_tools["load_tools"], meta_tools.get("web_search")] + default_tools + current_tools
+        all_tools = (
+            [meta_tools["search_tools"], meta_tools["load_tools"], meta_tools.get("web_search")]
+            + default_tools
+            + current_tools
+        )
 
         # Remove duplicates based on tool name
         seen_names = set()
@@ -81,7 +84,7 @@ def build_graph(
                 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}"
+                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":
@@ -99,8 +102,6 @@ def build_graph(
 
         return Command(goto="agent", update={"messages": tool_messages, "selected_tool_ids": new_tool_ids})
 
-
-
     # Define the graph
     workflow = StateGraph(State)
 

universal_mcp/agents/builder/__main__.py

@@ -0,0 +1,125 @@
+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.agents.builder.builder import BuilderAgent
+
+
+async def run_interactive_build():
+    """Simulates a multi-turn conversation to build and then modify an agent."""
+    logger.info("--- SCENARIO 1: INTERACTIVE AGENT BUILD & MODIFY ---")
+
+    registry = AgentrRegistry()
+    memory = MemorySaver()
+    agent = BuilderAgent(
+        name="Builder Agent",
+        instructions="You are a builder agent that creates other agents.",
+        model="anthropic/claude-4-sonnet-20250514",
+        registry=registry,
+        memory=memory,
+    )
+
+    thread_id = str(uuid4())
+
+    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",
+    ]
+
+    final_result = {}
+    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
+
+        generated_agent = final_result.get("generated_agent")
+        tool_config = final_result.get("tool_config")
+
+        if generated_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}")
+
+        if tool_config:
+            logger.info("--- Selected Tools ---")
+            tools_str = "\n".join(f"- {app}: {', '.join(tool_ids)}" for app, tool_ids in tool_config.items())
+            logger.info(tools_str)
+        else:
+            logger.info("--- Selected Tools ---")
+            logger.info("No tools selected for this agent yet.")
+
+
+async def run_conversation_build():
+    """Simulates a one-shot agent build from a conversation history payload."""
+    logger.info("\n\n--- SCENARIO 2: AGENT BUILD FROM CONVERSATION HISTORY ---")
+
+    registry = AgentrRegistry()
+    agent = BuilderAgent(
+        name="Builder Agent",
+        instructions="You build agents from conversation transcripts.",
+        model="anthropic/claude-4-sonnet-20250514",
+        registry=registry,
+    )
+
+    sample_conversation_history = [
+        {
+            "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": "ai",
+            "content": "Of course. The last 3 pull requests are: #101 'Fix login bug', #102 'Update documentation', and #103 'Add new chart component'.",
+        },
+        {
+            "type": "human",
+            "content": "Awesome, thanks. Now can you draft a new Google Doc and put that list in there for me?",
+        },
+        {"type": "ai", "content": "Done. I have created a new Google Doc with the list of the last 3 pull requests."},
+    ]
+    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)
+
+    generated_agent = result.get("generated_agent")
+    tool_config = result.get("tool_config")
+
+    if generated_agent:
+        logger.info("\n--- Generated Agent Profile ---")
+        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"Schedule: {generated_agent.schedule}")
+    else:
+        logger.error("Error: Agent profile was not generated.")
+
+    if tool_config:
+        logger.info("--- Final Tool Configuration ---")
+        tools_str = "\n".join(f"- {app}: {', '.join(tool_ids)}" for app, tool_ids in tool_config.items())
+        logger.info(tools_str)
+    else:
+        logger.error("Error: Tool configuration is missing.")
+
+
+async def main():
+    await run_interactive_build()
+    await run_conversation_build()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp/agents/builder/builder.py

@@ -0,0 +1,225 @@
+import json
+from collections import defaultdict
+
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import AIMessage, 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 universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.builder.prompts import (
+    AGENT_BUILDER_INSTRUCTIONS,
+    AGENT_FROM_CONVERSATION_PROMPT,
+    TASK_SYNTHESIS_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
+
+
+class BuilderAgent(BaseAgent):
+    def __init__(
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        registry: ToolRegistry,
+        memory: BaseCheckpointSaver | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            instructions=instructions,
+            model=model,
+            memory=memory,
+            **kwargs,
+        )
+        self.registry = registry
+        self.llm: BaseChatModel = load_chat_model(model, thinking=False)
+
+    def _entry_point_router(self, state: BuilderState):
+        """
+        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.
+        """
+        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")
+
+        generated_agent = await generate_agent(self.llm, task, agent)
+        yield {
+            "generated_agent": generated_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 {}
+
+        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,
+        }
+
+    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,
+        }
+
+    async def _synthesize_from_conversation(self, state: BuilderState):
+        """
+        Takes conversation history and used tools from input to synthesize a complete agent profile.
+        This is a one-shot generation.
+        """
+        content_str = state["messages"][-1].content
+        initial_input = json.loads(content_str)
+
+        conversation_history = initial_input.get("conversation_history")
+        tool_config = initial_input.get("tool_config")
+
+        if not conversation_history or not tool_config:
+            raise ValueError("Input must be a dictionary containing 'conversation_history' and 'tool_config'.")
+
+        prompt = AGENT_FROM_CONVERSATION_PROMPT.format(
+            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."
+                )
+            ],
+        }
+
+    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)
+
+        # 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)