universal-mcp-agents 0.1.23rc6__py3-none-any.whl → 0.1.23rc8__py3-none-any.whl

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/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/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/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/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,9 +196,11 @@ 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):
-            result_parts.append("Unconnected app functions can also be loaded if required by the user, but prefer connected ones.")
-        return " ".join(result_parts)
+        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
     async def load_functions(tool_ids: list[str]) -> str:
@@ -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/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
@@ -452,78 +452,3 @@ 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/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()

universal_mcp/applications/llm/app.py

@@ -1,7 +1,6 @@
 import json
 from typing import Any, Literal, cast
 
-from langchain.chat_models import init_chat_model
 from pydantic import BaseModel, Field
 from universal_mcp.applications.application import BaseApplication
 
@@ -38,7 +37,7 @@ class LlmApp(BaseApplication):
         """Initialize the LLMApp."""
         super().__init__(name="llm")
 
-    def generate_text(
+    async def generate_text(
         self,
         task: str,
         context: str | list[str] | dict[str, str] = "",
@@ -92,10 +91,10 @@ class LlmApp(BaseApplication):
         full_prompt = f"{prompt}\n\nContext:\n{context_str}\n\n"
 
         model = load_chat_model("azure/gpt-5-mini")
-        response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(full_prompt)
+        response = await model.with_retry(stop_after_attempt=MAX_RETRIES).ainvoke(full_prompt)
         return str(response.content)
 
-    def classify_data(
+    async def classify_data(
         self,
         classification_task_and_requirements: str,
         context: Any | list[Any] | dict[str, Any],
@@ -154,7 +153,7 @@ class LlmApp(BaseApplication):
             "Return ONLY a valid JSON object, no extra text."
         )
 
-        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+        model = load_chat_model("azure/gpt-5-mini", temperature=0)
 
         class ClassificationResult(BaseModel):
             probabilities: dict[str, float] = Field(..., description="The probabilities for each class.")
@@ -162,13 +161,13 @@ class LlmApp(BaseApplication):
             top_class: str = Field(..., description="The class with the highest probability.")
 
         response = (
-            model.with_structured_output(schema=ClassificationResult)
+            await model.with_structured_output(schema=ClassificationResult)
             .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+            .ainvoke(prompt)
         )
         return response.model_dump()
 
-    def extract_data(
+    async def extract_data(
         self,
         extraction_task: str,
         source: Any | list[Any] | dict[str, Any],
@@ -229,16 +228,16 @@ class LlmApp(BaseApplication):
             "Return ONLY a valid JSON object that conforms to the provided schema, with no extra text."
         )
 
-        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+        model = load_chat_model("azure/gpt-5-mini", temperature=0)
 
-        response = (
+        response = await (
             model.with_structured_output(schema=output_schema, method="json_mode")
             .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+            .ainvoke(prompt)
         )
         return cast(dict[str, Any], response)
 
-    def call_llm(
+    async def call_llm(
         self,
         task_instructions: str,
         context: Any | list[Any] | dict[str, Any],
@@ -282,14 +281,14 @@ class LlmApp(BaseApplication):
 
         prompt = f"{task_instructions}\n\nContext:\n{context_str}\n\nReturn ONLY a valid JSON object, no extra text."
 
-        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+        model = load_chat_model("azure/gpt-5-mini", temperature=0)
 
-        response = (
-            model.with_structured_output(schema=output_schema, method="json_mode")
+        response = await (
+            model.with_structured_output(schema=output_schema)
             .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+            .ainvoke(prompt)
         )
-        return cast(dict[str, Any], response)
+        return response.model_dump()
 
     def list_tools(self):
         return [

{universal_mcp_agents-0.1.23rc6.dist-info → universal_mcp_agents-0.1.23rc8.dist-info}/METADATA

@@ -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.dist-info → universal_mcp_agents-0.1.23rc8.dist-info}/RECORD

@@ -1,10 +1,10 @@
 universal_mcp/agents/__init__.py,sha256=Ythw8tyq7p-w1SPnuO2JtS4TvYEP75PkQpdyvZv-ww4,914
-universal_mcp/agents/base.py,sha256=pnPf5EgVVoycg_mrgdIwqEiENny1Dcx6GDZWmOVw2NU,7837
+universal_mcp/agents/base.py,sha256=IyU1HUmB8rjHuCxv-c29RV-dWXfdiQiPq5rGkcCiSbU,7833
 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=ocYm94HOiJVI2zwTjO1K2PNfVY7EILLJ6cd__jnGHPs,3327
-universal_mcp/agents/sandbox.py,sha256=LL4OfavEzxbmTDcc_NxizRRpQnw5hc3G2bxvFY63scY,4241
+universal_mcp/agents/sandbox.py,sha256=YxTGp_zsajuN7FUn0Q4PFjuXczgLht7oKql_gyb2Gf4,5112
 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
@@ -22,23 +22,23 @@ universal_mcp/agents/builder/prompts.py,sha256=8Xs6uzTUHguDRngVMLak3lkXFkk2VV_uQ
 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=YyIoecUcKVUhTcCACzLlSmYrayMDsdwzDEqaV4VV4CE,766
-universal_mcp/agents/codeact0/agent.py,sha256=jaBntdEGydWI6OvRPpDsrLjnNncDdvQtjJbAgkeYp-U,20545
+universal_mcp/agents/codeact0/agent.py,sha256=CRgbKCBHSbMOpiNp_Sgdb-Wml7o9Uy72aA9_DaPNiJA,23449
 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=zMZyaIb_T1ssPASm6tnEvPSG8SkHm80aJcLzqcTicIk,11144
-universal_mcp/agents/codeact0/sandbox.py,sha256=FcJgJ64upa8NMcFDLXkT7FT69AQvUvPBiXyqW937AUo,4701
+universal_mcp/agents/codeact0/prompts.py,sha256=RiC_43GSeE4LDoiFhmJIOsKkoijOK9_7skwAH6ZqSWk,15501
+universal_mcp/agents/codeact0/sandbox.py,sha256=Zcr7fvYtcGbwNWd7RPV7-Btl2HtycPIPofEGVmzxSmE,4696
 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/codeact0/tools.py,sha256=kWFlEfJdbOPugPMbsP7I-vxFMGfZj3FUilMI-aT7-Xw,18753
+universal_mcp/agents/codeact0/utils.py,sha256=Gvft0W0Sg1qlFWm8ciX14yssCa8y3x037lql92yGsBQ,18164
 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
 universal_mcp/applications/filesystem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/applications/filesystem/app.py,sha256=0TRjjm8YnslVRSmfkXI7qQOAlqWlD1eEn8Jm0xBeigs,5561
 universal_mcp/applications/llm/__init__.py,sha256=_XGRxN3O1--ZS5joAsPf8IlI9Qa6negsJrwJ5VJXno0,46
-universal_mcp/applications/llm/app.py,sha256=4aMDlbBFCJIe_yzSq3Jphtk5ctvjWhHkHfSfnh3_Mso,12714
+universal_mcp/applications/llm/app.py,sha256=zcMCcswJxvbk2jN_x4xpiv2IG2yoJ62jH1CQaNltmYs,12645
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.23rc6.dist-info/METADATA,sha256=_BtR77yJ3U-Rtfl0JD6fpYJY8M5Q1TEgp_6M3AFT9dw,931
-universal_mcp_agents-0.1.23rc6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.23rc6.dist-info/RECORD,,
+universal_mcp_agents-0.1.23rc8.dist-info/METADATA,sha256=q1hNCeGDqDDTJ5TWkQkh8JuHoXyNgNZEbDOXViM-xM0,931
+universal_mcp_agents-0.1.23rc8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.23rc8.dist-info/RECORD,,