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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.23rc4
+Version: 0.1.23rc6
 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.23rc4 → universal_mcp_agents-0.1.23rc6}/pyproject.toml

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

{universal_mcp_agents-0.1.23rc4 → universal_mcp_agents-0.1.23rc6}/src/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-0.1.23rc4 → universal_mcp_agents-0.1.23rc6}/src/universal_mcp/agents/codeact0/prompts.py

@@ -25,6 +25,7 @@ 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,25 +36,6 @@ Your job is to answer the user's question or perform the task they ask for.
 - 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
 
 **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.
@@ -188,7 +170,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-0.1.23rc4 → universal_mcp_agents-0.1.23rc6}/src/universal_mcp/agents/codeact0/sandbox.py

@@ -7,13 +7,15 @@ import socket
 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]]:
     """
@@ -38,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:
@@ -65,7 +63,7 @@ def eval_unsafe(
     # Filter locals for picklable/storable variables
     all_vars = {}
     for key, value in _locals.items():
-        if key == "__builtins__":
+        if key.startswith("__"):
             continue
         if inspect.iscoroutine(value) or inspect.iscoroutinefunction(value):
             continue
@@ -74,7 +72,12 @@ def eval_unsafe(
         if isinstance(value, EXCLUDE_TYPES):
             continue
         if not callable(value) or not hasattr(value, "__name__"):
-            all_vars[key] = value
+            # Only keep if it can be pickled (serialized) successfully
+            try:
+                pickle.dumps(value)
+                all_vars[key] = value
+            except Exception:
+                pass
 
     # Safely derive context
     try:

{universal_mcp_agents-0.1.23rc4 → universal_mcp_agents-0.1.23rc6}/src/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,