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

universal_mcp/agents/codeact0/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/codeact00/__init__.py

@@ -0,0 +1,3 @@
+from .agent import CodeActPlaybookAgent
+
+__all__ = ["CodeActPlaybookAgent"]

universal_mcp/agents/{unified → codeact00}/__main__.py

@@ -4,23 +4,21 @@ from langgraph.checkpoint.memory import MemorySaver
 from rich import print
 from universal_mcp.agentr.registry import AgentrRegistry
 
-from universal_mcp.agents.unified import UnifiedAgent
+from universal_mcp.agents.codeact00.agent import CodeActPlaybookAgent
 from universal_mcp.agents.utils import messages_to_list
 
 
 async def main():
     memory = MemorySaver()
-    default_tools = {"llm": ["generate_text", "classify_data", "extract_data", "call_llm"]}
-    agent = UnifiedAgent(
+    agent = CodeActPlaybookAgent(
         name="CodeAct Agent",
         instructions="Be very concise in your answers.",
-        model="anthropic:claude-4-sonnet-20250514",
-        tools=default_tools,
+        model="azure/gpt-4.1",
         registry=AgentrRegistry(),
         memory=memory,
     )
     print("Starting agent...")
-    result = await agent.invoke(user_input="find the 80th fibonnaci number")
+    result = await agent.invoke(user_input="Check my google calendar and show my todays agenda")
     print(messages_to_list(result["messages"]))