universal-mcp-agents 0.1.19rc1__tar.gz → 0.1.20rc1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.19rc1
+Version: 0.1.20rc1
 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.19rc1 → universal_mcp_agents-0.1.20rc1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-agents"
-version = "0.1.19-rc1"
+version = "0.1.20-rc1"
 description = "Add your description here"
 readme = "README.md"
 authors = [

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

@@ -3,14 +3,14 @@ from typing import Literal
 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 CodeActPlaybookAgent as CodeActRepl
+from universal_mcp.agents.codeact0 import CodeActPlaybookAgent
 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"]):
+def get_agent(
+    agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-script", "codeact-repl"],
+):
     if agent_name == "react":
         return ReactAgent
     elif agent_name == "simple":
@@ -19,12 +19,8 @@ def get_agent(agent_name: Literal["react", "simple", "builder", "bigtool", "code
         return BuilderAgent
     elif agent_name == "bigtool":
         return BigToolAgent
-    elif agent_name == "codeact-script":
-        return CodeActScript
     elif agent_name == "codeact-repl":
-        return CodeActRepl
-    elif agent_name == "unified":
-        return UnifiedAgent
+        return CodeActPlaybookAgent
     else:
         raise ValueError(
             f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, bigtool, codeact-script, codeact-repl"

{universal_mcp_agents-0.1.19rc1 → universal_mcp_agents-0.1.20rc1}/src/universal_mcp/agents/base.py

@@ -49,8 +49,11 @@ class BaseAgent:
             run_metadata.update(metadata)
 
         run_config = {
+            "recursion_limit": 50,
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
+            "run_id": thread_id,
+            "run_name": self.name,
         }
 
         async for event, meta in self._graph.astream(
@@ -113,7 +116,7 @@ class BaseAgent:
             run_metadata.update(metadata)
 
         run_config = {
-            "recursion_limit": 25,
+            "recursion_limit": 50,
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
             "run_id": thread_id,

{universal_mcp_agents-0.1.19rc1 → universal_mcp_agents-0.1.20rc1}/src/universal_mcp/agents/cli.py

@@ -28,9 +28,6 @@ def run(name: str = "react"):
         "model": "anthropic/claude-sonnet-4-20250514",
         "registry": AgentrRegistry(client=client),
         "memory": MemorySaver(),
-        "tools": {
-            "google_mail": ["send_email"],
-        },
     }
     agent_cls = get_agent(name)
     agent = agent_cls(name=name, **params)

universal_mcp_agents-0.1.20rc1/src/universal_mcp/agents/codeact0/__init__.py

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

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

@@ -4,13 +4,13 @@ from langgraph.checkpoint.memory import MemorySaver
 from rich import print
 from universal_mcp.agentr.registry import AgentrRegistry
 
-from universal_mcp.agents.codeact0.agent import CodeActAgent
+from universal_mcp.agents.codeact0.agent import CodeActPlaybookAgent
 from universal_mcp.agents.utils import messages_to_list
 
 
 async def main():
     memory = MemorySaver()
-    agent = CodeActAgent(
+    agent = CodeActPlaybookAgent(
         name="CodeAct Agent",
         instructions="Be very concise in your answers.",
         model="anthropic:claude-4-sonnet-20250514",

{universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified → universal_mcp_agents-0.1.20rc1/src/universal_mcp/agents/codeact0}/agent.py

@@ -1,35 +1,36 @@
 import json
 import re
+from collections.abc import Callable
 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 (
+from universal_mcp.agents.codeact0.llm_tool import ai_classify, call_llm, data_extractor, smart_print
+from universal_mcp.agents.codeact0.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
+from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
+from universal_mcp.agents.codeact0.state import CodeActState
+from universal_mcp.agents.codeact0.tools import (
+    create_meta_tools,
+    enter_playbook_mode,
+    get_valid_tools,
+)
+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
 
 
-class UnifiedAgent(BaseAgent):
+class CodeActPlaybookAgent(BaseAgent):
     def __init__(
         self,
         name: str,
@@ -50,40 +51,35 @@ class UnifiedAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.tools_config = tools or {}
+        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")
+        self.sandbox_timeout = sandbox_timeout
+        self.processed_tools: list[StructuredTool | Callable] = []
 
-    async def _build_graph(self):  # noqa: PLR0915
+    async def _build_graph(self):
         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']}",
-                    }
-                )
+        additional_tools = [smart_print, data_extractor, ai_classify, call_llm, meta_tools["web_search"]]
+        self.additional_tools = [
+            t if isinstance(t, StructuredTool) else StructuredTool.from_function(t) for t in additional_tools
+        ]
+        if self.tools_config:
+            # Convert dict format to list format if needed
+            if isinstance(self.tools_config, dict):
+                self.tools_config = [
+                    f"{provider}__{tool}" for provider, tools in self.tools_config.items() for tool in tools
+                ]
+            if not self.registry:
+                raise ValueError("Tools are configured but no registry is provided")
+
+        async def call_model(state: CodeActState) -> Command[Literal["execute_tools"]]:
+            messages = [{"role": "system", "content": self.final_instructions}] + state["messages"]
 
             # Run the model and potentially loop for reflection
             model_with_tools = self.model_instance.bind_tools(
                 tools=[
+                    execute_ipython_cell,
                     enter_playbook_mode,
                     meta_tools["search_functions"],
                     meta_tools["load_functions"],
@@ -91,18 +87,12 @@ class UnifiedAgent(BaseAgent):
                 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:
+            if response.tool_calls:
                 return Command(goto="execute_tools", update={"messages": [response]})
             else:
-                return Command(update={"messages": [response]})
+                return Command(update={"messages": [response], "model_with_tools": model_with_tools})
 
-        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "playbook", "sandbox"]]:
+        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "playbook"]]:
             """Execute tool calls"""
             last_message = state["messages"][-1]
             tool_calls = last_message.tool_calls if isinstance(last_message, AIMessage) else []
@@ -112,6 +102,8 @@ class UnifiedAgent(BaseAgent):
             ask_user = False
             ai_msg = ""
             tool_result = ""
+            effective_previous_add_context = state.get("add_context", {})
+            effective_existing_context = state.get("context", {})
 
             for tool_call in tool_calls:
                 try:
@@ -125,6 +117,18 @@ class UnifiedAgent(BaseAgent):
                             goto="playbook",
                             update={"playbook_mode": "planning", "messages": [tool_message]},  # Entered Playbook mode
                         )
+                    elif tool_call["name"] == "execute_ipython_cell":
+                        code = tool_call["args"]["snippet"]
+                        output, new_context, new_add_context = await handle_execute_ipython_cell(
+                            code,
+                            self.tools_context,
+                            self.eval_fn,
+                            effective_previous_add_context,
+                            effective_existing_context,
+                        )
+                        effective_existing_context = new_context
+                        effective_previous_add_context = new_add_context
+                        tool_result = output
                     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
@@ -138,8 +142,13 @@ class UnifiedAgent(BaseAgent):
                             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"])
+                    else:
+                        raise Exception(
+                            f"Unexpected tool call: {tool_call['name']}. "
+                            "tool calls must be one of 'enter_playbook_mode', 'execute_ipython_cell', 'load_functions', or 'search_functions'"
+                        )
                 except Exception as e:
-                    tool_result = f"Error during {tool_call}: {e}"
+                    tool_result = str(e)
 
                 tool_message = ToolMessage(
                     content=json.dumps(tool_result),
@@ -148,40 +157,30 @@ class UnifiedAgent(BaseAgent):
                 )
                 tool_messages.append(tool_message)
 
+            if new_tool_ids:
+                self.tools_config.extend(new_tool_ids)
+                self.exported_tools = await self.registry.export_tools(new_tool_ids, ToolFormat.LANGCHAIN)
+                self.final_instructions, self.tools_context = create_default_prompt(
+                    self.exported_tools, self.additional_tools, self.instructions
+                )
             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."},
+                    update={
+                        "messages": tool_messages,
+                        "selected_tool_ids": new_tool_ids,
+                        "context": effective_existing_context,
+                        "add_context": effective_previous_add_context,
+                    }
                 )
 
-            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,
+                    "messages": tool_messages,
+                    "selected_tool_ids": new_tool_ids,
+                    "context": effective_existing_context,
+                    "add_context": effective_previous_add_context,
                 },
             )
 
@@ -272,16 +271,20 @@ class UnifiedAgent(BaseAgent):
                     update={"messages": [mock_assistant_message, mock_exit_tool_response], "playbook_mode": "normal"}
                 )
 
-        def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
+        async def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
             """Route to either normal mode or playbook creation"""
+            self.exported_tools = []
+            self.tools_config.extend(state.get("selected_tool_ids", []))
+            self.exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
+            self.final_instructions, self.tools_context = create_default_prompt(
+                self.exported_tools, self.additional_tools, self.instructions
+            )
             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)

{universal_mcp_agents-0.1.19rc1 → universal_mcp_agents-0.1.20rc1}/src/universal_mcp/agents/codeact0/langgraph_agent.py

@@ -1,6 +1,6 @@
 from universal_mcp.agentr.registry import AgentrRegistry
 
-from universal_mcp.agents.codeact0.playbook_agent import CodeActPlaybookAgent
+from universal_mcp.agents.codeact0 import CodeActPlaybookAgent
 
 
 async def agent():

{universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified → universal_mcp_agents-0.1.20rc1/src/universal_mcp/agents/codeact0}/prompts.py

@@ -4,24 +4,29 @@ from collections.abc import Sequence
 
 from langchain_core.tools import StructuredTool
 
+from universal_mcp.agents.codeact0.utils import schema_to_signature
+
 uneditable_prompt = """
 You are **Wingmen**, an AI Assistant created by AgentR — a creative, straight-forward, and direct principal software engineer with access to tools.
 
 Your job is to answer the user's question or perform the task they ask for.
-- Answer simple questions (which do not require you to write any code or access any external resources) directly. Note that any operation that involves using ONLY print functions should be answered directly.
-- For tasks requiring operations or access to external resources, you should achieve the task by writing Python code snippets inside markdown blocks (e.g., ```python ... ```).
-- You also have access to two tools for finding and loading more python functions- `search_functions` and `load_functions`, which you must use for finding functions for using different external applications. Prefer pre-loaded or functions already available when possible, and prioritize connected applications over unconnected ones. When this is not enough to break a tie between similar applications, ask the user.
-- In writing or natural language processing tasks DO NOT answer directly. Instead write python code using the AI functions provided to you for tasks like summarizing, text generation, classification, data extraction from text or unstructured data, etc. Avoid hardcoded approaches to classification, data extraction.
+- Answer simple questions (which do not require you to write any code or access any external resources) directly. Note that any operation that involves using ONLY print functions should be answered directly in the chat. NEVER write a string yourself and print it.
+- For task requiring operations or access to external resources, you should achieve the task by executing Python code snippets.
+- You have access to `execute_ipython_cell` tool that allows you to execute Python code in an IPython notebook cell.
+- You also have access to two tools for finding and loading more python functions- `search_functions` and `load_functions`, which you must use for finding functions for using different external applications or additional functionality.
+    - Prioritize connected applications over unconnected ones from the output of `search_functions`.
+    - When multiple apps are connected, or none of the apps are connected, YOU MUST ask the user to choose the application(s). The search results will inform you when such a case occurs, and you must stop and ask the user if multiple apps are relevant.
+- In writing or natural language processing tasks DO NOT answer directly. Instead use `execute_ipython_cell` tool with the AI functions provided to you for tasks like summarizing, text generation, classification, data extraction from text or unstructured data, etc. Avoid hardcoded approaches to classification, data extraction, or creative writing.
 - The code you write will be executed in a sandbox environment, and you can use the output of previous executions in your code. variables, functions, imports are retained.
-- Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is NOT visible to the user, so after the task is complete, you have to give the output to the user in a markdown format.
-- If needed, feel free to ask for more information from the user to clarify the task.
+- Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is NOT visible to the user, so after the task is complete, you have to give the output to the user in a markdown format. Similarly, you should only use print/smart_print for your own analysis, the user does not get the output.
+- If needed, feel free to ask for more information from the user (without using the `execute_ipython_cell` tool) to clarify the task.
 
 GUIDELINES for writing code:
 - Variables defined at the top level of previous code snippets can be referenced in your code.
 - External functions which return a dict or list[dict] are ambiguous. Therefore, you MUST explore the structure of the returned data using `smart_print()` statements before using it, printing keys and values. `smart_print` truncates long strings from data, preventing huge output logs.
 - When an operation involves running a fixed set of steps on a list of items, run one run correctly and then use a for loop to run the steps on each item in the list.
 - In a single code snippet, try to achieve as much as possible.
-- You can only import libraries that come pre-installed with Python. For external functions, use the search and load tools to access them in the code.
+- You can only import libraries that come pre-installed with Python. However, do consider searching for external functions first, using the search and load tools to access them in the code.
 - For displaying final results to the user, you must present your output in markdown format, including image links, so that they are rendered and displayed to the user. The code output is NOT visible to the user.
 - Call all functions using keyword arguments only, never positional arguments.
 - Async Functions (Critical): Use them only as follows-
@@ -40,6 +45,37 @@ Rules:
 - Never nest asyncio.run() calls
 """
 
+PLAYBOOK_PLANNING_PROMPT = """Now, you are tasked with creating a reusable playbook from the user's previous workflow.
+
+TASK: Analyze the conversation history and code execution to create a step-by-step plan for a reusable function. Do not include the searching and loading of tools. Assume that the tools have already been loaded.
+
+Your plan should:
+1. Identify the key steps in the workflow
+2. Mark user-specific variables that should become the main playbook function parameters using `variable_name` syntax. Intermediate variables should not be highlighted using ``
+3. Keep the logic generic and reusable
+4. Be clear and concise
+
+Example:
+```
+1. Connect to database using `db_connection_string`
+2. Query user data for `user_id`
+3. Process results and calculate `metric_name`
+4. Send notification to `email_address`
+```
+
+Now create a plan based on the conversation history. Enclose it between ``` and ```. Ask the user if the plan is okay."""
+
+
+PLAYBOOK_CONFIRMING_PROMPT = """Now, you are tasked with confirming the playbook plan. Return True if the user is happy with the plan, False otherwise. Do not say anything else in your response. The user response will be the last message in the chain.
+"""
+
+PLAYBOOK_GENERATING_PROMPT = """Now, you are tasked with generating the playbook function. Return the function in Python code.
+Do not include any other text in your response.
+The function should be a single, complete piece of code that can be executed independently, based on previously executed code snippets that executed correctly.
+The parameters of the function should be the same as the final confirmed playbook plan.
+Do not include anything other than python code in your response
+"""
+
 
 def make_safe_function_name(name: str) -> str:
     """Convert a tool name to a valid Python function name."""
@@ -133,14 +169,28 @@ def indent(text, prefix, predicate=None):
 
 def create_default_prompt(
     tools: Sequence[StructuredTool],
+    additional_tools: Sequence[StructuredTool],
     base_prompt: str | None = None,
 ):
     system_prompt = uneditable_prompt.strip() + (
         "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
     )
     tools_context = {}
-
     for tool in tools:
+        if hasattr(tool, "func") and tool.func is not None:
+            tool_callable = tool.func
+            is_async = False
+        elif hasattr(tool, "coroutine") and tool.coroutine is not None:
+            tool_callable = tool.coroutine
+            is_async = True
+        system_prompt += f'''{"async " if is_async else ""}{schema_to_signature(tool.args, tool.name)}:
+    """{tool.description}"""
+    ...
+    '''
+        safe_name = make_safe_function_name(tool.name)
+        tools_context[safe_name] = tool_callable
+
+    for tool in additional_tools:
         if hasattr(tool, "func") and tool.func is not None:
             tool_callable = tool.func
             is_async = False
@@ -158,35 +208,3 @@ def create_default_prompt(
         system_prompt += f"Your goal is to perform the following task:\n\n{base_prompt}"
 
     return system_prompt, tools_context
-
-
-PLAYBOOK_PLANNING_PROMPT = """Now, you are tasked with creating a reusable playbook from the user's previous workflow.
-
-TASK: Analyze the conversation history and code execution to create a step-by-step plan for a reusable function. Do not include the searching and loading of tools. Assume that the tools have already been loaded.
-
-Your plan should:
-1. Identify the key steps in the workflow
-2. Mark user-specific variables that should become the main playbook function parameters using `variable_name` syntax. Intermediate variables should not be highlighted using ``
-3. Keep the logic generic and reusable
-4. Be clear and concise
-
-Example:
-```
-1. Connect to database using `db_connection_string`
-2. Query user data for `user_id`
-3. Process results and calculate `metric_name`
-4. Send notification to `email_address`
-```
-
-Now create a plan based on the conversation history. Enclose it between ``` and ```. Ask the user if the plan is okay."""
-
-
-PLAYBOOK_CONFIRMING_PROMPT = """Now, you are tasked with confirming the playbook plan. Return True if the user is happy with the plan, False otherwise. Do not say anything else in your response. The user response will be the last message in the chain.
-"""
-
-PLAYBOOK_GENERATING_PROMPT = """Now, you are tasked with generating the playbook function. Return the function in Python code.
-Do not include any other text in your response.
-The function should be a single, complete piece of code that can be executed independently, based on previously executed code snippets that executed correctly.
-The parameters of the function should be the same as the final confirmed playbook plan.
-Do not include anything other than python code in your response
-"""

{universal_mcp_agents-0.1.19rc1/src/universal_mcp/agents/unified → universal_mcp_agents-0.1.20rc1/src/universal_mcp/agents/codeact0}/sandbox.py

@@ -10,7 +10,7 @@ from typing import Any
 
 from langchain_core.tools import tool
 
-from universal_mcp.agents.codeact0.utils import derive_context
+from universal_mcp.agents.codeact0.utils import derive_context, inject_context, smart_truncate
 
 
 def eval_unsafe(
@@ -53,6 +53,14 @@ def eval_unsafe(
     if thread.is_alive():
         result_container["output"] = f"Code timeout: code execution exceeded {timeout} seconds."
 
+    # If NameError for provider__tool occurred, append guidance (no retry)
+    try:
+        m = re.search(r"NameError:\s*name\s*'([^']+)'\s*is\s*not\s*defined", result_container["output"])
+        if m and "__" in m.group(1):
+            result_container["output"] += "\nHint: If it is a valid tool, load it before running this snippet."
+    except Exception:
+        pass
+
     # Filter locals for picklable/storable variables
     all_vars = {}
     for key, value in _locals.items():
@@ -99,3 +107,25 @@ def execute_ipython_cell(snippet: str) -> str:
 
     # Your actual execution logic would go here
     return f"Successfully executed {len(snippet)} characters of Python code"
+
+
+async def handle_execute_ipython_cell(
+    code: str,
+    tools_context: dict[str, Any],
+    eval_fn,
+    effective_previous_add_context: dict[str, Any],
+    effective_existing_context: dict[str, Any],
+) -> tuple[str, dict[str, Any], dict[str, Any]]:
+    """
+    Execute a code cell with shared state, supporting both sync and async eval functions.
+
+    Returns (output, new_context, new_add_context).
+    """
+    add_context = inject_context(effective_previous_add_context, tools_context)
+    context = {**effective_existing_context, **add_context}
+    if inspect.iscoroutinefunction(eval_fn):
+        output, new_context, new_add_context = await eval_fn(code, context, effective_previous_add_context, 180)
+    else:
+        output, new_context, new_add_context = eval_fn(code, context, effective_previous_add_context, 180)
+    output = smart_truncate(output)
+    return output, new_context, new_add_context

{universal_mcp_agents-0.1.19rc1 → universal_mcp_agents-0.1.20rc1}/src/universal_mcp/agents/codeact0/state.py

@@ -6,6 +6,8 @@ from langgraph.prebuilt.chat_agent_executor import AgentState
 def _enqueue(left: list, right: list) -> list:
     """Treat left as a FIFO queue, append new items from right (preserve order),
     keep items unique, and cap total size to 20 (drop oldest items)."""
+
+    # Tool ifd are unique
     max_size = 30
     preferred_size = 20
     if len(right) > preferred_size:
@@ -20,7 +22,7 @@ def _enqueue(left: list, right: list) -> list:
     if len(queue) > preferred_size:
         queue = queue[-preferred_size:]
 
-    return queue
+    return list(set(queue))
 
 
 class CodeActState(AgentState):