universal-mcp-agents 0.1.23rc2__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,11 +64,11 @@ 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_playbook = isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "playbook"
+                is_agent_builder = isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "agent_builder"
                 additional_kwargs = getattr(payload, "additional_kwargs", {}) or {}
-                if is_playbook and not additional_kwargs.get("stream"):
+                if is_agent_builder and not additional_kwargs.get("stream"):
                     continue
                 if isinstance(payload, AIMessageChunk):
                     last_ai_chunk = payload

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
@@ -16,19 +16,18 @@ from universal_mcp.types import ToolFormat
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.codeact0.llm_tool import smart_print
 from universal_mcp.agents.codeact0.prompts import (
-    PLAYBOOK_GENERATING_PROMPT,
-    PLAYBOOK_META_PROMPT,
-    PLAYBOOK_PLANNING_PROMPT,
+    AGENT_BUILDER_GENERATING_PROMPT,
+    AGENT_BUILDER_META_PROMPT,
+    AGENT_BUILDER_PLANNING_PROMPT,
     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, PlaybookCode, PlaybookMeta, PlaybookPlan
+from universal_mcp.agents.codeact0.state import AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan, CodeActState
 from universal_mcp.agents.codeact0.tools import (
     create_meta_tools,
-    enter_playbook_mode,
-    get_valid_tools,
+    enter_agent_builder_mode,
 )
-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
 
@@ -41,7 +40,7 @@ class CodeActPlaybookAgent(BaseAgent):
         model: str,
         memory: BaseCheckpointSaver | None = None,
         registry: ToolRegistry | None = None,
-        playbook_registry: object | None = None,
+        agent_builder_registry: object | None = None,
         sandbox_timeout: int = 20,
         **kwargs,
     ):
@@ -53,11 +52,13 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.playbook_model_instance = load_chat_model("azure/gpt-4.1")
+        self.agent_builder_model_instance = load_chat_model("azure/gpt-4.1")
         self.registry = registry
-        self.playbook_registry = playbook_registry
-        self.playbook = playbook_registry.get_agent() if playbook_registry else None
-        self.tools_config = self.playbook.tools if self.playbook else {}
+        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
         self.default_tools_config = {
@@ -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."""
@@ -91,7 +88,7 @@ class CodeActPlaybookAgent(BaseAgent):
 
             agent_facing_tools = [
                 execute_ipython_cell,
-                enter_playbook_mode,
+                enter_agent_builder_mode,
                 meta_tools["search_functions"],
                 meta_tools["load_functions"],
             ]
@@ -113,14 +110,13 @@ 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:
                 return Command(update={"messages": [response], "model_with_tools": model_with_tools})
 
-        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "playbook"]]:
+        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "agent_builder"]]:
             """Execute tool calls"""
             last_message = state["messages"][-1]
             tool_calls = last_message.tool_calls if isinstance(last_message, AIMessage) else []
@@ -128,6 +124,8 @@ class CodeActPlaybookAgent(BaseAgent):
             tool_messages = []
             new_tool_ids = []
             tool_result = ""
+            ask_user = False
+            ai_msg = ""
             effective_previous_add_context = state.get("add_context", {})
             effective_existing_context = state.get("context", {})
             # logging.info(f"Initial new_tool_ids_for_context: {new_tool_ids_for_context}")
@@ -136,15 +134,18 @@ class CodeActPlaybookAgent(BaseAgent):
                 tool_name = tool_call["name"]
                 tool_args = tool_call["args"]
                 try:
-                    if tool_name == "enter_playbook_mode":
+                    if tool_name == "enter_agent_builder_mode":
                         tool_message = ToolMessage(
-                            content=json.dumps("Entered Playbook Mode."),
+                            content=json.dumps("Entered Agent Builder 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
+                            goto="agent_builder",
+                            update={
+                                "agent_builder_mode": "planning",
+                                "messages": [tool_message],
+                            },  # Entered Agent Builder mode
                         )
                     elif tool_name == "execute_ipython_cell":
                         code = tool_call["args"]["snippet"]
@@ -160,24 +161,23 @@ class CodeActPlaybookAgent(BaseAgent):
                         tool_result = output
                     elif tool_name == "load_functions":
                         # The tool now does all the work of validation and formatting.
-                        tool_result = 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`
-                        valid_tools, _ = await get_valid_tools(tool_ids=tool_args["tool_ids"], registry=self.registry)
                         new_tool_ids.extend(valid_tools)
                         if new_tool_ids:
-                            newly_exported = await self.registry.export_tools(new_tool_ids, ToolFormat.LANGCHAIN)
-                            _, new_context_for_sandbox = create_default_prompt(
-                                newly_exported, [], "", "", None
-                            )  # is_initial_prompt is False by default
                             self.tools_context.update(new_context_for_sandbox)
+                        if unconnected_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 {unconnected_links} "
 
                     elif tool_name == "search_functions":
                         tool_result = await meta_tools["search_functions"].ainvoke(tool_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'. For using functions, call them in code using 'execute_ipython_cell'."
+                            "tool calls must be one of 'enter_agent_builder_mode', 'execute_ipython_cell', 'load_functions', or 'search_functions'. For using functions, call them in code using 'execute_ipython_cell'."
                         )
                 except Exception as e:
                     tool_result = str(e)
@@ -189,6 +189,17 @@ class CodeActPlaybookAgent(BaseAgent):
                 )
                 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,
+                        "context": effective_existing_context,
+                        "add_context": effective_previous_add_context,
+                    }
+                )
+
             return Command(
                 goto="call_model",
                 update={
@@ -199,17 +210,19 @@ class CodeActPlaybookAgent(BaseAgent):
                 },
             )
 
-        def playbook(state: CodeActState, writer: StreamWriter) -> Command[Literal["call_model"]]:
-            playbook_mode = state.get("playbook_mode")
-            if playbook_mode == "planning":
+        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())
-                writer({"type": "custom", id: plan_id, "name": "planning", "data": {"update": bool(self.playbook)}})
-                planning_instructions = self.instructions + PLAYBOOK_PLANNING_PROMPT
+                writer({"type": "custom", id: plan_id, "name": "planning", "data": {"update": bool(self.agent)}})
+                planning_instructions = self.instructions + AGENT_BUILDER_PLANNING_PROMPT
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
-                model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookPlan)
-                response = model_with_structured_output.invoke(messages)
-                plan = cast(PlaybookPlan, response)
+                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}})
                 return Command(
@@ -220,16 +233,16 @@ class CodeActPlaybookAgent(BaseAgent):
                                 additional_kwargs={
                                     "type": "planning",
                                     "plan": plan.steps,
-                                    "update": bool(self.playbook),
+                                    "update": bool(self.agent),
                                 },
                             )
                         ],
-                        "playbook_mode": "confirming",
+                        "agent_builder_mode": "confirming",
                         "plan": plan.steps,
                     }
                 )
 
-            elif playbook_mode == "confirming":
+            elif agent_builder_mode == "confirming":
                 # Deterministic routing based on three exact button inputs from UI
                 user_text = ""
                 for m in reversed(state["messages"]):
@@ -245,10 +258,10 @@ class CodeActPlaybookAgent(BaseAgent):
                 if t == "yes, this is great":
                     self.meta_id = str(uuid.uuid4())
                     name, description = None, None
-                    if self.playbook:
+                    if self.agent:
                         # Update flow: use existing name/description and do not re-generate
-                        name = getattr(self.playbook, "name", None)
-                        description = getattr(self.playbook, "description", None)
+                        name = getattr(self.agent, "name", None)
+                        description = getattr(self.agent, "description", None)
                         writer(
                             {
                                 "type": "custom",
@@ -264,12 +277,14 @@ class CodeActPlaybookAgent(BaseAgent):
                     else:
                         writer({"type": "custom", id: self.meta_id, "name": "generating", "data": {"update": False}})
 
-                        meta_instructions = self.instructions + PLAYBOOK_META_PROMPT
+                        meta_instructions = self.instructions + AGENT_BUILDER_META_PROMPT
                         messages = [{"role": "system", "content": meta_instructions}] + state["messages"]
 
-                        model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookMeta)
-                        meta_response = model_with_structured_output.invoke(messages)
-                        meta = cast(PlaybookMeta, meta_response)
+                        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
 
                         # Emit intermediary UI update with created name/description
@@ -283,11 +298,11 @@ class CodeActPlaybookAgent(BaseAgent):
                         )
 
                     return Command(
-                        goto="playbook",
+                        goto="agent_builder",
                         update={
-                            "playbook_mode": "generating",
-                            "playbook_name": name,
-                            "playbook_description": description,
+                            "agent_builder_mode": "generating",
+                            "agent_name": name,
+                            "agent_description": description,
                         },
                     )
                 if t == "i would like to modify the plan":
@@ -295,52 +310,53 @@ class CodeActPlaybookAgent(BaseAgent):
                         content="What would you like to change about the plan? Let me know and I'll update the plan accordingly.",
                         additional_kwargs={"stream": "true"},
                     )
-                    return Command(update={"playbook_mode": "planning", "messages": [prompt_ai]})
+                    return Command(update={"agent_builder_mode": "planning", "messages": [prompt_ai]})
                 if t == "let's do something else":
-                    return Command(goto="call_model", update={"playbook_mode": "inactive"})
+                    return Command(goto="call_model", update={"agent_builder_mode": "inactive"})
 
                 # Fallback safe default
-                return Command(goto="call_model", update={"playbook_mode": "inactive"})
+                return Command(goto="call_model", update={"agent_builder_mode": "inactive"})
 
-            elif playbook_mode == "generating":
-                generating_instructions = self.instructions + PLAYBOOK_GENERATING_PROMPT
+            elif agent_builder_mode == "generating":
+                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
 
-                model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookCode)
-                response = model_with_structured_output.invoke(messages)
-                func_code = cast(PlaybookCode, response).code
+                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)
                 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"
+                    function_name = "generated_agent"
 
                 # Use generated metadata if available
-                final_name = state.get("playbook_.pyname") or function_name
-                final_description = state.get("playbook_description") or f"Generated playbook: {function_name}"
+                final_name = state.get("agent_name") or function_name
+                final_description = state.get("agent_description") or f"Generated agent: {function_name}"
 
                 # Save or update an Agent using the helper registry
                 try:
-                    if not self.playbook_registry:
-                        raise ValueError("Playbook registry is not configured")
+                    if not self.agent_builder_registry:
+                        raise ValueError("AgentBuilder registry is not configured")
 
                     # Build instructions payload embedding the plan and function code
                     instructions_payload = {
-                        "playbookPlan": state["plan"],
-                        "playbookScript": func_code,
+                        "plan": state["plan"],
+                        "script": func_code,
                     }
 
                     # Convert tool ids list to dict
                     tool_dict = convert_tool_ids_to_dict(state["selected_tool_ids"])
 
-                    res = self.playbook_registry.upsert_agent(
+                    res = self.agent_builder_registry.upsert_agent(
                         name=final_name,
                         description=final_description,
                         instructions=instructions_payload,
                         tools=tool_dict,
-                        visibility="private",
                     )
                 except Exception as e:
                     raise e
@@ -352,29 +368,41 @@ class CodeActPlaybookAgent(BaseAgent):
                         "name": "generating",
                         "data": {
                             "id": str(res.id),
-                            "update": bool(self.playbook),
+                            "update": bool(self.agent),
                             "name": final_name,
                             "description": final_description,
                         },
                     }
                 )
+                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.playbook),
-                        "name": final_name,
+                        "update": bool(self.agent),
+                        "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], "playbook_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", "playbook"]:
-            """Route to either normal mode or playbook creation"""
-            all_tools = await self.registry.export_tools(state["selected_tool_ids"], ToolFormat.LANGCHAIN)
-            # print(all_tools)
+        async def route_entry(state: CodeActState) -> Command[Literal["call_model", "agent_builder", "execute_tools"]]:
+            """Route to either normal mode or agent builder creation"""
+            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(
@@ -382,16 +410,22 @@ class CodeActPlaybookAgent(BaseAgent):
                 self.additional_tools,
                 self.instructions,
                 await get_connected_apps_string(self.registry),
-                self.playbook,
+                self.agent,
                 is_initial_prompt=True,
             )
-            if state.get("playbook_mode") in ["planning", "confirming", "generating"]:
-                return "playbook"
-            return "call_model"
+            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 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(playbook)
+        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.
@@ -63,16 +62,16 @@ Rules:
 - Your final response should contain the complete answer to the user's request in a clear, well-formatted manner that directly addresses what they asked for.
 """
 
-PLAYBOOK_PLANNING_PROMPT = """Now, you are tasked with creating a reusable playbook from the user's previous workflow.
+AGENT_BUILDER_PLANNING_PROMPT = """Now, you are tasked with creating a reusable agent 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.
 The plan is a sequence of steps.
-You must output a JSON object with a single key "steps", which is a list of strings. Each string is a step in the playbook.
+You must output a JSON object with a single key "steps", which is a list of strings. Each string is a step in the agent.
 
 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 ``
+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
 
@@ -90,26 +89,27 @@ Now create a plan based on the conversation history. Do not include any other te
 """
 
 
-PLAYBOOK_GENERATING_PROMPT = """Now, you are tasked with generating the playbook function.
+AGENT_BUILDER_GENERATING_PROMPT = """Now, you are tasked with generating the agent function.
 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 playbook 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.
 """
 
 
-PLAYBOOK_META_PROMPT = """
-You are preparing metadata for a reusable playbook based on the confirmed step-by-step plan.
+AGENT_BUILDER_META_PROMPT = """
+You are preparing metadata for a reusable agent based on the confirmed step-by-step plan.
 
-TASK: Create a concise, human-friendly name and a short description for the playbook.
+TASK: Create a concise, human-friendly name and a short description for the agent.
 
 INPUTS:
 - Conversation context and plan steps will be provided in prior messages
 
 REQUIREMENTS:
 1. Name: 3-6 words, Title Case, no punctuation except hyphens if needed
-2. Description: Single sentence, <= 140 characters, clearly states what the playbook does
+2. Description: Single sentence, <= 140 characters, clearly states what the agent does
 
 OUTPUT: Return ONLY a JSON object with exactly these keys:
 {
@@ -132,12 +132,26 @@ 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,
-    playbook: object | None = None,
+    agent: object | None = None,
     is_initial_prompt: bool = False,
 ):
     if is_initial_prompt:
@@ -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:
@@ -191,14 +173,14 @@ def create_default_prompt(
                 f"\n\nUse the following information/instructions while completing your tasks:\n\n{base_prompt}"
             )
 
-        # Append existing playbook (plan + code) if provided
+        # Append existing agent (plan + code) if provided
         try:
-            if playbook and hasattr(playbook, "instructions"):
-                pb = playbook.instructions or {}
-                plan = pb.get("playbookPlan")
-                code = pb.get("playbookScript")
+            if agent and hasattr(agent, "instructions"):
+                pb = agent.instructions or {}
+                plan = pb.get("plan")
+                code = pb.get("script")
                 if plan or code:
-                    system_prompt += "\n\nExisting Playbook 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,19 +1,19 @@
 from typing import Annotated, Any
 
-from langgraph.prebuilt.chat_agent_executor import AgentState
+from langchain.agents import AgentState
 from pydantic import BaseModel, Field
 
 
-class PlaybookPlan(BaseModel):
-    steps: list[str] = Field(description="The steps of the playbook.")
+class AgentBuilderPlan(BaseModel):
+    steps: list[str] = Field(description="The steps of the agent.")
 
 
-class PlaybookCode(BaseModel):
-    code: str = Field(description="The Python code for the playbook.")
+class AgentBuilderCode(BaseModel):
+    code: str = Field(description="The Python code for the agent.")
 
 
-class PlaybookMeta(BaseModel):
-    name: str = Field(description="Concise, title-cased playbook name (3-6 words).")
+class AgentBuilderMeta(BaseModel):
+    name: str = Field(description="Concise, title-cased agent name (3-6 words).")
     description: str = Field(description="Short, one-sentence description (<= 140 chars).")
 
 
@@ -46,13 +46,13 @@ class CodeActState(AgentState):
     """Dictionary containing the execution context with available tools and variables."""
     add_context: dict[str, Any]
     """Dictionary containing the additional context (functions, classes, imports) to be added to the execution context."""
-    playbook_mode: str | None
-    """State for the playbook agent."""
+    agent_builder_mode: str | None
+    """State for the agent builder agent."""
     selected_tool_ids: Annotated[list[str], _enqueue]
     """Queue for tools exported from registry"""
     plan: list[str] | None
-    """Plan for the playbook agent."""
-    playbook_name: str | None
-    """Generated playbook name after confirmation."""
-    playbook_description: str | None
+    """Plan for the agent builder agent."""
+    agent_name: str | None
+    """Generated agent name after confirmation."""
+    agent_description: str | None
     """Generated short description after confirmation."""

universal_mcp/agents/codeact0/tools.py

@@ -8,11 +8,11 @@ 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_playbook_mode():
-    """Call this function to enter playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
+def enter_agent_builder_mode():
+    """Call this function to enter agent builder mode. Agent builder mode is when the user wants to store a repeated task as a script with some inputs for the future."""
     return
 
 
@@ -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:
@@ -212,39 +214,30 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             return "No tool IDs provided to load."
 
         # Step 1: Validate which tools are usable and get login links for others.
-        valid_tool_ids, unconnected_links = await get_valid_tools(tool_ids=tool_ids, registry=tool_registry)
+        valid_tools, unconnected_links = await get_valid_tools(tool_ids=tool_ids, registry=tool_registry)
 
-        if not valid_tool_ids:
+        if not valid_tools:
             return "Error: None of the provided tool IDs could be validated or loaded."
 
         # Step 2: Export the schemas of the valid tools.
-        try:
-            # Create a temporary, clean registry to export only the requested tools
-            temp_registry = AgentrRegistry()
-            exported_tools = await temp_registry.export_tools(valid_tool_ids, ToolFormat.LANGCHAIN)
-        except Exception as e:
-            return f"Error exporting tools: {e}"
+        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, _ = 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)
+        unconnected_links = "\n".join(unconnected_links)
 
-        # Append login links if any apps were not connected
-        if unconnected_links:
-            links = "\n".join(unconnected_links)
-            response_string += (
-                f"\n\nPlease ask the user to log in to the following app(s) to use their full functionality:\n{links}"
-            )
-
-        return response_string
+        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.23rc2.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.23rc2
+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.23rc2.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=CEnY8y2as_XR311t9v2iqd4DOCSyhpOPOBDcZKNJMpc,7378
+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=9YwcCeRE_bSl77JG54SOJjQxqZxCd_ZfdBJmgb1N0RA,18818
+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=qFcGDsISqW3iUNpW4yNDCH_vDwx75QS0acQsWI0Ul2w,11666
-universal_mcp/agents/codeact0/sandbox.py,sha256=Xw4tbUV_6haYIZZvteJi6lIYsW6ni_3DCRCOkslTKgM,4459
-universal_mcp/agents/codeact0/state.py,sha256=ESlxz68bwudasuL8jCI7GhweTqgLbYQqZM0mPkE06hQ,1938
-universal_mcp/agents/codeact0/tools.py,sha256=bCIJDNkyE_6SULoU8LGvupOrRrvaa9JZVMPMTdsGDEs,15017
-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.23rc2.dist-info/METADATA,sha256=v2vW8cUeI8cn6XY502FcEhBaYVeLpXu1n2D9FpUmJ4Y,881
-universal_mcp_agents-0.1.23rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.23rc2.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,,