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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.23rc6
+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.23rc6 → 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-rc6"
+version = "0.1.23-rc8"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{universal_mcp_agents-0.1.23rc6 → 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.23rc6 → 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,6 +18,7 @@ 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,
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
@@ -27,7 +27,7 @@ from universal_mcp.agents.codeact0.tools import (
     create_meta_tools,
     enter_agent_builder_mode,
 )
-from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string, create_agent_call
+from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string
 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
 
@@ -52,12 +52,11 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.agent_builder_model_instance = load_chat_model("azure/gpt-4.1")
+        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
@@ -66,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."""
@@ -215,7 +216,7 @@ class CodeActPlaybookAgent(BaseAgent):
             if agent_builder_mode == "planning":
                 plan_id = str(uuid.uuid4())
                 writer({"type": "custom", id: plan_id, "name": "planning", "data": {"update": bool(self.agent)}})
-                planning_instructions = self.instructions + AGENT_BUILDER_PLANNING_PROMPT
+                planning_instructions = self.instructions + AGENT_BUILDER_PLANNING_PROMPT + self.preloaded_defs
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
                 model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
@@ -225,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,
                     }
@@ -318,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
+                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(
@@ -358,8 +370,47 @@ class CodeActPlaybookAgent(BaseAgent):
                         instructions=instructions_payload,
                         tools=tool_dict,
                     )
-                except Exception as e:
-                    raise 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"}
+
+                    # Create a minimal assistant message to maintain flow
+                    mock_assistant_message = AIMessage(
+                        content=json.dumps(response.model_dump()),
+                        tool_calls=[mock_exit_tool_call],
+                        additional_kwargs={
+                            "type": "generating",
+                            "id": "ignore",
+                            "update": bool(self.agent),
+                            "name": final_name.replace(" ", "_"),
+                            "description": final_description,
+                        },
+                    )
+                    mock_exit_tool_response = ToolMessage(
+                        content=json.dumps(
+                            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",
+                    )
+                    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",
+                        }
+                    )
 
                 writer(
                     {
@@ -374,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],
@@ -390,33 +437,50 @@ 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"""
-            await self.registry.load_tools(state["selected_tool_ids"])
-            all_tools = await self.registry.export_tools(format=ToolFormat.NATIVE)
+            pre_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(
-                all_tools,
+                pre_tools,
                 self.additional_tools,
                 self.instructions,
                 await get_connected_apps_string(self.registry),
                 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})
+            self.preloaded_defs, _ = build_tool_definitions(pre_tools)
+            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
+            _, 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 state.get("agent_builder_mode") in ["planning", "confirming", "generating"]:
                 return Command(goto="agent_builder")

{universal_mcp_agents-0.1.23rc6 → 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.
 
@@ -25,7 +23,6 @@ Your job is to answer the user's question or perform the task they ask for.
 - 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.
-- Always use `await` when calling an async function. Since this is a Jupyter/async environment, you must not use asyncio.run().
 
 **Coding Best Practices:**
 - Variables defined at the top level of previous code snippets can be referenced in your code.
@@ -35,49 +32,98 @@ Your job is to answer the user's question or perform the task they ask for.
 - You can only import libraries that come pre-installed with Python. However, do consider searching for external functions first, using the search and load tools to access them in the code.
 - For displaying final results to the user, you must present your output in markdown format, including image links, so that they are rendered and displayed to the user. The code output is NOT visible to the user.
 - Call all functions using keyword arguments only, never positional arguments.
-
+- NEVER use execute_ipython_cell for:
+    - Static analysis or commentary
+    - Text that could be written as markdown
+    - Final output summarization after analysis
+    - Anything that's just formatted print statements
 
 **Final Output Requirements:**
-- Once you have all the information about the task, return the text directly to user in markdown format. No need to call `execute_ipython_cell` again.
+- Once you have all the information about the task, return the text directly to user in markdown format. Do NOT call `execute_ipython_cell` again just for summarization.
 - 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 = """Now, you are tasked with creating a reusable agent from the user's previous workflow.
+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.
+Rules:
+- Do NOT include the searching and loading of functions. Assume that the functions have already been loaded.
+- The plan is a sequence of steps corresponding to the key logical steps taken to achieve the user's task in the conversation history, without focusing on technical specifics.
+- 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.
+- Identify user-provided information as variables that should become the main agent input parameters using `variable_name` syntax, enclosed by backticks `...`. Intermediate variables should be highlighted using italics, i.e. *...*, NEVER `...`
+- Keep the logic generic and reusable. Avoid hardcoding any names/constants. Instead, keep them as variables with defaults. They should be represented as `variable_name(default = default_value)`.
+- Have a human-friendly plan and inputs format. That is, it must not use internal IDs or keys used by APIs as either inputs or outputs to the overall plan; using them internally is okay.
+- Be as concise as possible, especially for internal processing steps.
+- For steps where the assistant's intelligence was used outside of the code to infer/decide/analyse something, replace it with the use of *llm__* functions in the plan if required.
+
+Example Conversation History:
+User Message: "Create an image using Gemini for Marvel Cinematic Universe in comic style"
+Code snippet: image_result = await google_gemini__generate_image(prompt=prompt)
+Assistant Message: "The image has been successfully generated [image_result]."
+User Message: "Save the image in my OneDrive"
+Code snippet: image_data = base64.b64decode(image_result['data'])
+    temp_file_path = tempfile.mktemp(suffix='.png')
+    with open(temp_file_path, 'wb') as f:
+        f.write(image_data)
+    # Upload the image to OneDrive with a descriptive filename
+    onedrive_filename = "Marvel_Cinematic_Universe_Comic_Style.png"
+
+    print(f"Uploading to OneDrive as: {onedrive_filename}")
+
+    # Upload to OneDrive root folder
+    upload_result = onedrive__upload_file(
+        file_path=temp_file_path,
+        parent_id='root',
+        file_name=onedrive_filename
+    )
+
+Generated Steps:
+"steps": [
+    "Generate an image using Gemini model with `image_prompt` and `style(default = 'comic')`",
+    "Upload the obtained image to OneDrive using `onedrive_filename(default = 'generated_image.png')` and `onedrive_parent_folder(default = 'root')`",
+    "Return confirmation of upload including file name and destination path, and link to the upload"
+  ]
+Note that internal variables like upload_result, image_result are not highlighted in the plan, and intermediate processing details are skipped.
+Now create a plan based on the conversation history. Do not include any other text or explanation in your response. Just the JSON object.
+Note that the following tools are pre-loaded for the agent's use, and can be inluded in your plan if needed as internal variables (especially the llm tools)-\n
+"""
 
-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 agent.
 
-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 MUST not be highlighted using ``
-3. Keep the logic generic and reusable
-4. Be clear and concise
+AGENT_BUILDER_GENERATING_PROMPT = """
+You are tasked with generating a reusable agent function based on the final confirmed agent plan and preceding conversation history including user messages, assistant messages, and code executions.
+Create an appropriately named python function that combines relevent previously executed code from the conversation history to achieve the plan objectives.
+Rules-
+- Do NOT include the searching and loading of functions. Assume that the functions have already been loaded. Imports should be included.
+- Your response must be **ONLY Python code** for the function.
+- 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**.
+- Ensure that the outer function is self-contained and can run independently, based on previously validated code snippets.
 
 Example:
-{
-    "steps": [
-        "Connect to database using `db_connection_string`",
-        "Query user data for `user_id`",
-        "Process results and calculate `metric_name`",
-        "Send notification to `email_address`"
-    ]
-}
 
-Now create a plan based on the conversation history. Do not include any other text or explanation in your response. Just the JSON object.
-"""
+If the plan has:
+
+"steps": [
+"Receive creative description as image_prompt",
+"Generate image using Gemini with style(default = 'comic')",
+"Save temporary image internally as *temp_file_path*",
+"Upload *temp_file_path* to OneDrive folder onedrive_parent_folder(default = 'root')"
+]
+
+Then the function signature should be:
+
+```python
+def image_generator(image_prompt, style="comic", onedrive_parent_folder="root"):
+    #Code based on previously executed snippets
+
+And all internal variables (e.g., *temp_file_path*) should be defined inside the 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 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.
+Use this convention consistently to generate the final agent function.
+Note that the following tools are pre-loaded for the agent's use, and can be included in your code-\n
 """
 
 
@@ -114,17 +160,40 @@ def make_safe_function_name(name: str) -> str:
     return safe_name
 
 
+# Compile regex once for better performance
+_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)
+    return cleaned.strip()
+
+
 def build_tool_definitions(tools: list[Callable]) -> tuple[list[str], dict[str, Callable]]:
     tool_definitions = []
     context = {}
-    for tool in tools:
+
+    # Pre-allocate lists for better performance
+    tool_definitions = [None] * len(tools)
+
+    for i, tool in enumerate(tools):
         tool_name = tool.__name__
-        tool_definitions.append(
-            f'''{"async " if inspect.iscoroutinefunction(tool) else ""}def {tool_name} {str(inspect.signature(tool))}:
-    """{tool.__doc__}"""
+        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
 
 
@@ -139,7 +208,7 @@ def create_default_prompt(
     if is_initial_prompt:
         system_prompt = uneditable_prompt.strip()
         if apps_string:
-            system_prompt += f"\n\n**Connected external applications (These apps have been logged into by the user):**\n{apps_string}\n\n Use `search_functions` to search for functions you can perform using the above. You can also discover more applications using the `search_functions` tool to find additional tools and integrations, if required.\n"
+            system_prompt += f"\n\n**Connected external applications (These apps have been logged into by the user):**\n{apps_string}\n\n Use `search_functions` to search for functions you can perform using the above. You can also discover more applications using the `search_functions` tool to find additional tools and integrations, if required. However, you MUST not assume the application when multiple apps are connected for a particular usecase.\n"
         system_prompt += (
             "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
         )
@@ -162,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.23rc6 → 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>"