universal-mcp-agents 0.1.18__tar.gz → 0.1.19rc1__tar.gz

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.18
+Version: 0.1.19rc1
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19rc1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-agents"
-version = "0.1.18"
+version = "0.1.19-rc1"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -70,7 +70,7 @@ lint.ignore = [
 
 [tool.ruff.lint.pylint]
 max-args = 10
-max-statements = 85
+max-statements = 118
 max-returns = 10
 max-branches = 37
 

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19rc1}/src/universal_mcp/agents/__init__.py

@@ -7,6 +7,7 @@ from universal_mcp.agents.codeact import CodeActAgent as CodeActScript
 from universal_mcp.agents.codeact0 import CodeActPlaybookAgent as CodeActRepl
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
+from universal_mcp.agents.unified import UnifiedAgent
 
 
 def get_agent(agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-script", "codeact-repl"]):
@@ -22,6 +23,8 @@ def get_agent(agent_name: Literal["react", "simple", "builder", "bigtool", "code
         return CodeActScript
     elif agent_name == "codeact-repl":
         return CodeActRepl
+    elif agent_name == "unified":
+        return UnifiedAgent
     else:
         raise ValueError(
             f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, bigtool, codeact-script, codeact-repl"

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19rc1}/src/universal_mcp/agents/codeact0/__main__.py

@@ -19,12 +19,6 @@ async def main():
         memory=memory,
     )
     print("Starting agent...")
-    # await agent.ainit()
-    # await agent.run_interactive()
-    # async for event in agent.stream(
-    #     user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
-    # ):
-    #     print(event.content, end="")
     result = await agent.invoke(
         user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
     )

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19rc1}/src/universal_mcp/agents/codeact0/llm_tool.py

@@ -27,7 +27,7 @@ def smart_print(data: Any) -> None:
     Args:
         data: Either a dictionary with string keys, or a list of such dictionaries
     """
-    print(light_copy(data))  # noqa
+    print(light_copy(data))  # noqa: T201
 
 
 def creative_writer(
@@ -275,105 +275,3 @@ def data_extractor(
         .invoke(prompt)
     )
     return cast(dict[str, Any], response)
-
-
-# news_articles_schema = {
-#     "type": "object",
-#     "properties": {
-#         "articles": {
-#             "type": "array",
-#             "title": "Articles",
-#             "description": "List of news articles",
-#             "items": {
-#                 "type": "object",
-#                 "properties": {
-#                     "headline": {
-#                         "type": "string",
-#                         "title": "Headline",
-#                         "description": "The headline of the news article"
-#                     },
-#                     "url": {
-#                         "type": "string",
-#                         "title": "URL",
-#                         "description": "The URL of the news article"
-#                     }
-#                 },
-#                 "required": ["headline", "url"],
-#             }
-#         }
-#     },
-#     "required": ["articles"],
-# }
-
-
-# news_articles_schema = {
-#   "title": "NewsArticleList",
-#   "description": "A list of news articles with headlines and URLs",
-#   "type": "object",
-#   "properties": {
-#     "articles": {
-#       "type": "array",
-#       "items": {
-#         "type": "object",
-#         "properties": {
-#           "headline": {
-#             "type": "string"
-#           },
-#           "url": {
-#             "type": "string"
-#           }
-#         },
-#         "required": ["headline", "url"]
-#       }
-#     }
-#   },
-#   "required": ["articles"]
-# }
-# model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
-# structured_model = model.with_structured_output(news_articles_schema)
-
-
-# class TwitterComment(BaseModel):
-#     skip: bool
-#     reason: str
-#     comment: str
-
-# twitter_comment_schema = {
-#   "title": "TwitterComment",
-#   "description": "A twitter comment to engage with followers",
-#   "type": "object",
-#   "properties": {
-#     "skip": {
-#       "type": "boolean"
-#     },
-#     "reason": {
-#       "type": "string"
-#     },
-#     "comment": {
-#       "type": "string"
-#     },
-#     "tagged_profiles": {
-#       "type": "array",
-#       "items": {
-#         "type": "string"
-#       }
-#     }
-#   },
-#   "required": ["skip", "reason"]
-# }
-
-# comment = {
-#     "tweet_id": "08109402",
-#     "handle": "@iamnishant",
-#     "text": "Hey really loved this tweet! Well said 💯"
-# }
-
-# comment_instructions = (
-#     "Goal is to engage with my twitter followers who have commented on my tweets."
-#     "Please generate a single line, context-aware, conversational reply for the given comment."
-#     "- Use social media language (can use hinglish)."
-#     "- Skip the reply, if the comment is too generic."
-#     "- Also tag relevant people in the reply."
-# )
-
-# my_reply = call_llm(comment_instructions, comment, twitter_comment_schema)

{universal_mcp_agents-0.1.18 → universal_mcp_agents-0.1.19rc1}/src/universal_mcp/agents/codeact0/playbook_agent.py

@@ -81,7 +81,7 @@ class CodeActPlaybookAgent(BaseAgent):
             memory=memory,
             **kwargs,
         )
-        self.model_instance = load_chat_model(model, thinking=True)
+        self.model_instance = load_chat_model(model)
         self.tools_config = tools or []
         self.registry = registry
         self.playbook_registry = playbook_registry

universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/sandbox.py

@@ -0,0 +1,90 @@
+import contextlib
+import inspect
+import io
+import queue
+import re
+import socket
+import threading
+import types
+from typing import Any
+
+from universal_mcp.agents.codeact0.utils import derive_context
+
+
+class Sandbox:
+    """
+    A class to execute code safely in a sandboxed environment with a timeout.
+    """
+
+    def __init__(self, timeout: int = 180):
+        """
+        Initializes the Sandbox.
+        Args:
+            timeout: The timeout for code execution in seconds.
+        """
+        self.timeout = timeout
+        self._locals: dict[str, Any] = {}
+        self.add_context: dict[str, Any] = {}
+
+    def run(self, code: str) -> tuple[str, dict[str, Any], dict[str, Any]]:
+        """
+        Execute code safely with a timeout.
+        - Returns (output_str, filtered_locals_dict, new_add_context)
+        - Errors or timeout are returned as output_str.
+        - Previous variables in _locals persist across calls.
+        """
+
+        EXCLUDE_TYPES = (
+            types.ModuleType,
+            type(re.match("", "")),
+            type(threading.Lock()),
+            type(threading.RLock()),
+            threading.Event,
+            threading.Condition,
+            threading.Semaphore,
+            queue.Queue,
+            socket.socket,
+            io.IOBase,
+        )
+
+        result_container = {"output": "<no output>"}
+
+        def target():
+            try:
+                with contextlib.redirect_stdout(io.StringIO()) as f:
+                    exec(code, self._locals, self._locals)
+                result_container["output"] = f.getvalue() or "<code ran, no output printed to stdout>"
+            except Exception as e:
+                result_container["output"] = "Error during execution: " + str(e)
+
+        thread = threading.Thread(target=target)
+        thread.start()
+        thread.join(self.timeout)
+
+        if thread.is_alive():
+            result_container["output"] = f"Code timeout: code execution exceeded {self.timeout} seconds."
+
+        # Filter locals for picklable/storable variables
+        all_vars = {}
+        for key, value in self._locals.items():
+            if key == "__builtins__":
+                continue
+            if inspect.iscoroutine(value) or inspect.iscoroutinefunction(value):
+                continue
+            if inspect.isasyncgen(value) or inspect.isasyncgenfunction(value):
+                continue
+            if isinstance(value, EXCLUDE_TYPES):
+                continue
+            if not callable(value) or not hasattr(value, "__name__"):
+                all_vars[key] = value
+
+        self._locals = all_vars
+
+        # Safely derive context
+        try:
+            self.add_context = derive_context(code, self.add_context)
+        except Exception:
+            # Keep the old context if derivation fails
+            pass
+
+        return result_container["output"], self._locals, self.add_context

universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified/README.md

@@ -0,0 +1,45 @@
+# Unified Agent
+
+The Unified Agent is a sophisticated AI assistant designed to understand and execute tasks by writing and running Python code. It operates within a secure sandbox environment and can leverage a variety of tools to interact with external systems and perform complex operations. A key feature of the Unified Agent is its ability to create reusable "playbooks" from user workflows, enabling automation of repeated tasks.
+
+## Architecture
+
+The agent's architecture is built upon the LangGraph library, creating a state machine that cycles between thinking (calling a language model) and acting (executing code or tools).
+
+### Core Components:
+
+*   **`UnifiedAgent`**: The fundamental agent implementation. It processes user requests, writes Python code, and executes it in a sandbox to achieve the desired outcome. It also has a "playbook mode" to generate reusable Python functions from a user's workflow.
+*   **State Graph (`CodeActState`)**: The agent's logic is defined as a state graph. The primary nodes are:
+    *   `call_model`: Invokes the language model to generate Python code or select a tool based on the current state and user input.
+    *   `sandbox`: Executes the generated Python code using a safe `eval` function with a timeout. The results and any errors are captured and fed back into the state.
+    *   `execute_tools`: Handles the execution of meta-tools for searching, loading, and interacting with external functions.
+    *   `playbook`: Manages the playbook creation process, including planning, user confirmation, and code generation.
+*   **Sandbox (`sandbox.py`)**: A secure execution environment that runs Python code in a separate thread with a timeout. It ensures that the agent's code execution is isolated and cannot harm the host system.
+*   **Tools**: The agent has access to a set of powerful tools:
+    *   `execute_ipython_cell`: The primary tool for executing arbitrary Python code snippets.
+    *   **AI Functions (`llm_tool.py`)**: A suite of functions (`generate_text`, `classify_data`, `extract_data`, `call_llm`) that allow the agent to delegate complex reasoning, classification, and data extraction tasks to a language model.
+    *   **Meta Tools (`tools.py`)**: Functions like `search_functions` and `load_functions` that enable the agent to dynamically discover and load new tools from a `ToolRegistry`.
+
+## Playbook Mode
+
+A key feature of the Unified Agent is its ability to create reusable "playbooks". When a user performs a task that they might want to repeat in the future, they can trigger the playbook mode. The agent will then:
+
+1.  **Plan:** Analyze the workflow and create a step-by-step plan for a reusable function, identifying user-specific variables that should become function parameters.
+2.  **Confirm:** Ask the user for confirmation of the generated plan.
+3.  **Generate:** Generate a Python function based on the confirmed plan. This function can be saved and executed later to automate the task.
+
+## Getting Started (`__main__.py`)
+
+The `__main__.py` file serves as a simple command-line interface for interacting with the agent. It demonstrates how to instantiate the `UnifiedAgent`, configure it with tools, and invoke it with a user request. This allows for easy testing and experimentation with the agent's capabilities.
+
+To run the agent, execute the following command from the root of the repository:
+```bash
+uv run python -m src.universal_mcp.agents.unified.__main__
+```
+
+Major TODO:
+- [] Improve LLM Tools
+    - [] Use smaller dedicated models for universal_write, clasify etc
+- Improve Sandbox
+    - [] Support saving loading context
+    - [] Direct async tool support

universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified/__init__.py

@@ -0,0 +1,3 @@
+from .agent import UnifiedAgent
+
+__all__ = ["UnifiedAgent"]

universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified/__main__.py

@@ -0,0 +1,28 @@
+import asyncio
+
+from langgraph.checkpoint.memory import MemorySaver
+from rich import print
+from universal_mcp.agentr.registry import AgentrRegistry
+
+from universal_mcp.agents.unified import UnifiedAgent
+from universal_mcp.agents.utils import messages_to_list
+
+
+async def main():
+    memory = MemorySaver()
+    default_tools = {"llm": ["generate_text", "classify_data", "extract_data", "call_llm"]}
+    agent = UnifiedAgent(
+        name="CodeAct Agent",
+        instructions="Be very concise in your answers.",
+        model="anthropic:claude-4-sonnet-20250514",
+        tools=default_tools,
+        registry=AgentrRegistry(),
+        memory=memory,
+    )
+    print("Starting agent...")
+    result = await agent.invoke(user_input="find the 80th fibonnaci number")
+    print(messages_to_list(result["messages"]))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified/agent.py

@@ -0,0 +1,289 @@
+import json
+import re
+from typing import Literal, cast
+
+from langchain_core.messages import AIMessage, ToolMessage
+from langchain_core.tools import StructuredTool
+from langchain_core.tools import tool as create_tool
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.graph import START, StateGraph
+from langgraph.types import Command, RetryPolicy
+from loguru import logger
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig, ToolFormat
+
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.agents.utils import convert_tool_ids_to_dict, filter_retry_on, get_message_text
+
+from .llm_tool import smart_print
+from .prompts import (
+    PLAYBOOK_CONFIRMING_PROMPT,
+    PLAYBOOK_GENERATING_PROMPT,
+    PLAYBOOK_PLANNING_PROMPT,
+    create_default_prompt,
+)
+from .sandbox import eval_unsafe
+from .state import CodeActState
+from .tools import create_meta_tools, enter_playbook_mode, get_valid_tools
+from .utils import inject_context, smart_truncate
+
+
+class UnifiedAgent(BaseAgent):
+    def __init__(
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        memory: BaseCheckpointSaver | None = None,
+        tools: ToolConfig | None = None,
+        registry: ToolRegistry | None = None,
+        playbook_registry: object | None = None,
+        sandbox_timeout: int = 20,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            instructions=instructions,
+            model=model,
+            memory=memory,
+            **kwargs,
+        )
+        self.model_instance = load_chat_model(model)
+        self.tools_config = tools or {}
+        self.registry = registry
+        self.playbook_registry = playbook_registry
+        self.sandbox_timeout = sandbox_timeout
+        self.eval_fn = eval_unsafe
+        if self.tools_config and not self.registry:
+            raise ValueError("Registry must be provided with tools")
+
+    async def _build_graph(self):  # noqa: PLR0915
+        meta_tools = create_meta_tools(self.registry)
+        additional_tools = [smart_print, meta_tools["web_search"]]
+        self.additional_tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in additional_tools]
+        self.default_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
+
+        async def call_model(state: CodeActState) -> Command[Literal["sandbox", "execute_tools"]]:
+            self.exported_tools = []
+
+            selected_tool_ids = state.get("selected_tool_ids", [])
+            self.exported_tools = await self.registry.export_tools(selected_tool_ids, ToolFormat.LANGCHAIN)
+            all_tools = self.exported_tools + self.additional_tools
+            self.final_instructions, self.tools_context = create_default_prompt(all_tools, self.instructions)
+            messages = [{"role": "user", "content": self.final_instructions}] + state["messages"]
+
+            if state.get("output"):
+                messages.append(
+                    {
+                        "role": "system",
+                        "content": f"The last code execution resulted in this output:\n{state['output']}",
+                    }
+                )
+
+            # Run the model and potentially loop for reflection
+            model_with_tools = self.model_instance.bind_tools(
+                tools=[
+                    enter_playbook_mode,
+                    meta_tools["search_functions"],
+                    meta_tools["load_functions"],
+                ],
+                tool_choice="auto",
+            )
+            response = cast(AIMessage, model_with_tools.invoke(messages))
+            response_text = get_message_text(response)
+            code_match = re.search(r"```python\n(.*?)\n```", response_text, re.DOTALL)
+
+            if code_match:
+                code = code_match.group(1).strip()
+                return Command(goto="sandbox", update={"messages": [response], "code": code, "output": ""})
+            elif response.tool_calls:
+                return Command(goto="execute_tools", update={"messages": [response]})
+            else:
+                return Command(update={"messages": [response]})
+
+        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "playbook", "sandbox"]]:
+            """Execute tool calls"""
+            last_message = state["messages"][-1]
+            tool_calls = last_message.tool_calls if isinstance(last_message, AIMessage) else []
+
+            tool_messages = []
+            new_tool_ids = []
+            ask_user = False
+            ai_msg = ""
+            tool_result = ""
+
+            for tool_call in tool_calls:
+                try:
+                    if tool_call["name"] == "enter_playbook_mode":
+                        tool_message = ToolMessage(
+                            content=json.dumps("Entered Playbook Mode."),
+                            name=tool_call["name"],
+                            tool_call_id=tool_call["id"],
+                        )
+                        return Command(
+                            goto="playbook",
+                            update={"playbook_mode": "planning", "messages": [tool_message]},  # Entered Playbook mode
+                        )
+                    elif tool_call["name"] == "load_functions":  # Handle load_functions separately
+                        valid_tools, unconnected_links = await get_valid_tools(
+                            tool_ids=tool_call["args"]["tool_ids"], registry=self.registry
+                        )
+                        new_tool_ids.extend(valid_tools)
+                        # Create tool message response
+                        tool_result = f"Successfully loaded {len(valid_tools)} tools: {valid_tools}"
+                        links = "\n".join(unconnected_links)
+                        if 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 {links} "
+                    elif tool_call["name"] == "search_functions":
+                        tool_result = await meta_tools["search_functions"].ainvoke(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="call_model", update={"messages": tool_messages, "selected_tool_ids": new_tool_ids})
+
+        def sandbox(state: CodeActState) -> Command[Literal["call_model"]]:
+            code = state.get("code")
+
+            if not code:
+                logger.error("Sandbox called without code")
+                return Command(
+                    goto="call_model",
+                    update={"output": "Sandbox was called without any code to execute."},
+                )
+
+            previous_add_context = state.get("add_context", {})
+            add_context = inject_context(previous_add_context, self.tools_context)
+            existing_context = state.get("context", {})
+            context = {**existing_context, **add_context}
+            # Execute the script in the sandbox
+
+            output, new_context, new_add_context = self.eval_fn(
+                code, context, previous_add_context, 180
+            )  # default timeout 3 min
+            output = smart_truncate(output)
+
+            return Command(
+                goto="call_model",
+                update={
+                    "output": output,
+                    "code": "",
+                    "context": new_context,
+                    "add_context": new_add_context,
+                },
+            )
+
+        def playbook(state: CodeActState) -> Command[Literal["call_model"]]:
+            playbook_mode = state.get("playbook_mode")
+            if playbook_mode == "planning":
+                planning_instructions = self.instructions + PLAYBOOK_PLANNING_PROMPT
+                messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
+
+                response = self.model_instance.invoke(messages)
+                response = cast(AIMessage, response)
+                response_text = get_message_text(response)
+                # Extract plan from response text between triple backticks
+                plan_match = re.search(r"```(.*?)```", response_text, re.DOTALL)
+                if plan_match:
+                    plan = plan_match.group(1).strip()
+                else:
+                    plan = response_text.strip()
+                return Command(update={"messages": [response], "playbook_mode": "confirming", "plan": plan})
+
+            elif playbook_mode == "confirming":
+                confirmation_instructions = self.instructions + PLAYBOOK_CONFIRMING_PROMPT
+                messages = [{"role": "system", "content": confirmation_instructions}] + state["messages"]
+                response = self.model_instance.invoke(messages, stream=False)
+                response = get_message_text(response)
+                if "true" in response.lower():
+                    return Command(goto="playbook", update={"playbook_mode": "generating"})
+                else:
+                    return Command(goto="playbook", update={"playbook_mode": "planning"})
+
+            elif playbook_mode == "generating":
+                generating_instructions = self.instructions + PLAYBOOK_GENERATING_PROMPT
+                messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
+                response = cast(AIMessage, self.model_instance.invoke(messages))
+                raw_content = get_message_text(response)
+                func_code = raw_content.strip()
+                func_code = func_code.replace("```python", "").replace("```", "")
+                func_code = func_code.strip()
+
+                # Extract function name (handle both regular and async functions)
+                match = re.search(r"^\s*(?:async\s+)?def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", func_code, re.MULTILINE)
+                if match:
+                    function_name = match.group(1)
+                else:
+                    function_name = "generated_playbook"
+
+                # Save or update an Agent using the helper registry
+                saved_note = ""
+                try:
+                    if not self.playbook_registry:
+                        raise ValueError("Playbook registry is not configured")
+
+                    # Build instructions payload embedding the plan and function code
+                    instructions_payload = {
+                        "playbookPlan": state["plan"],
+                        "playbookScript": {
+                            "name": function_name,
+                            "code": func_code,
+                        },
+                    }
+
+                    # Convert tool ids list to dict
+                    tool_dict = convert_tool_ids_to_dict(state["selected_tool_ids"])
+
+                    res = self.playbook_registry.create_agent(
+                        name=function_name,
+                        description=f"Generated playbook: {function_name}",
+                        instructions=instructions_payload,
+                        tools=tool_dict,
+                        visibility="private",
+                    )
+                    saved_note = f"Successfully created your playbook! Check it out here: [View Playbook](https://wingmen.info/agents/{res.id})"
+                except Exception as e:
+                    saved_note = f"Failed to save generated playbook as Agent '{function_name}': {e}"
+
+                # Mock tool call for exit_playbook_mode (for testing/demonstration)
+                mock_exit_tool_call = {"name": "exit_playbook_mode", "args": {}, "id": "mock_exit_playbook_123"}
+                mock_assistant_message = AIMessage(content=saved_note, tool_calls=[mock_exit_tool_call])
+
+                # Mock tool response for exit_playbook_mode
+                mock_exit_tool_response = ToolMessage(
+                    content=json.dumps(f"Exited Playbook Mode.{saved_note}"),
+                    name="exit_playbook_mode",
+                    tool_call_id="mock_exit_playbook_123",
+                )
+
+                return Command(
+                    update={"messages": [mock_assistant_message, mock_exit_tool_response], "playbook_mode": "normal"}
+                )
+
+        def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
+            """Route to either normal mode or playbook creation"""
+            if state.get("playbook_mode") in ["planning", "confirming", "generating"]:
+                return "playbook"
+
+            return "call_model"
+
+        agent = StateGraph(state_schema=CodeActState)
+        agent.add_node(call_model, retry_policy=RetryPolicy(max_attempts=3, retry_on=filter_retry_on))
+        agent.add_node(sandbox)
+        agent.add_node(playbook)
+        agent.add_node(execute_tools)
+        agent.add_conditional_edges(START, route_entry)
+        # agent.add_edge(START, "call_model")
+        return agent.compile(checkpointer=self.memory)

universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified/langgraph_agent.py

@@ -0,0 +1,14 @@
+from universal_mcp.agentr.registry import AgentrRegistry
+
+from universal_mcp.agents.unified import UnifiedAgent
+
+
+async def agent():
+    agent_obj = UnifiedAgent(
+        name="CodeAct Agent",
+        instructions="Be very concise in your answers.",
+        model="anthropic:claude-4-sonnet-20250514",
+        tools=[],
+        registry=AgentrRegistry(),
+    )
+    return await agent_obj._build_graph()