universal-mcp-agents 0.1.23rc5__py3-none-any.whl → 0.1.23rc7__py3-none-any.whl

universal_mcp/agents/base.py

@@ -1,13 +1,12 @@
-# agents/base.py
-from typing import cast
+from typing import Any, cast
 from uuid import uuid4
+import asyncio
 
 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
 
 
@@ -57,40 +56,48 @@ class BaseAgent:
         }
 
         last_ai_chunk = None
-        async for event, meta in self._graph.astream(
-            {"messages": [{"role": "user", "content": user_input}]},
-            config=run_config,
-            context={"system_prompt": self.instructions, "model": self.model},
-            stream_mode=["messages", "custom"],
-            stream_usage=True,
-        ):
-            if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:  # noqa: PLR2004
-                payload, meta_dict = meta
-                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"):
-                    continue
-                if isinstance(payload, AIMessageChunk):
-                    last_ai_chunk = payload
-                    aggregate = payload if aggregate is None else aggregate + payload
-                if "finish_reason" in payload.response_metadata:
-                    logger.debug(
-                        f"Finish event: {payload}, reason: {payload.response_metadata['finish_reason']}, Metadata: {meta_dict}"
+        try:
+            async for event, meta in self._graph.astream(
+                {"messages": [{"role": "user", "content": user_input}]},
+                config=run_config,
+                context={"system_prompt": self.instructions, "model": self.model},
+                stream_mode=["messages", "custom"],
+                stream_usage=True,
+            ):
+                if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:  # noqa: PLR2004
+                    payload, meta_dict = meta
+                    is_agent_builder = (
+                        isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "agent_builder"
                     )
-                    pass
-                logger.debug(f"Event: {payload}, Metadata: {meta_dict}")
-                yield payload
-
-            if event == "custom":
-                yield meta
-
-        # Send a final finished message if we saw any AI chunks (to carry usage)
-        if last_ai_chunk is not None and aggregate is not None:
-            event = cast(AIMessageChunk, last_ai_chunk)
-            event.usage_metadata = aggregate.usage_metadata
-            logger.debug(f"Usage metadata: {event.usage_metadata}")
-            event.content = ""  # Clear the message since it would have already been streamed above
-            yield event
+                    additional_kwargs = getattr(payload, "additional_kwargs", {}) or {}
+                    if is_agent_builder and not additional_kwargs.get("stream"):
+                        continue
+                    if isinstance(payload, AIMessageChunk):
+                        last_ai_chunk = payload
+                        aggregate = payload if aggregate is None else aggregate + payload
+                    if "finish_reason" in payload.response_metadata:
+                        logger.debug(
+                            f"Finish event: {payload}, reason: {payload.response_metadata['finish_reason']}, Metadata: {meta_dict}"
+                        )
+                        pass
+                    logger.debug(f"Event: {payload}, Metadata: {meta_dict}")
+                    yield payload
+
+                if event == "custom":
+                    yield meta
+
+        except asyncio.CancelledError:
+            logger.info(f"Stream for thread_id {thread_id} was cancelled by the user.")
+            # Perform any cleanup here if necessary
+        finally:
+            # This block will run whether the stream finished normally or was cancelled
+            # Send a final finished message if we saw any AI chunks (to carry usage)
+            if last_ai_chunk is not None and aggregate is not None:
+                event = cast(AIMessageChunk, last_ai_chunk)
+                event.usage_metadata = aggregate.usage_metadata
+                logger.debug(f"Usage metadata: {event.usage_metadata}")
+                event.content = ""  # Clear the message
+                yield event
 
     async def stream_interactive(self, thread_id: str, user_input: str):
         await self.ainit()

universal_mcp/agents/codeact0/agent.py

@@ -20,6 +20,7 @@ from universal_mcp.agents.codeact0.prompts import (
     AGENT_BUILDER_META_PROMPT,
     AGENT_BUILDER_PLANNING_PROMPT,
     create_default_prompt,
+    build_tool_definitions
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
 from universal_mcp.agents.codeact0.state import AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan, CodeActState
@@ -27,7 +28,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,7 +53,7 @@ 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", thinking = False)
         self.registry = registry
         self.agent_builder_registry = agent_builder_registry
         self.agent = agent_builder_registry.get_agent() if agent_builder_registry else None
@@ -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(
@@ -318,7 +319,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(
@@ -359,7 +360,34 @@ class CodeActPlaybookAgent(BaseAgent):
                         tools=tool_dict,
                     )
                 except Exception as e:
-                    raise e
+                    # 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"
+                    )
+                    return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "agent_builder_mode": "normal"})
 
                 writer(
                     {
@@ -401,18 +429,24 @@ class CodeActPlaybookAgent(BaseAgent):
 
         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,
             )
+            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]}

universal_mcp/agents/codeact0/prompts.py

@@ -34,68 +34,97 @@ 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.
-
-**Async Functions (Critical Rules):**
-Use async functions only as follows:
-- Case 1: Top-level await without asyncio.run()
-    Wrap in async function and call with asyncio.run():
-    ```python
-    async def main():
-        result = await some_async_function()
-        return result
-    asyncio.run(main())
-    ```
-- Case 2: Using asyncio.run() directly
-    If code already contains asyncio.run(), use as-is — do not wrap again:
-    ```python
-    asyncio.run(some_async_function())
-    ```
-Rules:
-- Never use await outside an async function
-- Never use await asyncio.run()
-- Never nest asyncio.run() calls
+- 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.
 """
 
-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')"
+]
 
-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.
+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.
+
+
+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
 """
 
 
@@ -132,17 +161,39 @@ 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
 
 
@@ -157,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"
         )
@@ -188,7 +239,7 @@ def create_default_prompt(
                             plan_block = str(plan)
                         system_prompt += f"Plan Steps:\n{plan_block}\n"
                     if code:
-                        system_prompt += f"\nScript:\n```python\n{str(code)}\n```\nThis function can be called by you using `execute_ipython_code`, either directly or using asyncio.run (if an async function). Do NOT redefine the function, unless it has to be modified. For modifying it, you must enter agent_builder mode first so that it is modified in the database and not just the chat locally."
+                        system_prompt += f"\nScript:\n```python\n{str(code)}\n```\nThis function can be called by you using `execute_ipython_code`. Do NOT redefine the function, unless it has to be modified. For modifying it, you must enter agent_builder mode first so that it is modified in the database and not just the chat locally."
         except Exception:
             # Silently ignore formatting issues
             pass

universal_mcp/agents/codeact0/sandbox.py

@@ -8,13 +8,14 @@ import threading
 import types
 from typing import Any
 import pickle
+import ast
 
 from langchain_core.tools import tool
 
 from universal_mcp.agents.codeact0.utils import derive_context, inject_context, smart_truncate
 
 
-def eval_unsafe(
+async def eval_unsafe(
     code: str, _locals: dict[str, Any], add_context: dict[str, Any], timeout: int = 180
 ) -> tuple[str, dict[str, Any], dict[str, Any]]:
     """
@@ -39,21 +40,17 @@ def eval_unsafe(
     )
 
     result_container = {"output": "<no output>"}
-
-    def target():
-        try:
-            with contextlib.redirect_stdout(io.StringIO()) as f:
-                exec(code, _locals, _locals)
-            result_container["output"] = f.getvalue() or "<code ran, no output printed to stdout>"
-        except Exception as e:
-            result_container["output"] = f"Error during execution: {type(e).__name__}: {e}"
-
-    thread = threading.Thread(target=target)
-    thread.start()
-    thread.join(timeout)
-
-    if thread.is_alive():
-        result_container["output"] = f"Code timeout: code execution exceeded {timeout} seconds."
+    
+    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
+            if coroutine:
+                await coroutine
+        result_container["output"] = f.getvalue() or "<code ran, no output printed to stdout>"
+    except Exception as e:
+        result_container["output"] = f"Error during execution: {type(e).__name__}: {e}"
 
     # If NameError for provider__tool occurred, append guidance (no retry)
     try:

universal_mcp/agents/codeact0/tools.py

@@ -192,9 +192,9 @@ 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:

universal_mcp/agents/codeact0/utils.py

@@ -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/applications/llm/app.py

@@ -166,7 +166,7 @@ class LlmApp(BaseApplication):
             .with_retry(stop_after_attempt=MAX_RETRIES)
             .invoke(prompt)
         )
-        return response.model_dump_json(indent=2)
+        return response.model_dump()
 
     def extract_data(
         self,

{universal_mcp_agents-0.1.23rc5.dist-info → universal_mcp_agents-0.1.23rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.23rc5
+Version: 0.1.23rc7
 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.23rc5.dist-info → universal_mcp_agents-0.1.23rc7.dist-info}/RECORD

@@ -1,5 +1,5 @@
 universal_mcp/agents/__init__.py,sha256=Ythw8tyq7p-w1SPnuO2JtS4TvYEP75PkQpdyvZv-ww4,914
-universal_mcp/agents/base.py,sha256=Sa3ws87OlMklXv9NAs_kXNAvP5DbaAUnFQbx1WqEStM,7410
+universal_mcp/agents/base.py,sha256=pnPf5EgVVoycg_mrgdIwqEiENny1Dcx6GDZWmOVw2NU,7837
 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
@@ -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=lixuPcFLEaWl3IgJ7pY9JSLz9UxH5t9F9FJVEIELydA,22507
 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=Zt0ea01ofz6oS7fgyGK2Q2zN9CNMHGubBdR54VgvKic,11684
-universal_mcp/agents/codeact0/sandbox.py,sha256=AYy512wsOKgh4nmXccEF0mntuXDBeHaccsz0aUSIQMI,4696
+universal_mcp/agents/codeact0/prompts.py,sha256=re1DHkfC6kyy1Y2pgmPLMZ_TceKZHZk-0-csCPHnQjw,15344
+universal_mcp/agents/codeact0/sandbox.py,sha256=FcJgJ64upa8NMcFDLXkT7FT69AQvUvPBiXyqW937AUo,4701
 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=e-ucTRkXuHEagEAWo2OPWh28UGeYlKzeNhi5cM7lqPc,15007
+universal_mcp/agents/codeact0/utils.py,sha256=a0ux1icTSB6ETIZ_X2azZxlP44LBx95bi7wchQWpnuY,18188
 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=g9mK-luOLUshZzBGyQZMOHBeCSXmh2kCKir40YnsGUo,12727
+universal_mcp/applications/llm/app.py,sha256=4aMDlbBFCJIe_yzSq3Jphtk5ctvjWhHkHfSfnh3_Mso,12714
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.23rc5.dist-info/METADATA,sha256=JN1atZb7RAGx_PCxS2MMWgRXQwkCHT1a-oi_2GzRDFA,931
-universal_mcp_agents-0.1.23rc5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.23rc5.dist-info/RECORD,,
+universal_mcp_agents-0.1.23rc7.dist-info/METADATA,sha256=Up-hGsxUw2JH3vSa9FipSTF45ROWOMiySV0DItN4Cx8,931
+universal_mcp_agents-0.1.23rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.23rc7.dist-info/RECORD,,