universal-mcp-agents 0.1.23rc3__py3-none-any.whl → 0.1.23rc4__py3-none-any.whl

universal_mcp/agents/__init__.py

@@ -15,16 +15,10 @@ def get_agent(
         return ReactAgent
     elif agent_name == "simple":
         return SimpleAgent
-    elif agent_name == "builder":
-        return BuilderAgent
-    elif agent_name == "bigtool":
-        return BigToolAgent
     elif agent_name == "codeact-repl":
         return CodeActPlaybookAgent
     else:
-        raise ValueError(
-            f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, bigtool, codeact-repl"
-        )
+        raise ValueError(f"Unknown agent: {agent_name}. Possible values:  react, simple, codeact-repl")
 
 
 __all__ = [

universal_mcp/agents/base.py

@@ -64,7 +64,7 @@ class BaseAgent:
             stream_mode=["messages", "custom"],
             stream_usage=True,
         ):
-            if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:
+            if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:  # noqa: PLR2004
                 payload, meta_dict = meta
                 is_agent_builder = isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "agent_builder"
                 additional_kwargs = getattr(payload, "additional_kwargs", {}) or {}

universal_mcp/agents/bigtool/state.py

@@ -1,6 +1,6 @@
 from typing import Annotated
 
-from langgraph.prebuilt.chat_agent_executor import AgentState
+from langchain.agents import AgentState
 
 
 def _enqueue(left: list, right: list) -> list:

universal_mcp/agents/codeact0/__main__.py

@@ -18,7 +18,7 @@ async def main():
         memory=memory,
     )
     print("Starting agent...")
-    result = await agent.invoke(user_input="load all the tools of reddit which can be used to search subreddit")
+    result = await agent.invoke(user_input="Check my google calendar and show my todays agenda")
     print(messages_to_list(result["messages"]))
 
 

universal_mcp/agents/codeact0/agent.py

@@ -3,10 +3,10 @@ import json
 import re
 import uuid
 from typing import Literal, cast
+from types import SimpleNamespace
 
 from langchain_anthropic import ChatAnthropic
 from langchain_core.messages import AIMessage, ToolMessage
-from langchain_core.tools import StructuredTool
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import START, StateGraph
 from langgraph.types import Command, RetryPolicy, StreamWriter
@@ -22,13 +22,12 @@ from universal_mcp.agents.codeact0.prompts import (
     create_default_prompt,
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
-from universal_mcp.agents.codeact0.state import CodeActState, AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan
+from universal_mcp.agents.codeact0.state import AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan, CodeActState
 from universal_mcp.agents.codeact0.tools import (
     create_meta_tools,
     enter_agent_builder_mode,
-    get_valid_tools,
 )
-from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string
+from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string, create_agent_call
 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
 
@@ -57,6 +56,8 @@ class CodeActPlaybookAgent(BaseAgent):
         self.registry = registry
         self.agent_builder_registry = agent_builder_registry
         self.agent = agent_builder_registry.get_agent() if agent_builder_registry else None
+
+        
         self.tools_config = self.agent.tools if self.agent else {}
         self.eval_fn = eval_unsafe
         self.sandbox_timeout = sandbox_timeout
@@ -65,14 +66,11 @@ class CodeActPlaybookAgent(BaseAgent):
         }
         self.final_instructions = ""
         self.tools_context = {}
-        self.exported_tools = []
 
-    async def _build_graph(self):
+    async def _build_graph(self):  # noqa: PLR0915
+        """Build the graph for the CodeAct Playbook Agent."""
         meta_tools = create_meta_tools(self.registry)
-        additional_tools = [smart_print, meta_tools["web_search"]]
-        self.additional_tools = [
-            t if isinstance(t, StructuredTool) else StructuredTool.from_function(t) for t in additional_tools
-        ]
+        self.additional_tools = [smart_print, meta_tools["web_search"]]
 
         if self.tools_config:
             if isinstance(self.tools_config, dict):
@@ -81,9 +79,8 @@ class CodeActPlaybookAgent(BaseAgent):
                 ]
                 if not self.registry:
                     raise ValueError("Tools are configured but no registry is provided")
-            await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
-
-        await self.registry.export_tools(self.default_tools_config, ToolFormat.LANGCHAIN)
+            await self.registry.load_tools(self.tools_config)  # Load the default tools
+        await self.registry.load_tools(self.default_tools_config)  # Load more tools
 
         async def call_model(state: CodeActState) -> Command[Literal["execute_tools"]]:
             """This node now only ever binds the four meta-tools to the LLM."""
@@ -113,8 +110,7 @@ class CodeActPlaybookAgent(BaseAgent):
                     tools=agent_facing_tools,
                     tool_choice="auto",
                 )
-
-            response = cast(AIMessage, model_with_tools.invoke(messages))
+            response = cast(AIMessage, await model_with_tools.ainvoke(messages))
             if response.tool_calls:
                 return Command(goto="execute_tools", update={"messages": [response]})
             else:
@@ -146,7 +142,10 @@ class CodeActPlaybookAgent(BaseAgent):
                         )
                         return Command(
                             goto="agent_builder",
-                            update={"agent_builder_mode": "planning", "messages": [tool_message]},  # Entered Agent Builder mode
+                            update={
+                                "agent_builder_mode": "planning",
+                                "messages": [tool_message],
+                            },  # Entered Agent Builder mode
                         )
                     elif tool_name == "execute_ipython_cell":
                         code = tool_call["args"]["snippet"]
@@ -162,7 +161,9 @@ class CodeActPlaybookAgent(BaseAgent):
                         tool_result = output
                     elif tool_name == "load_functions":
                         # The tool now does all the work of validation and formatting.
-                        tool_result, new_context_for_sandbox, valid_tools, unconnected_links = await meta_tools["load_functions"].ainvoke(tool_args)
+                        tool_result, new_context_for_sandbox, valid_tools, unconnected_links = await meta_tools[
+                            "load_functions"
+                        ].ainvoke(tool_args)
                         # We still need to update the sandbox context for `execute_ipython_cell`
                         new_tool_ids.extend(valid_tools)
                         if new_tool_ids:
@@ -187,7 +188,7 @@ class CodeActPlaybookAgent(BaseAgent):
                     tool_call_id=tool_call["id"],
                 )
                 tool_messages.append(tool_message)
-            
+
             if ask_user:
                 tool_messages.append(AIMessage(content=ai_msg))
                 return Command(
@@ -209,7 +210,7 @@ class CodeActPlaybookAgent(BaseAgent):
                 },
             )
 
-        def agent_builder(state: CodeActState, writer: StreamWriter) -> Command[Literal["call_model"]]:
+        async def agent_builder(state: CodeActState, writer: StreamWriter) -> Command[Literal["call_model"]]:
             agent_builder_mode = state.get("agent_builder_mode")
             if agent_builder_mode == "planning":
                 plan_id = str(uuid.uuid4())
@@ -217,8 +218,10 @@ class CodeActPlaybookAgent(BaseAgent):
                 planning_instructions = self.instructions + AGENT_BUILDER_PLANNING_PROMPT
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
-                model_with_structured_output = self.agent_builder_model_instance.with_structured_output(AgentBuilderPlan)
-                response = model_with_structured_output.invoke(messages)
+                model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
+                    AgentBuilderPlan
+                )
+                response = await model_with_structured_output.ainvoke(messages)
                 plan = cast(AgentBuilderPlan, response)
 
                 writer({"type": "custom", id: plan_id, "name": "planning", "data": {"plan": plan.steps}})
@@ -277,8 +280,10 @@ class CodeActPlaybookAgent(BaseAgent):
                         meta_instructions = self.instructions + AGENT_BUILDER_META_PROMPT
                         messages = [{"role": "system", "content": meta_instructions}] + state["messages"]
 
-                        model_with_structured_output = self.agent_builder_model_instance.with_structured_output(AgentBuilderMeta)
-                        meta_response = model_with_structured_output.invoke(messages)
+                        model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
+                            AgentBuilderMeta
+                        )
+                        meta_response = await model_with_structured_output.ainvoke(messages)
                         meta = cast(AgentBuilderMeta, meta_response)
                         name, description = meta.name, meta.description
 
@@ -316,8 +321,10 @@ class CodeActPlaybookAgent(BaseAgent):
                 generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
 
-                model_with_structured_output = self.agent_builder_model_instance.with_structured_output(AgentBuilderCode)
-                response = model_with_structured_output.invoke(messages)
+                model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
+                    AgentBuilderCode
+                )
+                response = await model_with_structured_output.ainvoke(messages)
                 func_code = cast(AgentBuilderCode, response).code
 
                 # Extract function name (handle both regular and async functions)
@@ -367,23 +374,35 @@ class CodeActPlaybookAgent(BaseAgent):
                         },
                     }
                 )
+                mock_exit_tool_call = {
+                    "name": "exit_agent_builder_mode",
+                    "args": {},
+                    "id": "exit_builder_1"
+                }
                 mock_assistant_message = AIMessage(
                     content=json.dumps(response.model_dump()),
+                    tool_calls=[mock_exit_tool_call],
                     additional_kwargs={
                         "type": "generating",
                         "id": str(res.id),
                         "update": bool(self.agent),
-                        "name": final_name,
+                        "name": final_name.replace(" ", "_"),
                         "description": final_description,
                     },
                 )
+                
+                mock_exit_tool_response = ToolMessage(
+                    content=json.dumps("Exited Agent Builder Mode. Enter this mode again if you need to modify the saved agent."),
+                    name="exit_agent_builder_mode",
+                    tool_call_id="exit_builder_1"
+                )
 
-                return Command(update={"messages": [mock_assistant_message], "agent_builder_mode": "normal"})
+                return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "agent_builder_mode": "normal"})
 
-        async def route_entry(state: CodeActState) -> Literal["call_model", "agent_builder"]:
+        async def route_entry(state: CodeActState) -> Command[Literal["call_model", "agent_builder", "execute_tools"]]:
             """Route to either normal mode or agent builder creation"""
-            all_tools = await self.registry.export_tools(state["selected_tool_ids"], ToolFormat.LANGCHAIN)
-            # print(all_tools)
+            await self.registry.load_tools(state["selected_tool_ids"])
+            all_tools = await self.registry.export_tools(format=ToolFormat.NATIVE)
 
             # Create the initial system prompt and tools_context in one go
             self.final_instructions, self.tools_context = create_default_prompt(
@@ -394,13 +413,19 @@ class CodeActPlaybookAgent(BaseAgent):
                 self.agent,
                 is_initial_prompt=True,
             )
+            if len(state['messages']) == 1 and self.agent: # Inject the agent's script function into add_context for execution
+                script = self.agent.instructions.get('script')
+                add_context = {"functions":[script]}
+                return Command(goto="call_model", update = {"add_context": add_context})
+
             if state.get("agent_builder_mode") in ["planning", "confirming", "generating"]:
-                return "agent_builder"
-            return "call_model"
+                return Command(goto="agent_builder")
+            return Command(goto="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(agent_builder)
         agent.add_node(execute_tools)
-        agent.add_conditional_edges(START, route_entry)
+        agent.add_node(route_entry)
+        agent.add_edge(START, "route_entry")
         return agent.compile(checkpointer=self.memory)

universal_mcp/agents/codeact0/prompts.py

@@ -1,10 +1,8 @@
 import inspect
 import re
-from collections.abc import Sequence
+from collections.abc import Callable
 
-from langchain_core.tools import StructuredTool
-
-from universal_mcp.agents.codeact0.utils import schema_to_signature
+from loguru import logger
 
 uneditable_prompt = """
 You are **Ruzo**, an AI Assistant created by AgentR — a creative, straight-forward, and direct principal software engineer with access to tools.
@@ -14,7 +12,7 @@ Your job is to answer the user's question or perform the task they ask for.
 - 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`.
+    - Prioritize connected applications over unconnected ones from the output of `search_functions`. However, if the user specifically asks for an application, you MUST use that irrespective of connection status.
     - 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.
@@ -26,6 +24,7 @@ Your job is to answer the user's question or perform the task they ask for.
 - 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.
 - Always describe in 2-3 lines about the current progress. In each step, mention what has been achieved and what you are planning to do next.
+- DO NOT use the code execution to communicate with the user. The user is not able to see the output of the code cells.
 
 **Coding Best Practices:**
 - Variables defined at the top level of previous code snippets can be referenced in your code.
@@ -72,7 +71,7 @@ You must output a JSON object with a single key "steps", which is a list of stri
 
 Your plan should:
 1. Identify the key steps in the workflow
-2. Mark user-specific variables that should become the main agent function parameters using `variable_name` syntax. Intermediate variables should not be highlighted using ``
+2. Mark user-specific variables that should become the main agent function parameters using `variable_name` syntax. Intermediate variables MUST not be highlighted using ``
 3. Keep the logic generic and reusable
 4. Be clear and concise
 
@@ -95,7 +94,8 @@ Your response must be ONLY the Python code for the function.
 Do not include any other text, markdown, or explanations in your response.
 Your response should start with `def` or `async def`.
 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 agent plan.
+The parameters of the function MUST be exactly the same as the final confirmed agent plan. The variables will are indicated using `` in the plan.
+Any additional functions you require should be child functions inside the main top level function, and thus the first function to appear must be the main agent executable function.
 """
 
 
@@ -132,9 +132,23 @@ def make_safe_function_name(name: str) -> str:
     return safe_name
 
 
+def build_tool_definitions(tools: list[Callable]) -> tuple[list[str], dict[str, Callable]]:
+    tool_definitions = []
+    context = {}
+    for tool in tools:
+        tool_name = tool.__name__
+        tool_definitions.append(
+            f'''{"async " if inspect.iscoroutinefunction(tool) else ""}def {tool_name} {str(inspect.signature(tool))}:
+    """{tool.__doc__}"""
+    ...'''
+        )
+        context[tool_name] = tool
+    return tool_definitions, context
+
+
 def create_default_prompt(
-    tools: Sequence[StructuredTool],
-    additional_tools: Sequence[StructuredTool],
+    tools: list[Callable],
+    additional_tools: list[Callable],
     base_prompt: str | None = None,
     apps_string: str | None = None,
     agent: object | None = None,
@@ -150,39 +164,7 @@ def create_default_prompt(
     else:
         system_prompt = ""
 
-    tools_context = {}
-    tool_definitions = []
-
-    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
-        tool_definitions.append(
-            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
-        elif hasattr(tool, "coroutine") and tool.coroutine is not None:
-            tool_callable = tool.coroutine
-            is_async = True
-        tool_definitions.append(
-            f'''{"async " if is_async else ""}def {tool.name} {str(inspect.signature(tool_callable))}:
-    """{tool.description}"""
-    ...'''
-        )
-        safe_name = make_safe_function_name(tool.name)
-        tools_context[safe_name] = tool_callable
-
+    tool_definitions, tools_context = build_tool_definitions(tools + additional_tools)
     system_prompt += "\n".join(tool_definitions)
 
     if is_initial_prompt:
@@ -198,7 +180,7 @@ def create_default_prompt(
                 plan = pb.get("plan")
                 code = pb.get("script")
                 if plan or code:
-                    system_prompt += "\n\nExisting Agent Provided:\n"
+                    system_prompt += "\n\nYou have been provided an existing agent plan and code for performing a task.:\n"
                     if plan:
                         if isinstance(plan, list):
                             plan_block = "\n".join(f"- {str(s)}" for s in plan)
@@ -206,7 +188,7 @@ def create_default_prompt(
                             plan_block = str(plan)
                         system_prompt += f"Plan Steps:\n{plan_block}\n"
                     if code:
-                        system_prompt += f"\nScript:\n```python\n{str(code)}\n```\n"
+                        system_prompt += f"\nScript:\n```python\n{str(code)}\n```\nThis function can be called by you using `execute_ipython_code`, either directly or using asyncio.run (if an async function). Do NOT redefine the function, unless it has to be modified. For modifying it, you must enter agent_builder mode first so that it is modified in the database and not just the chat locally."
         except Exception:
             # Silently ignore formatting issues
             pass

universal_mcp/agents/codeact0/sandbox.py

@@ -26,6 +26,7 @@ def eval_unsafe(
     EXCLUDE_TYPES = (
         types.ModuleType,
         type(re.match("", "")),
+        type(re.compile("")),
         type(threading.Lock()),
         type(threading.RLock()),
         threading.Event,
@@ -44,7 +45,7 @@ def eval_unsafe(
                 exec(code, _locals, _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)
+            result_container["output"] = f"Error during execution: {type(e).__name__}: {e}"
 
     thread = threading.Thread(target=target)
     thread.start()

universal_mcp/agents/codeact0/state.py

@@ -1,6 +1,6 @@
 from typing import Annotated, Any
 
-from langgraph.prebuilt.chat_agent_executor import AgentState
+from langchain.agents import AgentState
 from pydantic import BaseModel, Field
 
 

universal_mcp/agents/codeact0/tools.py

@@ -8,7 +8,7 @@ from pydantic import Field
 from universal_mcp.agentr.registry import AgentrRegistry
 from universal_mcp.types import ToolFormat
 
-from universal_mcp.agents.codeact0.prompts import create_default_prompt
+from universal_mcp.agents.codeact0.prompts import build_tool_definitions
 
 
 def enter_agent_builder_mode():
@@ -181,7 +181,7 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             result_parts.append("")  # Empty line between apps
 
         # Add connection status information
-        if len(connected_apps_in_results) == 0 and len(apps_in_results) > 0:
+        if len(connected_apps_in_results) == 0 and len(apps_in_results) > 1:
             result_parts.append(
                 "Connection Status: None of the apps in the results are connected. You must ask the user to choose the application."
             )
@@ -192,7 +192,9 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             )
 
         result_parts.append("Call load_functions to select the required functions only.")
-        return "\n".join(result_parts)
+        if len(connected_apps_in_results)>len(apps_in_results):
+            result_parts.append("Unconnected app functions can also be loaded if required by the user, but prefer connected ones.")
+        return " ".join(result_parts)
 
     @tool
     async def load_functions(tool_ids: list[str]) -> str:
@@ -218,16 +220,17 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             return "Error: None of the provided tool IDs could be validated or loaded."
 
         # Step 2: Export the schemas of the valid tools.
-        all_exported_tools = await tool_registry.export_tools(valid_tools, ToolFormat.LANGCHAIN)
-        exported_tools = [tool for tool in all_exported_tools if tool.name in valid_tools]
-
+        await tool_registry.load_tools(valid_tools)
+        exported_tools = await tool_registry.export_tools(
+            valid_tools, ToolFormat.NATIVE
+        )  # Get definition for only the new tools
 
         # Step 3: Build the informational string for the agent.
-        tool_definitions, new_tools_context = create_default_prompt(exported_tools, [], is_initial_prompt=False)
+        tool_definitions, new_tools_context = build_tool_definitions(exported_tools)
 
         result_parts = [
             f"Successfully loaded {len(exported_tools)} functions. They are now available for use inside `execute_ipython_cell`:",
-            tool_definitions,
+            "\n".join(tool_definitions),
         ]
 
         response_string = "\n\n".join(result_parts)
@@ -235,7 +238,6 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
 
         return response_string, new_tools_context, valid_tools, unconnected_links
 
-    @tool
     async def web_search(query: str) -> dict:
         """
         Get an LLM answer to a question informed by Exa search results. Useful when you need information from a wide range of real-time sources on the web. Do not use this when you need to access contents of a specific webpage.

universal_mcp/agents/codeact0/utils.py

@@ -4,7 +4,7 @@ import re
 from collections.abc import Sequence
 from typing import Any
 
-from langchain_core.messages import BaseMessage
+from langchain_core.messages import AIMessage, ToolMessage, BaseMessage
 from universal_mcp.types import ToolConfig
 
 MAX_CHARS = 5000
@@ -452,3 +452,78 @@ async def get_connected_apps_string(registry) -> str:
         return "\n".join(apps_list)
     except Exception:
         return "Unable to retrieve connected applications."
+
+
+def create_agent_call(agent: object, agent_args: dict[str, Any]) -> AIMessage:
+    """Create an assistant tool-call message to execute the agent script.
+
+    This inspects the agent's generated script (expected at agent.instructions["script"]) to
+    locate the topmost function or async function, then constructs a Python snippet that:
+    - embeds the script as-is,
+    - deserializes the provided arguments as keyword arguments,
+    - invokes the detected function (awaiting it if async), and
+    - prints the result via smart_print.
+
+    If no top-level function is detected or the script cannot be parsed, a safe fallback
+    snippet is produced which simply prints the provided arguments.
+
+    Args:
+        agent: Object that provides an `instructions` mapping with a `script` string.
+        agent_args: Mapping of argument names to values to be passed as keyword args to the function.
+
+    Returns:
+        AIMessage: A synthetic assistant message containing a single tool call for
+        `execute_ipython_cell` with the constructed snippet.
+    """
+    content = "Running the agent with your provided parameters"
+    script = agent.instructions.get("script") if hasattr(agent, "instructions") else None
+    args = agent_args or {}
+
+    func_name = None
+    is_async = False
+
+    if isinstance(script, str) and script.strip():
+        try:
+            tree = ast.parse(script)
+            for node in tree.body:
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    func_name = node.name
+                    is_async = isinstance(node, ast.AsyncFunctionDef)
+                    break
+        except SyntaxError:
+            func_name = None
+
+    # Fallback content/snippet if no callable function is found
+    if not func_name:
+        snippet = (
+            "import asyncio\n\n# Test fallback: no function detected in script; printing args\n"
+            f"smart_print({repr(args)})\n"
+        )
+    else:
+        import json as _json
+        args_json = _json.dumps(args)
+        if is_async:
+            snippet = (
+                f"{script}\n\n"
+                "import asyncio, json\n"
+                f"_kwargs = json.loads('{args_json}')\n"
+                f"async def __runner():\n    result = await {func_name}(**_kwargs)\n    smart_print(result)\n"
+                "asyncio.run(__runner())\n"
+            )
+        else:
+            snippet = (
+                f"{script}\n\n"
+                "import json\n"
+                f"_kwargs = json.loads('{args_json}')\n"
+                f"result = {func_name}(**_kwargs)\n"
+                "smart_print(result)\n"
+            )
+
+    mock_agent_call = {
+        "name": "execute_ipython_cell",
+        "args": {"snippet": snippet},
+        "id": "initial_agent_call",
+        "type": "tool_call",
+    }
+    mock_assistant_message = AIMessage(content=content, tool_calls=[mock_agent_call])
+    return mock_assistant_message

universal_mcp/agents/react.py

@@ -1,5 +1,5 @@
+from langchain.agents import create_agent
 from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.prebuilt import create_react_agent
 from loguru import logger
 from rich import print
 from universal_mcp.agentr.registry import AgentrRegistry
@@ -75,10 +75,10 @@ class ReactAgent(BaseAgent):
             tools = []
 
         logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
-        return create_react_agent(
+        return create_agent(
             self.llm,
             tools,
-            prompt=self._build_system_message(),
+            system_prompt=self._build_system_message(),
             checkpointer=self.memory,
         )
 

universal_mcp/agents/sandbox.py

@@ -1,90 +1,123 @@
+import ast
+import base64
 import contextlib
-import inspect
 import io
-import queue
-import re
-import socket
-import threading
-import types
-from typing import Any
+import traceback
 
-from universal_mcp.agents.codeact0.utils import derive_context
+import cloudpickle as pickle
 
 
 class Sandbox:
     """
-    A class to execute code safely in a sandboxed environment with a timeout.
+    A simulated environment for executing Python code cells with context
+    maintained across multiple runs.
     """
 
-    def __init__(self, timeout: int = 180):
+    def __init__(self):
+        # Dictionary to store variables (context) across runs
+        self.context = {}
+
+    def add_context(self, context: dict[str, any]):
+        """
+        Adds a dictionary of context to the sandbox.
+        """
+        self.context.update(context)
+
+    def save_context(self) -> str:
+        """
+        Saves the context to a base64 string.
+        """
+        pickled_data = pickle.dumps(self.context)
+        base64_encoded = base64.b64encode(pickled_data).decode("utf-8")
+        return base64_encoded
+
+    def load_context(self, context: str):
+        """
+        Loads the context from a base64 string.
         """
-        Initializes the Sandbox.
+        pickled_data = base64.b64decode(context)
+        self.context = pickle.loads(pickled_data)
+
+    def run(self, code: str) -> dict[str, any]:
+        """
+        Executes the provided Python code string in the maintained context.
+
         Args:
-            timeout: The timeout for code execution in seconds.
+            code (str): The Python code to execute.
+
+        Returns:
+            dict: A dictionary containing the execution results.
         """
-        self.timeout = timeout
-        self._locals: dict[str, Any] = {}
-        self.add_context: dict[str, Any] = {}
+        # Prepare the execution environment:
+        # Use a copy of the context for execution locals/globals
+        exec_scope = self.context.copy()
+
+        stdout_capture = io.StringIO()
+        stderr_output = ""
+
+        # Use a true context manager for robust stdout capture
+        try:
+            with contextlib.redirect_stdout(stdout_capture):
+                # Execute the code. Using the same dictionary for globals and locals
+                # allows newly created variables to be visible immediately.
+                exec(code, exec_scope, exec_scope)
+
+            # Update the context with any new/modified variables
+            # Filter out dunder methods/system keys that might be introduced by exec
+            new_context = {k: v for k, v in exec_scope.items() if not k.startswith("__")}
+            self.context.update(new_context)
 
-    def run(self, code: str) -> tuple[str, dict[str, Any], dict[str, Any]]:
+        except Exception:
+            # Capture the traceback for better error reporting (simulated stderr)
+            stderr_output = traceback.format_exc()
+
+            # The execution scope might contain partially defined variables,
+            # but we continue to maintain the *previous* valid context.
+            # We don't update self.context on failure to avoid polluting it.
+
+        return {"stdout": stdout_capture.getvalue(), "stderr": stderr_output, "success": stderr_output == ""}
+
+    def get_context(self) -> dict[str, any]:
+        """
+        Returns a copy of the current execution context.
+
+        Returns:
+            dict: A copy of the context dictionary.
+        """
+        return self.context.copy()
+
+    def reset(self):
         """
-        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.
+        Resets the sandbox's context, clearing all defined variables.
         """
+        self.context = {}
+
+    async def arun(self, code: str) -> dict[str, any]:
+        """
+        Asynchronously executes Python code, supporting top-level await.
+        """
+        # Use a copy of the context for execution
+        exec_scope = self.context.copy()
+        stdout_capture = io.StringIO()
+        stderr_output = ""
 
-        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)
+            # Compile the code with the special flag to allow top-level await
+            compiled_code = compile(code, "<string>", "exec", flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
+
+            with contextlib.redirect_stdout(stdout_capture):
+                # Eval the compiled code to get a coroutine
+                coroutine = eval(compiled_code, exec_scope, exec_scope)
+
+                # Await the coroutine to run the code if it's async
+                if coroutine:
+                    await coroutine
+
+            # Update the context with any new/modified variables
+            new_context = {k: v for k, v in exec_scope.items() if not k.startswith("__")}
+            self.context.update(new_context)
+
         except Exception:
-            # Keep the old context if derivation fails
-            pass
+            stderr_output = traceback.format_exc()
 
-        return result_container["output"], self._locals, self.add_context
+        return {"stdout": stdout_capture.getvalue(), "stderr": stderr_output, "success": stderr_output == ""}

{universal_mcp_agents-0.1.23rc3.dist-info → universal_mcp_agents-0.1.23rc4.dist-info}/METADATA

@@ -1,23 +1,24 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.23rc3
+Version: 0.1.23rc4
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT
 Requires-Python: >=3.11
+Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: langchain-anthropic>=0.3.19
 Requires-Dist: langchain-google-genai>=2.1.10
 Requires-Dist: langchain-openai>=0.3.32
 Requires-Dist: langgraph>=0.6.6
-Requires-Dist: typer>=0.17.4
 Requires-Dist: universal-mcp-applications>=0.1.25
-Requires-Dist: universal-mcp>=0.1.24rc26
+Requires-Dist: universal-mcp>=0.1.24rc27
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: typer>=0.17.4; extra == 'dev'
 Provides-Extra: test
-Requires-Dist: pytest-asyncio>=1.1.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.2.0; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Requires-Dist: pytest<9.0.0,>=7.0.0; extra == 'test'

{universal_mcp_agents-0.1.23rc3.dist-info → universal_mcp_agents-0.1.23rc4.dist-info}/RECORD

@@ -1,10 +1,10 @@
-universal_mcp/agents/__init__.py,sha256=bW7WJopR6YZSLxghLf8nhohhHPWzm0wdGoZlmKDAcZ4,1078
-universal_mcp/agents/base.py,sha256=sSC217rac89dEheeIRZoMSU_nk9UfSfQw-0E1BjNSIc,7393
+universal_mcp/agents/__init__.py,sha256=Ythw8tyq7p-w1SPnuO2JtS4TvYEP75PkQpdyvZv-ww4,914
+universal_mcp/agents/base.py,sha256=Sa3ws87OlMklXv9NAs_kXNAvP5DbaAUnFQbx1WqEStM,7410
 universal_mcp/agents/cli.py,sha256=9CG7majpWUz7C6t0d8xr-Sg2ZPKBuQdykTbYS6KIZ3A,922
 universal_mcp/agents/hil.py,sha256=_5PCK6q0goGm8qylJq44aSp2MadP-yCPvhOJYKqWLMo,3808
 universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
-universal_mcp/agents/react.py,sha256=8XQvJ0HLVgc-K0qn9Ml48WGcgUGuIKtL67HatlT6Da0,3334
-universal_mcp/agents/sandbox.py,sha256=Int2O8JNFPlB8c7gb86KRxlNbuV0zdz5_NCo_GMcCds,2876
+universal_mcp/agents/react.py,sha256=ocYm94HOiJVI2zwTjO1K2PNfVY7EILLJ6cd__jnGHPs,3327
+universal_mcp/agents/sandbox.py,sha256=LL4OfavEzxbmTDcc_NxizRRpQnw5hc3G2bxvFY63scY,4241
 universal_mcp/agents/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
 universal_mcp/agents/utils.py,sha256=P6W9k6XAOBp6tdjC2VTP4tE0B2M4-b1EDmr-ylJ47Pw,7765
 universal_mcp/agents/bigtool/__init__.py,sha256=mZG8dsaCVyKlm82otxtiTA225GIFLUCUUYPEIPF24uw,2299
@@ -13,7 +13,7 @@ universal_mcp/agents/bigtool/agent.py,sha256=mtCDNN8WjE2hjJjooDqusmbferKBHeJMHrh
 universal_mcp/agents/bigtool/context.py,sha256=ny7gd-vvVpUOYAeQbAEUT0A6Vm6Nn2qGywxTzPBzYFg,929
 universal_mcp/agents/bigtool/graph.py,sha256=2Sy0dtevTWeT3hJDq4BDerZFvk_zJqx15j8VH2XLq8Y,5848
 universal_mcp/agents/bigtool/prompts.py,sha256=Joi5mCzZX63aM_6eBrMOKuNRHjTkceVIibSsGBGqhYE,2041
-universal_mcp/agents/bigtool/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
+universal_mcp/agents/bigtool/state.py,sha256=Voh7HXGC0PVe_0qoRZ8ZYg9akg65_2jQIAV2eIwperE,737
 universal_mcp/agents/bigtool/tools.py,sha256=-u80ta6xEaqzEMSzDVe3QZiTZm3YlgLkBD8WTghzClw,6315
 universal_mcp/agents/builder/__main__.py,sha256=VJDJOr-dJJerT53ibh5LVqIsMJ0m0sG2UlzFB784pKw,11680
 universal_mcp/agents/builder/builder.py,sha256=mh3MZpMVB1FE1DWzvMW9NnfiaF145VGn8cJzKSYUlzY,8587
@@ -21,16 +21,16 @@ universal_mcp/agents/builder/helper.py,sha256=8igR1b3Gy_N2u3WxHYKIWzvw7F5BMnfpO2
 universal_mcp/agents/builder/prompts.py,sha256=8Xs6uzTUHguDRngVMLak3lkXFkk2VV_uQXaDllzP5cI,4670
 universal_mcp/agents/builder/state.py,sha256=7DeWllxfN-yD6cd9wJ3KIgjO8TctkJvVjAbZT8W_zqk,922
 universal_mcp/agents/codeact0/__init__.py,sha256=8-fvUo1Sm6dURGI-lW-X3Kd78LqySYbb5NMkNJ4NDwg,76
-universal_mcp/agents/codeact0/__main__.py,sha256=EHW9ePVePEemGI5yMUBc2Mp_JlrP6Apk1liab1y2Rd8,782
-universal_mcp/agents/codeact0/agent.py,sha256=LzCshVduxT8weYbZ2mOyL1-rp4o-8H1ODoZAaONAV6o,19322
+universal_mcp/agents/codeact0/__main__.py,sha256=YyIoecUcKVUhTcCACzLlSmYrayMDsdwzDEqaV4VV4CE,766
+universal_mcp/agents/codeact0/agent.py,sha256=jaBntdEGydWI6OvRPpDsrLjnNncDdvQtjJbAgkeYp-U,20545
 universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
 universal_mcp/agents/codeact0/langgraph_agent.py,sha256=8nz2wq-LexImx-l1y9_f81fK72IQetnCeljwgnduNGY,420
 universal_mcp/agents/codeact0/llm_tool.py,sha256=-pAz04OrbZ_dJ2ueysT1qZd02DrbLY4EbU0tiuF_UNU,798
-universal_mcp/agents/codeact0/prompts.py,sha256=PEBPHvw4yItNVMAaaVUfNVhp53iijxs283Ln6xhew-4,11623
-universal_mcp/agents/codeact0/sandbox.py,sha256=Xw4tbUV_6haYIZZvteJi6lIYsW6ni_3DCRCOkslTKgM,4459
-universal_mcp/agents/codeact0/state.py,sha256=241G-ZDIs4dqm_RnfLZuZOBr7llJOh4dQoDc0aiRcPo,1947
-universal_mcp/agents/codeact0/tools.py,sha256=ZvAqi2vwarTlPizVdu9cZIAoujtBTF4OWnd69rdIIyA,14711
-universal_mcp/agents/codeact0/utils.py,sha256=Gvft0W0Sg1qlFWm8ciX14yssCa8y3x037lql92yGsBQ,18164
+universal_mcp/agents/codeact0/prompts.py,sha256=Zt0ea01ofz6oS7fgyGK2Q2zN9CNMHGubBdR54VgvKic,11684
+universal_mcp/agents/codeact0/sandbox.py,sha256=BeWJk_ucXed3QMHH6ae3FfVkbhSuRAlPXkjUeTUiufw,4504
+universal_mcp/agents/codeact0/state.py,sha256=cf-94hfVub-HSQJk6b7_SzqBS-oxMABjFa8jqyjdDK0,1925
+universal_mcp/agents/codeact0/tools.py,sha256=i2-WppqEfpJXPa7QouLfX3qXJgInBGVY9qxAGxFOUEg,14896
+universal_mcp/agents/codeact0/utils.py,sha256=F2aFnN0tNXbFfe8imO1iccHXTvWwSSulIbsrkwhhpno,21123
 universal_mcp/agents/shared/__main__.py,sha256=XxH5qGDpgFWfq7fwQfgKULXGiUgeTp_YKfcxftuVZq8,1452
 universal_mcp/agents/shared/prompts.py,sha256=yjP3zbbuKi87qCj21qwTTicz8TqtkKgnyGSeEjMu3ho,3761
 universal_mcp/agents/shared/tool_node.py,sha256=DC9F-Ri28Pam0u3sXWNODVgmj9PtAEUb5qP1qOoGgfs,9169
@@ -39,6 +39,6 @@ universal_mcp/applications/filesystem/app.py,sha256=0TRjjm8YnslVRSmfkXI7qQOAlqWl
 universal_mcp/applications/llm/__init__.py,sha256=_XGRxN3O1--ZS5joAsPf8IlI9Qa6negsJrwJ5VJXno0,46
 universal_mcp/applications/llm/app.py,sha256=g9mK-luOLUshZzBGyQZMOHBeCSXmh2kCKir40YnsGUo,12727
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.23rc3.dist-info/METADATA,sha256=-Bv-20WOl1vY3WTMTmZe0eUShg6RG7vcmPt9HuUFXnU,881
-universal_mcp_agents-0.1.23rc3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.23rc3.dist-info/RECORD,,
+universal_mcp_agents-0.1.23rc4.dist-info/METADATA,sha256=r3bhzzNiFXm9rGO6TU0sphN2YzqDkGR_5KHej-DEm4c,931
+universal_mcp_agents-0.1.23rc4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.23rc4.dist-info/RECORD,,