universal-mcp-agents 0.1.23rc7__tar.gz → 0.1.23rc8__tar.gz

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/PKG-INFO

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

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/pyproject.toml

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

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/src/universal_mcp/agents/base.py

@@ -1,12 +1,13 @@
-from typing import Any, cast
-from uuid import uuid4
 import asyncio
+from typing import cast
+from uuid import uuid4
 
 from langchain_core.messages import AIMessageChunk
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import StateGraph
 from langgraph.types import Command
 from universal_mcp.logger import logger
+
 from .utils import RichCLI
 
 

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/src/universal_mcp/agents/codeact0/agent.py

@@ -3,10 +3,9 @@ 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.messages import AIMessage, HumanMessage, ToolMessage
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import START, StateGraph
 from langgraph.types import Command, RetryPolicy, StreamWriter
@@ -19,8 +18,8 @@ from universal_mcp.agents.codeact0.prompts import (
     AGENT_BUILDER_GENERATING_PROMPT,
     AGENT_BUILDER_META_PROMPT,
     AGENT_BUILDER_PLANNING_PROMPT,
+    build_tool_definitions,
     create_default_prompt,
-    build_tool_definitions
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
 from universal_mcp.agents.codeact0.state import AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan, CodeActState
@@ -53,12 +52,11 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.agent_builder_model_instance = load_chat_model("anthropic:claude-sonnet-4-5-20250929", thinking = False)
+        self.agent_builder_model_instance = load_chat_model("anthropic:claude-sonnet-4-5-20250929")
         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
@@ -67,21 +65,23 @@ class CodeActPlaybookAgent(BaseAgent):
         }
         self.final_instructions = ""
         self.tools_context = {}
+        self.eval_mode = kwargs.get("eval_mode", False)
 
     async def _build_graph(self):  # noqa: PLR0915
         """Build the graph for the CodeAct Playbook Agent."""
         meta_tools = create_meta_tools(self.registry)
-        self.additional_tools = [smart_print, meta_tools["web_search"]]
+        self.additional_tools = [
+            smart_print,
+            meta_tools["web_search"],
+            meta_tools["read_file"],
+            meta_tools["save_file"],
+            meta_tools["upload_file"],
+        ]
 
         if self.tools_config:
-            if isinstance(self.tools_config, dict):
-                self.tools_config = [
-                    f"{provider}__{tool}" for provider, tools in self.tools_config.items() for tool in tools
-                ]
-                if not self.registry:
-                    raise ValueError("Tools are configured but no registry is provided")
-            await self.registry.load_tools(self.tools_config)  # Load the default tools
-        await self.registry.load_tools(self.default_tools_config)  # Load more tools
+            await self.registry.load_tools(self.tools_config)  # Load provided tools
+        if self.default_tools_config:
+            await self.registry.load_tools(self.default_tools_config)  # Load default tools
 
         async def call_model(state: CodeActState) -> Command[Literal["execute_tools"]]:
             """This node now only ever binds the four meta-tools to the LLM."""
@@ -226,18 +226,29 @@ class CodeActPlaybookAgent(BaseAgent):
                 plan = cast(AgentBuilderPlan, response)
 
                 writer({"type": "custom", id: plan_id, "name": "planning", "data": {"plan": plan.steps}})
+                ai_msg = AIMessage(
+                    content=json.dumps(plan.model_dump()),
+                    additional_kwargs={
+                        "type": "planning",
+                        "plan": plan.steps,
+                        "update": bool(self.agent),
+                    },
+                )
+
+                if self.eval_mode:
+                    mock_user_message = HumanMessage(content="yes, this is great")
+                    return Command(
+                        goto="agent_builder",
+                        update={
+                            "messages": [ai_msg, mock_user_message],
+                            "agent_builder_mode": "generating",
+                            "plan": plan.steps,
+                        },
+                    )
+
                 return Command(
                     update={
-                        "messages": [
-                            AIMessage(
-                                content=json.dumps(plan.model_dump()),
-                                additional_kwargs={
-                                    "type": "planning",
-                                    "plan": plan.steps,
-                                    "update": bool(self.agent),
-                                },
-                            )
-                        ],
+                        "messages": [ai_msg],
                         "agent_builder_mode": "confirming",
                         "plan": plan.steps,
                     }
@@ -319,7 +330,7 @@ class CodeActPlaybookAgent(BaseAgent):
                 return Command(goto="call_model", update={"agent_builder_mode": "inactive"})
 
             elif agent_builder_mode == "generating":
-                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT +  self.preloaded_defs
+                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT + self.preloaded_defs
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
 
                 model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
@@ -359,14 +370,10 @@ class CodeActPlaybookAgent(BaseAgent):
                         instructions=instructions_payload,
                         tools=tool_dict,
                     )
-                except Exception as e:
+                except Exception:
                     # In case of error, add the code to the exit message content
 
-                    mock_exit_tool_call = {
-                    "name": "exit_agent_builder_mode",
-                    "args": {},
-                    "id": "exit_builder_1"
-                    }
+                    mock_exit_tool_call = {"name": "exit_agent_builder_mode", "args": {}, "id": "exit_builder_1"}
 
                     # Create a minimal assistant message to maintain flow
                     mock_assistant_message = AIMessage(
@@ -385,9 +392,25 @@ class CodeActPlaybookAgent(BaseAgent):
                             f"An error occurred. Displaying the function code:\n\n{func_code}\nFinal Name: {final_name}\nDescription: {final_description}"
                         ),
                         name="exit_agent_builder_mode",
-                        tool_call_id="exit_builder_1"
+                        tool_call_id="exit_builder_1",
+                    )
+                    if self.eval_mode:
+                        human_msg = HumanMessage(
+                            content="Run the generated agent code and check whether it works as expected"
+                        )
+                        return Command(
+                            goto="call_model",
+                            update={
+                                "messages": [mock_assistant_message, mock_exit_tool_response, human_msg],
+                                "agent_builder_mode": "normal",
+                            },
+                        )
+                    return Command(
+                        update={
+                            "messages": [mock_assistant_message, mock_exit_tool_response],
+                            "agent_builder_mode": "normal",
+                        }
                     )
-                    return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "agent_builder_mode": "normal"})
 
                 writer(
                     {
@@ -402,11 +425,7 @@ class CodeActPlaybookAgent(BaseAgent):
                         },
                     }
                 )
-                mock_exit_tool_call = {
-                    "name": "exit_agent_builder_mode",
-                    "args": {},
-                    "id": "exit_builder_1"
-                }
+                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],
@@ -418,14 +437,21 @@ class CodeActPlaybookAgent(BaseAgent):
                         "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."),
+                    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"
+                    tool_call_id="exit_builder_1",
                 )
 
-                return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "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) -> Command[Literal["call_model", "agent_builder", "execute_tools"]]:
             """Route to either normal mode or agent builder creation"""
@@ -441,16 +467,20 @@ class CodeActPlaybookAgent(BaseAgent):
                 is_initial_prompt=True,
             )
             self.preloaded_defs, _ = build_tool_definitions(pre_tools)
-            self.preloaded_defs = '\n'.join(self.preloaded_defs)
+            self.preloaded_defs = "\n".join(self.preloaded_defs)
             await self.registry.load_tools(state["selected_tool_ids"])
-            exported_tools = await self.registry.export_tools(state["selected_tool_ids"],ToolFormat.NATIVE)  # Get definition for only the new tools
+            exported_tools = await self.registry.export_tools(
+                state["selected_tool_ids"], ToolFormat.NATIVE
+            )  # Get definition for only the new tools
             _, loaded_tools_context = build_tool_definitions(exported_tools)
             self.tools_context.update(loaded_tools_context)
-            
-            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 (
+                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")

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/src/universal_mcp/agents/codeact0/prompts.py

@@ -2,8 +2,6 @@ import inspect
 import re
 from collections.abc import Callable
 
-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.
 
@@ -45,6 +43,7 @@ Your job is to answer the user's question or perform the task they ask for.
 - Always respond in github flavoured markdown format.
 - For charts and diagrams, use mermaid chart in markdown directly.
 - 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.
+- For file types like images, audio, documents, etc., you must use the `upload_file` tool to upload the file to the server and render the link in the markdown response.
 """
 
 AGENT_BUILDER_PLANNING_PROMPT = """TASK: Analyze the conversation history and code execution to create a step-by-step non-technical plan for a reusable function.
@@ -100,7 +99,7 @@ Rules-
 - Do not include any text, explanations, or Markdown.
 - The response must start with `def` or `async def` and define a single, complete, executable function.
 - The function parameters **must exactly match the external variables** in the agent plan. External variables are marked using backticks `` `variable_name` ``.  Any variables in italics (i.e. enclosed in *...*) are to be used internally, but not as the main function paramters.
-- Any imports, variables, helper or child functions required must be defined **inside the main top-level function**.  
+- Any imports, variables, helper or child functions required must be defined **inside the main top-level function**.
 - Ensure that the outer function is self-contained and can run independently, based on previously validated code snippets.
 
 Example:
@@ -162,38 +161,39 @@ def make_safe_function_name(name: str) -> str:
 
 
 # Compile regex once for better performance
-_RAISES_PATTERN = re.compile(r'\n\s*[Rr]aises\s*:.*$', re.DOTALL)
+_RAISES_PATTERN = re.compile(r"\n\s*[Rr]aises\s*:.*$", re.DOTALL)
+
 
 def _clean_docstring(docstring: str | None) -> str:
     """Remove the 'Raises:' section and everything after it from a docstring."""
     if not docstring:
         return ""
-    
+
     # Use pre-compiled regex for better performance
-    cleaned = _RAISES_PATTERN.sub('', docstring)
+    cleaned = _RAISES_PATTERN.sub("", docstring)
     return cleaned.strip()
 
 
 def build_tool_definitions(tools: list[Callable]) -> tuple[list[str], dict[str, Callable]]:
     tool_definitions = []
     context = {}
-    
+
     # Pre-allocate lists for better performance
     tool_definitions = [None] * len(tools)
-    
+
     for i, tool in enumerate(tools):
         tool_name = tool.__name__
         cleaned_docstring = _clean_docstring(tool.__doc__)
-        
+
         # Pre-compute string parts to avoid repeated string operations
         async_prefix = "async " if inspect.iscoroutinefunction(tool) else ""
         signature = str(inspect.signature(tool))
-        
+
         tool_definitions[i] = f'''{async_prefix}def {tool_name} {signature}:
     """{cleaned_docstring}"""
     ...'''
         context[tool_name] = tool
-    
+
     return tool_definitions, context
 
 
@@ -231,7 +231,9 @@ def create_default_prompt(
                 plan = pb.get("plan")
                 code = pb.get("script")
                 if plan or code:
-                    system_prompt += "\n\nYou have been provided an existing agent plan and code for performing a task.:\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)

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/src/universal_mcp/agents/codeact0/sandbox.py

@@ -1,14 +1,14 @@
+import ast
 import contextlib
 import inspect
 import io
+import pickle
 import queue
 import re
 import socket
 import threading
 import types
 from typing import Any
-import pickle
-import ast
 
 from langchain_core.tools import tool
 
@@ -40,12 +40,12 @@ async def eval_unsafe(
     )
 
     result_container = {"output": "<no output>"}
-    
+
     try:
         compiled_code = compile(code, "<string>", "exec", flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
         with contextlib.redirect_stdout(io.StringIO()) as f:
             coroutine = eval(compiled_code, _locals, _locals)
-             # Await the coroutine to run the code if it's async
+            # Await the coroutine to run the code if it's async
             if coroutine:
                 await coroutine
         result_container["output"] = f.getvalue() or "<code ran, no output printed to stdout>"

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/src/universal_mcp/agents/codeact0/tools.py

@@ -1,11 +1,15 @@
 import asyncio
+import base64
 import json
 from collections import defaultdict
+from pathlib import Path
 from typing import Annotated, Any
 
 from langchain_core.tools import tool
 from pydantic import Field
+from universal_mcp.agentr.client import AgentrClient
 from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.applications.markitdown.app import MarkitdownApp
 from universal_mcp.types import ToolFormat
 
 from universal_mcp.agents.codeact0.prompts import build_tool_definitions
@@ -192,8 +196,10 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             )
 
         result_parts.append("Call load_functions to select the required functions only.")
-        if len(connected_apps_in_results)<len(apps_in_results) and len(connected_apps_in_results)>0:
-            result_parts.append("Unconnected app functions can also be loaded if required by the user, but prefer connected ones. And do ask the user to choose if none of the relevant apps are connected")
+        if len(connected_apps_in_results) < len(apps_in_results) and len(connected_apps_in_results) > 0:
+            result_parts.append(
+                "Unconnected app functions can also be loaded if required by the user, but prefer connected ones. And do ask the user to choose if none of the relevant apps are connected"
+            )
         return "\n".join(result_parts)
 
     @tool
@@ -263,7 +269,95 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             "citations": response.get("citations", []),
         }
 
-    return {"search_functions": search_functions, "load_functions": load_functions, "web_search": web_search}
+    async def read_file(uri: str) -> str:
+        """
+        Asynchronously reads a local file or uri and returns the content as a markdown string.
+
+        This tool aims to extract the main text content from various sources.
+        It automatically prepends 'file://' to the input string if it appears
+        to be a local path without a specified scheme (like http, https, data, file).
+
+        Args:
+            uri (str): The URI pointing to the resource or a local file path.
+                       Supported schemes:
+                       - http:// or https:// (Web pages, feeds, APIs)
+                       - file:// (Local or accessible network files)
+                       - data: (Embedded data)
+
+        Returns:
+            A string containing the markdown representation of the content at the specified URI
+
+        Raises:
+            ValueError: If the URI is invalid, empty, or uses an unsupported scheme
+                        after automatic prefixing.
+
+        Tags:
+            convert, markdown, async, uri, transform, document, important
+        """
+        markitdown = MarkitdownApp()
+        response = await markitdown.convert_to_markdown(uri)
+        return response
+
+    async def save_file(file_name: str, content: str) -> dict:
+        """
+        Saves a file to the local filesystem.
+
+        Args:
+            file_name (str): The name of the file to save.
+            content (str): The content to save to the file.
+
+        Returns:
+            dict: A dictionary containing the result of the save operation with the following fields:
+                - status (str): "success" if the save succeeded, "error" otherwise.
+                - message (str): A message returned by the server, typically indicating success or providing error details.
+        """
+        with Path(file_name).open("w") as f:
+            f.write(content)
+
+        return {
+            "status": "success",
+            "message": f"File {file_name} saved successfully",
+            "file_path": Path(file_name).absolute(),
+        }
+
+    async def upload_file(file_name: str, mime_type: str, base64_data: str) -> dict:
+        """
+        Uploads a file to the server via the AgentrClient.
+
+        Args:
+            file_name (str): The name of the file to upload.
+            mime_type (str): The MIME type of the file.
+            base64_data (str): The file content encoded as a base64 string.
+
+        Returns:
+            dict: A dictionary containing the result of the upload operation with the following fields:
+                - status (str): "success" if the upload succeeded, "error" otherwise.
+                - message (str): A message returned by the server, typically indicating success or providing error details.
+                - signed_url (str or None): The signed URL to access the uploaded file if successful, None otherwise.
+        """
+        client: AgentrClient = tool_registry.client
+        bytes_data = base64.b64decode(base64_data)
+        response = client._upload_file(file_name, mime_type, bytes_data)
+        if response.get("status") != "success":
+            return {
+                "status": "error",
+                "message": response.get("message"),
+                "signed_url": None,
+            }
+        return {
+            "status": "success",
+            "message": response.get("message"),
+            "signed_url": response.get("signed_url"),
+        }
+
+    return {
+        "search_functions": search_functions,
+        "load_functions": load_functions,
+        "web_search": web_search,
+        "read_file": read_file,
+        "upload_file": upload_file,
+        "save_file": save_file,
+    }
 
 
 async def get_valid_tools(tool_ids: list[str], registry: AgentrRegistry) -> tuple[list[str], list[str]]:

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/src/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 AIMessage, ToolMessage, BaseMessage
+from langchain_core.messages import BaseMessage
 from universal_mcp.types import ToolConfig
 
 MAX_CHARS = 5000

{universal_mcp_agents-0.1.23rc7 → universal_mcp_agents-0.1.23rc8}/src/universal_mcp/agents/sandbox.py

@@ -5,6 +5,7 @@ import io
 import traceback
 
 import cloudpickle as pickle
+from loguru import logger
 
 
 class Sandbox:
@@ -26,17 +27,37 @@ class Sandbox:
     def save_context(self) -> str:
         """
         Saves the context to a base64 string.
+        files, IO, threads, etc. are not pickable. So we only pickle the context that is pickable.
         """
-        pickled_data = pickle.dumps(self.context)
+        pickable_context = {}
+        for key, value in self.context.items():
+            try:
+                pickle.dumps(value)
+                pickable_context[key] = value
+            except Exception as e:
+                logger.error(f"Error picking {key}: {e}")
+        pickled_data = pickle.dumps(pickable_context)
         base64_encoded = base64.b64encode(pickled_data).decode("utf-8")
         return base64_encoded
 
-    def load_context(self, context: str):
+    def load_context(self, context: str, add_context: list[str] = []):
         """
         Loads the context from a base64 string.
+        Also executes the add_context code strings to add to the context.
         """
-        pickled_data = base64.b64decode(context)
-        self.context = pickle.loads(pickled_data)
+        if context:
+            pickled_data = base64.b64decode(context)
+            new_context = pickle.loads(pickled_data)
+            self.context.update(new_context)
+        for code in add_context:
+            self.run(code)
+        return self.context
+
+    def _filter_context(self, context: dict[str, any]) -> dict[str, any]:
+        """
+        Filters the context to only include pickable variables.
+        """
+        return {k: v for k, v in context.items() if not k.startswith("__")}
 
     def run(self, code: str) -> dict[str, any]:
         """
@@ -64,7 +85,7 @@ class Sandbox:
 
             # 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("__")}
+            new_context = self._filter_context(exec_scope)
             self.context.update(new_context)
 
         except Exception:
@@ -114,8 +135,9 @@ class Sandbox:
                     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)
+            new_context = self._filter_context(exec_scope)
+            if new_context:
+                self.context.update(new_context)
 
         except Exception:
             stderr_output = traceback.format_exc()