universal-mcp-agents 0.1.23__py3-none-any.whl → 0.1.24rc3__py3-none-any.whl

universal_mcp/agents/__init__.py

@@ -6,19 +6,26 @@ from universal_mcp.agents.builder.builder import BuilderAgent
 from universal_mcp.agents.codeact0 import CodeActPlaybookAgent
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
+from universal_mcp.agents.codeact00 import CodeActPlaybookAgent as CodeAct00Agent
+from universal_mcp.agents.codeact01 import CodeActPlaybookAgent as CodeAct01Agent
 
 
 def get_agent(
-    agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-repl"],
+    agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-repl", "codeact-00", "codeact-01"],
 ):
+    print("agent_name", agent_name)
     if agent_name == "react":
         return ReactAgent
     elif agent_name == "simple":
         return SimpleAgent
     elif agent_name == "codeact-repl":
         return CodeActPlaybookAgent
+    elif agent_name == "codeact-00":
+        return CodeAct00Agent
+    elif agent_name == "codeact-01":
+        return CodeAct01Agent
     else:
-        raise ValueError(f"Unknown agent: {agent_name}. Possible values:  react, simple, codeact-repl")
+        raise ValueError(f"Unknown agent: {agent_name}. Possible values:  react, simple, codeact-repl, codeact-00, codeact-01")
 
 
 __all__ = [
@@ -29,4 +36,6 @@ __all__ = [
     "BigToolAgent",
     "CodeActScript",
     "CodeActRepl",
+    "CodeAct00Agent",
+    "CodeAct01Agent",
 ]

universal_mcp/agents/base.py

@@ -67,13 +67,10 @@ class BaseAgent:
             ):
                 if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:  # noqa: PLR2004
                     payload, meta_dict = meta
-                    if meta_dict.get("tags") and "quiet" in meta_dict.get("tags"):
+                    metadata = getattr(payload, "metadata", {}) or {}
+                    if metadata and "quiet" in metadata.get("tags"):
                         continue
-                    is_agent_builder = (
-                        isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "agent_builder"
-                    )
-                    additional_kwargs = getattr(payload, "additional_kwargs", {}) or {}
-                    if is_agent_builder and not additional_kwargs.get("stream"):
+                    if meta_dict.get("tags") and "quiet" in meta_dict.get("tags"):
                         continue
                     if isinstance(payload, AIMessageChunk):
                         last_ai_chunk = payload

universal_mcp/agents/codeact0/agent.py

@@ -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, strip_thinking
+from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string, strip_thinking, extract_plan_parameters
 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
 
@@ -349,16 +349,23 @@ class CodeActPlaybookAgent(BaseAgent):
                 # Use generated metadata if available
                 final_name = state.get("agent_name") or function_name
                 final_description = state.get("agent_description") or f"Generated agent: {function_name}"
+                add_context = state.get("add_context", {})
+                if "functions" not in add_context:
+                    add_context["functions"] = []
+                add_context["functions"].append(func_code)
 
                 # Save or update an Agent using the helper registry
                 try:
                     if not self.agent_builder_registry:
                         raise ValueError("AgentBuilder registry is not configured")
 
+                    plan_params = extract_plan_parameters(state["plan"])
+                    
                     # Build instructions payload embedding the plan and function code
                     instructions_payload = {
                         "plan": state["plan"],
                         "script": func_code,
+                        "params": plan_params,
                     }
 
                     # Convert tool ids list to dict
@@ -395,22 +402,10 @@ class CodeActPlaybookAgent(BaseAgent):
                         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",
-                        }
-                    )
+                        human_msg = HumanMessage(content="Call the generated agent function (without redeclaring it) 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", "add_context": add_context})
+                    else:
+                        return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "agent_builder_mode": "normal", "add_context": add_context})
 
                 writer(
                     {
@@ -422,6 +417,7 @@ class CodeActPlaybookAgent(BaseAgent):
                             "update": bool(self.agent),
                             "name": final_name,
                             "description": final_description,
+                            "add_context": add_context,
                         },
                     }
                 )
@@ -450,6 +446,7 @@ class CodeActPlaybookAgent(BaseAgent):
                     update={
                         "messages": [mock_assistant_message, mock_exit_tool_response],
                         "agent_builder_mode": "normal",
+                        "add_context": add_context,
                     }
                 )
 

universal_mcp/agents/codeact0/prompts.py

@@ -9,7 +9,6 @@ Your job is to answer the user's question or perform the task they ask for.
 - Answer simple questions (which do not require you to write any code or access any external resources) directly. Note that any operation that involves using ONLY print functions should be answered directly in the chat. NEVER write a string or sequences of strings yourself and print it.
 - For task requiring operations or access to external resources, you should achieve the task by executing Python code snippets.
 - You have access to `execute_ipython_cell` tool that allows you to execute Python code in an IPython notebook cell.
-- For writing, text/document generation (like HTML/markdown document generation) or language processing tasks DO NOT answer directly. Instead you MUST use `execute_ipython_cell` tool with the llm functions provided to you for tasks like summarizing, text generation, classification, data extraction from text or unstructured data, etc. Avoid hardcoded approaches to classification, data extraction, or creative writing.
 - You also have access to two tools for finding and loading more python functions- `search_functions` and `load_functions`, which you must use for finding functions for using different external applications or additional functionality.
     - Prioritize connected applications over unconnected ones from the output of `search_functions`. However, if the user specifically asks for an application, you MUST use that irrespective of connection status.
     - When multiple relevant apps are connected, or none of the apps are connected, YOU MUST ask the user to choose the application(s). The search results may also inform you when such a case occurs, and you must stop and ask the user if multiple apps are relevant.
@@ -19,6 +18,7 @@ Your job is to answer the user's question or perform the task they ask for.
 - Structure your code into multiple small, well-defined functions within a single execution snippet. This ensures modularity and makes it easier to debug or update specific logic without rewriting or re-executing large portions of code. You can only rewrite the function/portion that you need to edit since the others are retained in context.
 - Every snippet you execute using `execute_ipython_cell` MUST follow this structure:
     - Break down logic into 3-5 small helper functions (30 lines each max)
+    - For definining large constants (multiline strings, dictionaries, etc) do it either at the global level or in a separate helper function responsible only for defining the object. Ensures that you do not have to rewrite large parts of the code multiple times during debugging/modifying.
     - Each helper function should do ONE thing
     - Example:
         def _helper_function_1(...):
@@ -38,7 +38,7 @@ Your job is to answer the user's question or perform the task they ask for.
 **Code Writing Rules:**
 - The code you write will be executed in a sandbox environment, and you can use the output of previous executions in your code. Variables, defined functions, imports, loaded functions are retained.
 - DO NOT use the code execution to communicate/show anything to the user. The user is not able to see the output of the code cells, it is only for your processing and actions. Similarly, you should only use print/smart_print for your own analysis, the user does not get the output.
-- Whenever you need to generate a large body of text, such as a document, an HTML file, or a report, use llm functions and save the output file using save/upload functions. Do not generate text yourself and do not print the entire text in order to save your memory.
+- Whenever you need to generate a large body of text, such as a document, an HTML file, or a report, use llm functions (see critical section below on LLM functions) and save the output file using save/upload functions. Do not generate text yourself and do not print the entire text in order to save your memory.
 - External functions which return a dict or list[dict] are ambiguous. Therefore, you MUST explore the structure of the returned data using `smart_print()` statements before using it, printing keys and values. `smart_print` truncates long strings from data, preventing huge output logs.
 - When an operation involves running a fixed set of steps on a list of items, run one run correctly and then use a for loop to run the steps on each item in the list.
 - 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.
@@ -50,12 +50,17 @@ Your job is to answer the user's question or perform the task they ask for.
     - Final output summarization after analysis
     - Anything that's just formatted print statements
 
+**Critical:LLM Function Usage Rules:**
+- For text creation or document generation (e.g., HTML, Markdown, textual content for document/email), do not respond directly; you must use execute_ipython_cell with llm__generate_text.
+- For any data extraction, text analysis, or classification task, always use the LLM functions (llm__extract_data, llm__classify_data, or llm__call_llm)-never rely on regex, manual parsing, or heuristic methods.
+- Use llm__call_llm only as a fallback when the other functions don't match the task exactly.
+
 **Final Output Requirements:**
 - Once you have all the information about the task, return the text directly to user in markdown format. Do NOT call `execute_ipython_cell` or any LLM tools again just for summarization. Do NOT use llm__generate_text for this purpose.
 - 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.
+- 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/path 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.
@@ -115,6 +120,7 @@ Rules-
   2) One top-level orchestrator function that calls the step functions in sequence to achieve the plan objectives.
 - The orchestrator function's parameters **must exactly match the external variables** in the agent plan (the ones marked with backticks `` `variable_name` ``). Provide defaults exactly as specified in the plan when present. Variables in italics (i.e. enclosed in *...*) are internal and must not be orchestrator parameters.
 - The orchestrator function MUST be declared with `def` or `async def` and be directly runnable with a single Python command (e.g., `image_generator(...)`). If it is async, assume the caller will `await` it.
+- NEVER use asyncio or asyncio.run(). The code is executed in a ipython environment, so using await is enough.
 - Step functions should accept only the inputs they need, return explicit outputs, and pass intermediate results forward via return values—not globals.
 - Name functions in snake_case derived from their purpose/step. Use keyword arguments in calls; avoid positional-only calls.
 - Keep the code self-contained and executable. Put imports at the top of the code. Do not nest functions unless strictly necessary.

universal_mcp/agents/codeact0/sandbox.py

@@ -125,8 +125,8 @@ async def handle_execute_ipython_cell(
 
     Returns (output, new_context, new_add_context).
     """
-    add_context = inject_context(effective_previous_add_context, tools_context)
-    context = {**effective_existing_context, **add_context}
+    context = {**tools_context, **effective_existing_context}
+    context = inject_context(effective_previous_add_context, context)
     if inspect.iscoroutinefunction(eval_fn):
         output, new_context, new_add_context = await eval_fn(code, context, effective_previous_add_context, 180)
     else:

universal_mcp/agents/codeact0/tools.py

@@ -420,7 +420,7 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
 
     def upload_file(file_name: str, mime_type: str, base64_data: str) -> dict:
         """
-        Uploads a file to the server via the AgentrClient.
+        Uploads a file to the server.
 
         Args:
             file_name (str): The name of the file to upload.
@@ -503,7 +503,7 @@ async def get_valid_tools(tool_ids: list[str], registry: AgentrRegistry) -> tupl
             start = text.find(":") + 1
             end = text.find(". R", start)
             url = text[start:end].strip()
-            markdown_link = f"![Connect to {app.capitalize()}]({url})"
+            markdown_link = f"[Connect to {app.capitalize()}]({url})"
             unconnected_links.append(markdown_link)
         for tool_id, tool_name in tool_entries:
             if tool_name in available:

universal_mcp/agents/codeact0/utils.py

@@ -29,6 +29,7 @@ def build_anthropic_cache_message(text: str, role: str = "system", ttl: str = "1
         }
     ]
 
+
 def strip_thinking(messages: list[BaseMessage]):
     """Remove Anthropic 'thinking' segments from the most recent AIMessage in-place.
 
@@ -502,3 +503,50 @@ async def get_connected_apps_string(registry) -> str:
         return "\n".join(apps_list)
     except Exception:
         return "Unable to retrieve connected applications."
+
+def extract_plan_parameters(plan_steps: list[str]) -> list[dict[str, Any]]:
+    """
+    Extracts parameters from plan steps and formats them into a list of OpenAPI-like parameter objects.
+
+    Parses parameters enclosed in backticks, identifying their name, if they are required, and any default values.
+    e.g., `variable` -> {"name": "variable", "required": True}
+    e.g., `variable(default = 'value')` -> {"name": "variable", "required": False, "default": "value"}
+    """
+    parameters_map: dict[str, Any] = {}
+    # Regex to find anything inside backticks
+    outer_pattern = re.compile(r"`([^`]+)`")
+    # Regex to parse parameters with default values
+    inner_pattern = re.compile(r"^\s*(\w+)\s*\(\s*default\s*=\s*(.+)\s*\)\s*$")
+
+    for step in plan_steps:
+        matches = outer_pattern.findall(step)
+        for match in matches:
+            param_str = match.strip()
+            inner_match = inner_pattern.match(param_str)
+
+            if inner_match:
+                # Parameter with a default value
+                name, default_val_str = inner_match.groups()
+                default_value: Any
+                try:
+                    # Safely evaluate the default value (e.g., 'string', 123, True)
+                    default_value = ast.literal_eval(default_val_str)
+                except (ValueError, SyntaxError):
+                    # If it's not a valid literal, treat it as a string
+                    default_value = default_val_str
+                parameters_map[name] = {"required": False, "default": default_value}
+            else:
+                # Required parameter (no default value)
+                name = param_str
+                # Only set as required if it hasn't been defined with a default already
+                if name not in parameters_map:
+                    parameters_map[name] = {"required": True}
+
+    # Convert the map to the final list format
+    final_parameters = []
+    for name, details in sorted(parameters_map.items()):
+        param_obj = {"name": name}
+        param_obj.update(details)
+        final_parameters.append(param_obj)
+
+    return final_parameters

universal_mcp/agents/codeact00/__init__.py

@@ -0,0 +1,3 @@
+from .agent import CodeActPlaybookAgent
+
+__all__ = ["CodeActPlaybookAgent"]

universal_mcp/agents/codeact00/__main__.py

@@ -0,0 +1,26 @@
+import asyncio
+
+from langgraph.checkpoint.memory import MemorySaver
+from rich import print
+from universal_mcp.agentr.registry import AgentrRegistry
+
+from universal_mcp.agents.codeact00.agent import CodeActPlaybookAgent
+from universal_mcp.agents.utils import messages_to_list
+
+
+async def main():
+    memory = MemorySaver()
+    agent = CodeActPlaybookAgent(
+        name="CodeAct Agent",
+        instructions="Be very concise in your answers.",
+        model="azure/gpt-4.1",
+        registry=AgentrRegistry(),
+        memory=memory,
+    )
+    print("Starting agent...")
+    result = await agent.invoke(user_input="Check my google calendar and show my todays agenda")
+    print(messages_to_list(result["messages"]))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())