universal-mcp-agents 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

universal_mcp/agents/codeact0/utils.py

@@ -4,12 +4,82 @@ import re
 from collections.abc import Sequence
 from typing import Any
 
-from langchain_core.messages import BaseMessage
+from langchain_core.messages import AIMessage, BaseMessage
 from universal_mcp.types import ToolConfig
 
 MAX_CHARS = 5000
 
 
+def build_anthropic_cache_message(text: str, role: str = "system", ttl: str = "1h") -> list[dict[str, Any]]:
+    """Build a complete Anthropic cache messages array from text.
+
+    Returns a list with a single cache message whose content is the
+    cached Anthropic content array with ephemeral cache control and TTL.
+    """
+    return [
+        {
+            "role": role,
+            "content": [
+                {
+                    "type": "text",
+                    "text": text,
+                    "cache_control": {"type": "ephemeral", "ttl": ttl},
+                }
+            ],
+        }
+    ]
+
+def strip_thinking(messages: list[BaseMessage]):
+    """Remove Anthropic 'thinking' segments from the most recent AIMessage in-place.
+
+    Scans from the end to find the last AIMessage, then removes thinking blocks
+    from its content. Handles both plain-string and block-array content.
+    """
+    if not messages:
+        return messages
+
+    # Find the last AIMessage from the end
+    last_ai_index = None
+    for i in range(len(messages) - 1, -1, -1):
+        if isinstance(messages[i], AIMessage):
+            last_ai_index = i
+            break
+
+    if last_ai_index is None:
+        return messages
+
+    ai_msg = messages[last_ai_index]
+    content = ai_msg.content
+
+    # If it's already plain text, nothing to strip
+    if isinstance(content, str):
+        return messages
+
+    # If Anthropic-style content blocks
+    if isinstance(content, list):
+        filtered_output: list[object] = []
+        removed_any = False
+        for b in content:
+            is_thinking = False
+            if isinstance(b, dict):
+                t = b.get("type")
+                if t == "thinking":
+                    is_thinking = True
+                elif "thinking" in b and isinstance(b["thinking"], str):
+                    is_thinking = True
+
+            if is_thinking:
+                removed_any = True
+                continue
+            filtered_output.append(b)
+
+        if removed_any:
+            ai_msg.content = filtered_output
+            messages[last_ai_index] = ai_msg
+
+    return messages
+
+
 def add_tools(tool_config: ToolConfig, tools_to_add: ToolConfig):
     for app_id, new_tools in tools_to_add.items():
         all_tools = tool_config.get(app_id, []) + new_tools
@@ -333,31 +403,45 @@ def inject_context(
     return namespace
 
 
-def schema_to_signature(schema: dict, func_name="my_function") -> str:
+def schema_to_signature(schema: dict, func_name: str = "my_function") -> str:
+    """
+    Convert a JSON schema into a Python-style function signature string.
+    Handles fields with `type`, `anyOf`, defaults, and missing metadata safely.
+    """
     type_map = {
         "integer": "int",
         "string": "str",
         "boolean": "bool",
         "null": "None",
+        "number": "float",
+        "array": "list",
+        "object": "dict",
     }
 
     params = []
     for name, meta in schema.items():
-        # figure out type
-        if "type" in meta:
+        if not isinstance(meta, dict):
+            typ = "Any"
+        elif "type" in meta:
             typ = type_map.get(meta["type"], "Any")
         elif "anyOf" in meta:
-            types = [type_map.get(t["type"], "Any") for t in meta["anyOf"]]
-            typ = " | ".join(set(types))
+            types = []
+            for t in meta["anyOf"]:
+                if not isinstance(t, dict):
+                    continue
+                t_type = t.get("type")
+                types.append(type_map.get(t_type, "Any") if t_type else "Any")
+            typ = " | ".join(sorted(set(types))) if types else "Any"
         else:
             typ = "Any"
 
-        default = meta.get("default", None)
-        default_repr = repr(default)
-
-        params.append(f"{name}: {typ} = {default_repr}")
+        # Handle defaults gracefully
+        default = meta.get("default")
+        if default is None:
+            params.append(f"{name}: {typ}")
+        else:
+            params.append(f"{name}: {typ} = {repr(default)}")
 
-    # join into signature
     param_str = ",\n    ".join(params)
     return f"def {func_name}(\n    {param_str},\n):"
 
@@ -394,3 +478,27 @@ def smart_truncate(
         truncated = truncated[:summary_threshold] + "\n... [output truncated to fit context] ..."
 
     return truncated
+
+
+async def get_connected_apps_string(registry) -> str:
+    """Get a formatted string of connected applications from the registry."""
+    if not registry:
+        return ""
+
+    try:
+        # Get connected apps from registry
+        connections = await registry.list_connected_apps()
+        if not connections:
+            return "No applications are currently connected."
+
+        # Extract app names from connections
+        connected_app_ids = {connection["app_id"] for connection in connections}
+
+        # Format the apps list
+        apps_list = []
+        for app_id in connected_app_ids:
+            apps_list.append(f"- {app_id}")
+
+        return "\n".join(apps_list)
+    except Exception:
+        return "Unable to retrieve connected applications."

universal_mcp/agents/llm.py

@@ -4,26 +4,33 @@ from langchain_anthropic import ChatAnthropic
 from langchain_core.language_models import BaseChatModel
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_openai import AzureChatOpenAI
+from loguru import logger
 
 
 @lru_cache(maxsize=8)
 def load_chat_model(
-    fully_specified_name: str, temperature: float = 1.0, tags: list[str] | None = None, thinking: bool = True
+    fully_specified_name: str, temperature: float = 1.0, tags: tuple[str, ...] | None = None, thinking: bool = True, disable_streaming: bool = False
 ) -> BaseChatModel:
     """Load a chat model from a fully specified name.
     Args:
         fully_specified_name (str): String in the format 'provider/model'.
     """
     fully_specified_name = fully_specified_name.replace("/", ":")
+    if tags:
+        if isinstance(tags, str):
+            tags = [tags]
+        else:
+            tags = list[str](tags)
     provider, model = fully_specified_name.split(":", maxsplit=1)
     if provider == "anthropic":
         return ChatAnthropic(
             model=model,
             temperature=temperature,
             thinking={"type": "enabled", "budget_tokens": 2048} if thinking else None,
-            max_tokens=4096,
+            max_tokens=8096,
             tags=tags,
             stream_usage=True,
+            disable_streaming = disable_streaming
         )  # pyright: ignore[reportCallIssue]
     elif provider == "azure":
         return AzureChatOpenAI(
@@ -33,6 +40,7 @@ def load_chat_model(
             temperature=temperature,
             tags=tags,
             stream_usage=True,
+            disable_streaming = disable_streaming
         )
     elif provider == "gemini":
         return ChatGoogleGenerativeAI(model=model, temperature=temperature)
@@ -41,8 +49,6 @@ def load_chat_model(
 
 
 if __name__ == "__main__":
-    from loguru import logger
-
     models_to_test = [
         "azure/gpt-5-chat",
         "anthropic/claude-4-sonnet-20250514",

universal_mcp/agents/react.py

@@ -1,5 +1,5 @@
+from langchain.agents import create_agent
 from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.prebuilt import create_react_agent
 from loguru import logger
 from rich import print
 from universal_mcp.agentr.registry import AgentrRegistry
@@ -75,10 +75,10 @@ class ReactAgent(BaseAgent):
             tools = []
 
         logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
-        return create_react_agent(
+        return create_agent(
             self.llm,
             tools,
-            prompt=self._build_system_message(),
+            system_prompt=self._build_system_message(),
             checkpointer=self.memory,
         )
 

universal_mcp/agents/sandbox.py

@@ -1,90 +1,145 @@
+import ast
+import base64
 import contextlib
-import inspect
 import io
-import queue
-import re
-import socket
-import threading
-import types
-from typing import Any
+import traceback
 
-from universal_mcp.agents.codeact0.utils import derive_context
+import cloudpickle as pickle
+from loguru import logger
 
 
 class Sandbox:
     """
-    A class to execute code safely in a sandboxed environment with a timeout.
+    A simulated environment for executing Python code cells with context
+    maintained across multiple runs.
     """
 
-    def __init__(self, timeout: int = 180):
+    def __init__(self):
+        # Dictionary to store variables (context) across runs
+        self.context = {}
+
+    def add_context(self, context: dict[str, any]):
+        """
+        Adds a dictionary of context to the sandbox.
+        """
+        self.context.update(context)
+
+    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.
+        """
+        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, add_context: list[str] = []):
         """
-        Initializes the Sandbox.
+        Loads the context from a base64 string.
+        Also executes the add_context code strings to add to the context.
+        """
+        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]:
+        """
+        Executes the provided Python code string in the maintained context.
+
         Args:
-            timeout: The timeout for code execution in seconds.
+            code (str): The Python code to execute.
+
+        Returns:
+            dict: A dictionary containing the execution results.
         """
-        self.timeout = timeout
-        self._locals: dict[str, Any] = {}
-        self.add_context: dict[str, Any] = {}
+        # Prepare the execution environment:
+        # Use a copy of the context for execution locals/globals
+        exec_scope = self.context.copy()
+
+        stdout_capture = io.StringIO()
+        stderr_output = ""
 
-    def run(self, code: str) -> tuple[str, dict[str, Any], dict[str, Any]]:
+        # Use a true context manager for robust stdout capture
+        try:
+            with contextlib.redirect_stdout(stdout_capture):
+                # Execute the code. Using the same dictionary for globals and locals
+                # allows newly created variables to be visible immediately.
+                exec(code, exec_scope, exec_scope)
+
+            # Update the context with any new/modified variables
+            # Filter out dunder methods/system keys that might be introduced by exec
+            new_context = self._filter_context(exec_scope)
+            self.context.update(new_context)
+
+        except Exception:
+            # Capture the traceback for better error reporting (simulated stderr)
+            stderr_output = traceback.format_exc()
+
+            # The execution scope might contain partially defined variables,
+            # but we continue to maintain the *previous* valid context.
+            # We don't update self.context on failure to avoid polluting it.
+
+        return {"stdout": stdout_capture.getvalue(), "stderr": stderr_output, "success": stderr_output == ""}
+
+    def get_context(self) -> dict[str, any]:
         """
-        Execute code safely with a timeout.
-        - Returns (output_str, filtered_locals_dict, new_add_context)
-        - Errors or timeout are returned as output_str.
-        - Previous variables in _locals persist across calls.
+        Returns a copy of the current execution context.
+
+        Returns:
+            dict: A copy of the context dictionary.
         """
+        return self.context.copy()
 
-        EXCLUDE_TYPES = (
-            types.ModuleType,
-            type(re.match("", "")),
-            type(threading.Lock()),
-            type(threading.RLock()),
-            threading.Event,
-            threading.Condition,
-            threading.Semaphore,
-            queue.Queue,
-            socket.socket,
-            io.IOBase,
-        )
+    def reset(self):
+        """
+        Resets the sandbox's context, clearing all defined variables.
+        """
+        self.context = {}
 
-        result_container = {"output": "<no output>"}
+    async def arun(self, code: str) -> dict[str, any]:
+        """
+        Asynchronously executes Python code, supporting top-level await.
+        """
+        # Use a copy of the context for execution
+        exec_scope = self.context.copy()
+        stdout_capture = io.StringIO()
+        stderr_output = ""
 
-        def target():
-            try:
-                with contextlib.redirect_stdout(io.StringIO()) as f:
-                    exec(code, self._locals, self._locals)
-                result_container["output"] = f.getvalue() or "<code ran, no output printed to stdout>"
-            except Exception as e:
-                result_container["output"] = "Error during execution: " + str(e)
-
-        thread = threading.Thread(target=target)
-        thread.start()
-        thread.join(self.timeout)
-
-        if thread.is_alive():
-            result_container["output"] = f"Code timeout: code execution exceeded {self.timeout} seconds."
-
-        # Filter locals for picklable/storable variables
-        all_vars = {}
-        for key, value in self._locals.items():
-            if key == "__builtins__":
-                continue
-            if inspect.iscoroutine(value) or inspect.iscoroutinefunction(value):
-                continue
-            if inspect.isasyncgen(value) or inspect.isasyncgenfunction(value):
-                continue
-            if isinstance(value, EXCLUDE_TYPES):
-                continue
-            if not callable(value) or not hasattr(value, "__name__"):
-                all_vars[key] = value
-
-        self._locals = all_vars
-
-        # Safely derive context
         try:
-            self.add_context = derive_context(code, self.add_context)
+            # Compile the code with the special flag to allow top-level await
+            compiled_code = compile(code, "<string>", "exec", flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
+
+            with contextlib.redirect_stdout(stdout_capture):
+                # Eval the compiled code to get a coroutine
+                coroutine = eval(compiled_code, exec_scope, exec_scope)
+
+                # Await the coroutine to run the code if it's async
+                if coroutine:
+                    await coroutine
+
+            # Update the context with any new/modified variables
+            new_context = self._filter_context(exec_scope)
+            if new_context:
+                self.context.update(new_context)
+
         except Exception:
-            # Keep the old context if derivation fails
-            pass
+            stderr_output = traceback.format_exc()
 
-        return result_container["output"], self._locals, self.add_context
+        return {"stdout": stdout_capture.getvalue(), "stderr": stderr_output, "success": stderr_output == ""}

universal_mcp/applications/llm/app.py

@@ -1,7 +1,7 @@
 import json
 from typing import Any, Literal, cast
 
-from langchain.chat_models import init_chat_model
+from langchain.agents import create_agent
 from pydantic import BaseModel, Field
 from universal_mcp.applications.application import BaseApplication
 
@@ -91,8 +91,8 @@ 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)
+        model = load_chat_model("azure/gpt-5-mini", disable_streaming = True, tags=("quiet",))
+        response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(full_prompt, stream=False)
         return str(response.content)
 
     def classify_data(
@@ -151,22 +151,22 @@ class LlmApp(BaseApplication):
             f"This is a classification task.\nPossible classes and descriptions:\n"
             f"{json.dumps(class_descriptions, indent=2)}\n\n"
             f"Context:\n{context_str}\n\n"
-            "Return ONLY a valid JSON object, no extra text."
         )
 
-        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
-
         class ClassificationResult(BaseModel):
             probabilities: dict[str, float] = Field(..., description="The probabilities for each class.")
             reason: str = Field(..., description="The reasoning behind the classification.")
             top_class: str = Field(..., description="The class with the highest probability.")
 
-        response = (
-            model.with_structured_output(schema=ClassificationResult)
-            .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+        model = load_chat_model("azure/gpt-5-mini", temperature=0, disable_streaming = True, tags=("quiet",))
+        agent = create_agent(
+            model=model,
+            tools=[],
+            response_format=ClassificationResult,  # Auto-selects ProviderStrategy
         )
-        return response.model_dump_json(indent=2)
+
+        result = agent.invoke({"messages": [{"role": "user", "content": prompt}]}, stream=False)
+        return result["structured_response"].model_dump()
 
     def extract_data(
         self,
@@ -229,12 +229,12 @@ 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, disable_streaming = True, tags=("quiet",))
 
         response = (
             model.with_structured_output(schema=output_schema, method="json_mode")
             .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+            .invoke(prompt, stream=False)
         )
         return cast(dict[str, Any], response)
 
@@ -282,14 +282,15 @@ 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, disable_streaming = True, tags=("quiet",))
 
-        response = (
-            model.with_structured_output(schema=output_schema, method="json_mode")
-            .with_retry(stop_after_attempt=MAX_RETRIES)
-            .invoke(prompt)
+        agent = create_agent(
+            model=model,
+            tools=[],
+            response_format=output_schema,
         )
-        return cast(dict[str, Any], response)
+        result = agent.invoke({"messages": [{"role": "user", "content": prompt}]}, stream=False)
+        return result["structured_response"]
 
     def list_tools(self):
         return [

{universal_mcp_agents-0.1.21.dist-info → universal_mcp_agents-0.1.23.dist-info}/METADATA

@@ -1,23 +1,24 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.21
+Version: 0.1.23
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT
 Requires-Python: >=3.11
+Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: langchain-anthropic>=0.3.19
 Requires-Dist: langchain-google-genai>=2.1.10
 Requires-Dist: langchain-openai>=0.3.32
 Requires-Dist: langgraph>=0.6.6
-Requires-Dist: typer>=0.17.4
-Requires-Dist: universal-mcp-applications>=0.1.24
-Requires-Dist: universal-mcp>=0.1.24rc25
+Requires-Dist: universal-mcp-applications>=0.1.30
+Requires-Dist: universal-mcp>=0.1.24rc29
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: typer>=0.17.4; extra == 'dev'
 Provides-Extra: test
-Requires-Dist: pytest-asyncio>=1.1.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.2.0; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Requires-Dist: pytest<9.0.0,>=7.0.0; extra == 'test'

{universal_mcp_agents-0.1.21.dist-info → universal_mcp_agents-0.1.23.dist-info}/RECORD

@@ -1,10 +1,10 @@
-universal_mcp/agents/__init__.py,sha256=Rh6vKqpwuZ2joC9nzLFHUI1G7jzbwwC3p0mgpH5qRgo,1112
-universal_mcp/agents/base.py,sha256=CEnY8y2as_XR311t9v2iqd4DOCSyhpOPOBDcZKNJMpc,7378
-universal_mcp/agents/cli.py,sha256=bXdpgxsOMjclm1STHJgx10ocX9EebQ11DrxH0p6KMZk,943
+universal_mcp/agents/__init__.py,sha256=Ythw8tyq7p-w1SPnuO2JtS4TvYEP75PkQpdyvZv-ww4,914
+universal_mcp/agents/base.py,sha256=HkTQzh8EudkG4_5teiD0aDidWpfp2obOz0XR9XsZeUI,7949
+universal_mcp/agents/cli.py,sha256=d3O5BxkT4axHcKnL7gM1SvneWoZMh1QQoElk03KeuU4,950
 universal_mcp/agents/hil.py,sha256=_5PCK6q0goGm8qylJq44aSp2MadP-yCPvhOJYKqWLMo,3808
-universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
-universal_mcp/agents/react.py,sha256=8XQvJ0HLVgc-K0qn9Ml48WGcgUGuIKtL67HatlT6Da0,3334
-universal_mcp/agents/sandbox.py,sha256=Int2O8JNFPlB8c7gb86KRxlNbuV0zdz5_NCo_GMcCds,2876
+universal_mcp/agents/llm.py,sha256=AOijT3hCt3VId97FnvARsPG9lx0sLmn-yiUo8Qx90lQ,2043
+universal_mcp/agents/react.py,sha256=ocYm94HOiJVI2zwTjO1K2PNfVY7EILLJ6cd__jnGHPs,3327
+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
@@ -13,7 +13,7 @@ universal_mcp/agents/bigtool/agent.py,sha256=mtCDNN8WjE2hjJjooDqusmbferKBHeJMHrh
 universal_mcp/agents/bigtool/context.py,sha256=ny7gd-vvVpUOYAeQbAEUT0A6Vm6Nn2qGywxTzPBzYFg,929
 universal_mcp/agents/bigtool/graph.py,sha256=2Sy0dtevTWeT3hJDq4BDerZFvk_zJqx15j8VH2XLq8Y,5848
 universal_mcp/agents/bigtool/prompts.py,sha256=Joi5mCzZX63aM_6eBrMOKuNRHjTkceVIibSsGBGqhYE,2041
-universal_mcp/agents/bigtool/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
+universal_mcp/agents/bigtool/state.py,sha256=Voh7HXGC0PVe_0qoRZ8ZYg9akg65_2jQIAV2eIwperE,737
 universal_mcp/agents/bigtool/tools.py,sha256=-u80ta6xEaqzEMSzDVe3QZiTZm3YlgLkBD8WTghzClw,6315
 universal_mcp/agents/builder/__main__.py,sha256=VJDJOr-dJJerT53ibh5LVqIsMJ0m0sG2UlzFB784pKw,11680
 universal_mcp/agents/builder/builder.py,sha256=mh3MZpMVB1FE1DWzvMW9NnfiaF145VGn8cJzKSYUlzY,8587
@@ -21,24 +21,24 @@ universal_mcp/agents/builder/helper.py,sha256=8igR1b3Gy_N2u3WxHYKIWzvw7F5BMnfpO2
 universal_mcp/agents/builder/prompts.py,sha256=8Xs6uzTUHguDRngVMLak3lkXFkk2VV_uQXaDllzP5cI,4670
 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=_7qSz97YnRgYJTESkALS5_eBIGHiMjA5rhr3IAeBvVo,896
-universal_mcp/agents/codeact0/agent.py,sha256=KvIoZh2J2JQONfGf80LBuXDdQnnYja4ybZ4DluCKxPM,15192
+universal_mcp/agents/codeact0/__main__.py,sha256=YyIoecUcKVUhTcCACzLlSmYrayMDsdwzDEqaV4VV4CE,766
+universal_mcp/agents/codeact0/agent.py,sha256=sJmTrFudHMJkkRVJgmd3KdB-kFU-yCwPvyRJE18pJ3g,23497
 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=a5ja7KwSG1SmbCkoZVdyFOI5dz2Ul-OWG-JcakBySDM,9635
-universal_mcp/agents/codeact0/sandbox.py,sha256=Xw4tbUV_6haYIZZvteJi6lIYsW6ni_3DCRCOkslTKgM,4459
-universal_mcp/agents/codeact0/state.py,sha256=Z9fUmBTw-29MZTq2GsYYyyjLPyrtE5GDnhX4gSqHhcA,1555
-universal_mcp/agents/codeact0/tools.py,sha256=qGhbJl74xflJBNfOCiy-Ts5zKIxXjE1JVyqvtVGHZNY,13363
-universal_mcp/agents/codeact0/utils.py,sha256=Rustf3MFoFbasdnwBh9YvNrXqasgANkBAWQn9AjqBO4,16240
+universal_mcp/agents/codeact0/prompts.py,sha256=TaGxbEka0wxaHIynVe_El_8Qy7bhIpXFLW817lGq3os,17264
+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=7w-04moo7gBkqjmGzz_rTbmJEG23W0vd71pZ0D9CA9M,23299
+universal_mcp/agents/codeact0/utils.py,sha256=eOdqemLx6RqI5g--vtM9WP2LHrYXro2bxScNAVUU0Do,19683
 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=2BIH6JDqw6LPD9Iuo3_LoXa48813o6G4gmeRBR_v9oc,12933
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.21.dist-info/METADATA,sha256=2Nx9bEG_IEb5wHTV-8vXpQEUTNsl0bbQkPR6Ii4R1V0,878
-universal_mcp_agents-0.1.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.21.dist-info/RECORD,,
+universal_mcp_agents-0.1.23.dist-info/METADATA,sha256=sBzwtuZHot_QhhiMDcIWVVHxi1V373IFHpBTYl9zFyg,928
+universal_mcp_agents-0.1.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.23.dist-info/RECORD,,