universal-mcp-agents 0.1.19rc1__py3-none-any.whl → 0.1.24rc3__py3-none-any.whl

universal_mcp/agents/{unified → codeact01}/utils.py

@@ -4,11 +4,90 @@ 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
+        tool_config[app_id] = list(set(all_tools))
+    return tool_config
+
+
 def light_copy(data):
     """
     Deep copy a dict[str, any] or Sequence[any] with string truncation.
@@ -325,31 +404,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):"
 
@@ -386,3 +479,74 @@ 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."
+
+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/llm.py

@@ -4,26 +4,37 @@ 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 +44,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 +53,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,8 +1,8 @@
 import json
-from typing import Any, Literal, cast
+from typing import Any, Literal, cast, Optional, List
 
-from langchain.chat_models import init_chat_model
-from pydantic import BaseModel, Field
+from langchain.agents import create_agent
+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.
 
@@ -91,8 +144,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 +204,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, method="json_mode")
-            .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 cast(dict[str, Any], response)
+
+        result = agent.invoke({"messages": [{"role": "user", "content": prompt}]}, stream=False)
+        return result["structured_response"].model_dump()
 
     def extract_data(
         self,
@@ -229,14 +282,15 @@ 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",))
 
+        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)
+            .invoke(prompt, stream=False)
         )
-        return cast(dict[str, Any], response)
+        return cast(dict[str, Any], response.model_dump())
 
     def call_llm(
         self,
@@ -282,14 +336,12 @@ 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)
-        )
-        return cast(dict[str, Any], 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 [