universal-mcp-agents 0.1.24rc1__tar.gz → 0.1.24rc2__tar.gz

{universal_mcp_agents-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.24rc1
+Version: 0.1.24rc2
 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.24rc1 → universal_mcp_agents-0.1.24rc2}/pyproject.toml

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

{universal_mcp_agents-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/src/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-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/src/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-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/src/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-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/src/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.

{universal_mcp_agents-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/src/universal_mcp/agents/codeact0/utils.py

@@ -503,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-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/src/universal_mcp/applications/llm/app.py

@@ -1,8 +1,8 @@
 import json
-from typing import Any, Literal, cast
+from typing import Any, Literal, cast, Optional, List
 
 from langchain.agents import create_agent
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, create_model
 from universal_mcp.applications.application import BaseApplication
 
 from universal_mcp.agents.llm import load_chat_model
@@ -10,6 +10,59 @@ from universal_mcp.agents.llm import load_chat_model
 MAX_RETRIES = 3
 
 
+def _pydantic_model_from_json_schema(schema: dict[str, Any]) -> type[BaseModel]:
+    """Create a Pydantic model from a JSON schema (subset support).
+
+    Supported keywords: type, properties, required, items, description, title.
+    """
+
+    def to_type(subschema: dict[str, Any]) -> Any:
+        stype = subschema.get("type")
+        if stype == "object" or (stype is None and "properties" in subschema):
+            title = subschema.get("title", "SubObject")
+            props: dict[str, dict[str, Any]] = subschema.get("properties", {})
+            required: list[str] = subschema.get("required", [])
+            fields: dict[str, tuple[Any, Any]] = {}
+            for name, prop_schema in props.items():
+                t = to_type(prop_schema)
+                if name in required:
+                    fields[name] = (t, ...)
+                else:
+                    fields[name] = (Optional[t], None)  # type: ignore[index]
+            return create_model(title, **fields)  # type: ignore[return-value]
+        if stype == "array":
+            item_schema = subschema.get("items", {"type": "string"})
+            return List[to_type(item_schema)]  # type: ignore[index]
+        if stype == "string":
+            return str
+        if stype == "integer":
+            return int
+        if stype == "number":
+            return float
+        if stype == "boolean":
+            return bool
+        if stype == "null":
+            return Optional[Any]
+        # Fallback to Any for unsupported/omitted types
+        return Any
+
+    title = schema.get("title", "Output")
+    if schema.get("type") == "object" or "properties" in schema:
+        props = schema.get("properties", {})
+        required = schema.get("required", [])
+        fields: dict[str, tuple[Any, Any]] = {}
+        for name, prop_schema in props.items():
+            t = to_type(prop_schema)
+            if name in required:
+                fields[name] = (t, ...)
+            else:
+                fields[name] = (Optional[t], None)  # type: ignore[index]
+        return create_model(title, **fields)  # type: ignore[return-value]
+    # Non-object root types
+    root_type = to_type(schema)
+    return create_model(title, __root__=(root_type, ...))  # type: ignore[return-value]
+
+
 def _get_context_as_string(source: Any | list[Any] | dict[str, Any]) -> str:
     """Converts context to a string representation.
 
@@ -231,12 +284,13 @@ class LlmApp(BaseApplication):
 
         model = load_chat_model("azure/gpt-5-mini", temperature=0, disable_streaming=True, tags=("quiet",))
 
+        PModel = _pydantic_model_from_json_schema(output_schema)
         response = (
-            model.with_structured_output(schema=output_schema, method="json_mode")
+            model.with_structured_output(PModel)
             .with_retry(stop_after_attempt=MAX_RETRIES)
             .invoke(prompt, stream=False)
         )
-        return cast(dict[str, Any], response)
+        return cast(dict[str, Any], response.model_dump())
 
     def call_llm(
         self,
@@ -284,13 +338,10 @@ class LlmApp(BaseApplication):
 
         model = load_chat_model("azure/gpt-5-mini", temperature=0, disable_streaming=True, tags=("quiet",))
 
-        agent = create_agent(
-            model=model,
-            tools=[],
-            response_format=output_schema,
-        )
-        result = agent.invoke({"messages": [{"role": "user", "content": prompt}]}, stream=False)
-        return result["structured_response"]
+        PModel = _pydantic_model_from_json_schema(output_schema)
+        model_with_structure = model.with_structured_output(PModel)
+        response = model_with_structure.with_retry(stop_after_attempt=MAX_RETRIES).invoke(prompt, stream=False)
+        return cast(dict[str, Any], response.model_dump())
 
     def list_tools(self):
         return [

{universal_mcp_agents-0.1.24rc1 → universal_mcp_agents-0.1.24rc2}/uv.lock

@@ -4902,7 +4902,7 @@ wheels = [
 
 [[package]]
 name = "universal-mcp-agents"
-version = "0.1.23"
+version = "0.1.24rc1"
 source = { editable = "." }
 dependencies = [
     { name = "cloudpickle" },