universal-mcp-agents 0.1.19rc1__py3-none-any.whl → 0.1.20rc1__py3-none-any.whl

universal_mcp/agents/unified/tools.py

@@ -1,188 +0,0 @@
-import asyncio
-from collections import defaultdict
-from typing import Any
-
-from langchain_core.tools import tool
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolFormat
-
-MAX_LENGHT = 100
-
-
-def enter_playbook_mode():
-    """Call this function to enter playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
-    return
-
-
-def exit_playbook_mode():
-    """Call this function to exit playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
-    return
-
-
-def create_meta_tools(tool_registry: ToolRegistry) -> dict[str, Any]:
-    """Create the meta tools for searching and loading tools"""
-
-    @tool
-    async def search_functions(queries: list[str]) -> str:
-        """Search for relevant functions given list of queries.
-        Each single query should be atomic (doable with a single function).
-        For tasks requiring multiple functions, add separate queries for each subtask"""
-        try:
-            # Fetch all connections
-            connections = await tool_registry.list_connected_apps()
-            connected_apps = {connection["app_id"] for connection in connections}
-
-            app_tools = defaultdict(set)
-            MAX_LENGTH = 20
-
-            # Process all queries concurrently
-            search_tasks = []
-            for query in queries:
-                search_tasks.append(_search_query_tools(query))
-
-            query_results = await asyncio.gather(*search_tasks)
-
-            # Aggregate results with limit per app and automatic deduplication
-            for tools_list in query_results:
-                for tool in tools_list:
-                    app = tool["id"].split("__")[0]
-                    tool_id = tool["id"]
-
-                    # Check if within limit and add to set (automatically deduplicates)
-                    if len(app_tools[app]) < MAX_LENGTH:
-                        cleaned_desc = tool["description"].split("Context:")[0].strip()
-                        app_tools[app].add(f"{tool_id}: {cleaned_desc}")
-
-            # Build result string efficiently
-            result_parts = []
-            for app, tools in app_tools.items():
-                app_status = "connected" if app in connected_apps else "NOT connected"
-                result_parts.append(f"Tools from {app} (status: {app_status} by user):")
-                # Convert set to sorted list for consistent output
-                for tool in sorted(tools):
-                    result_parts.append(f" - {tool}")
-                result_parts.append("")  # Empty line between apps
-
-            result_parts.append("Call load_functions to select the required functions only.")
-            return "\n".join(result_parts)
-
-        except Exception as e:
-            return f"Error: {e}"
-
-    async def _search_query_tools(query: str) -> list[dict]:
-        """Helper function to search apps and tools for a single query."""
-        # Start both searches concurrently
-        tools_search_task = tool_registry.search_tools(query, limit=10)
-        apps_search_task = tool_registry.search_apps(query, limit=4)
-
-        # Wait for both to complete
-        tools_from_general_search, apps_list = await asyncio.gather(tools_search_task, apps_search_task)
-
-        # Create tasks for searching tools from each app
-        app_tool_tasks = [tool_registry.search_tools(query, limit=5, app_id=app["id"]) for app in apps_list]
-
-        # Wait for all app-specific tool searches to complete
-        app_tools_results = await asyncio.gather(*app_tool_tasks)
-
-        # Combine all results
-        tools_list = list(tools_from_general_search)
-        for app_tools in app_tools_results:
-            tools_list.extend(app_tools)
-
-        return tools_list
-
-    @tool
-    async def load_functions(tool_ids: list[str]) -> str:
-        """Load specific functions by their IDs for use in subsequent steps.
-
-        Args:
-            tool_ids: Function ids in the form 'app__function'. Example: 'google_mail__send_email'
-
-        Returns:
-            Confirmation message about loaded functions
-        """
-        return f"Successfully loaded {len(tool_ids)} functions: {tool_ids}"
-
-    @tool
-    async def web_search(query: str) -> dict:
-        """
-        Get an LLM answer to a question informed by Exa search results.
-
-        This tool performs an Exa `/answer` request, which:
-        1. Provides a **direct answer** for factual queries (e.g., "What is the capital of France?" → "Paris")
-        2. Generates a **summary with citations** for open-ended questions
-        (e.g., "What is the state of AI in healthcare?" → A detailed summary with source links)
-
-        Args:
-            query (str): The question or topic to answer.
-        Returns:
-            dict: A structured response containing only:
-                - answer (str): Generated answer
-                - citations (list[dict]): List of cited sources
-        """
-        await tool_registry.export_tools(["exa__answer"], ToolFormat.LANGCHAIN)
-        response = await tool_registry.call_tool("exa__answer", {"query": query, "text": True})
-
-        # Extract only desired fields
-        return {
-            "answer": response.get("answer"),
-            "citations": response.get("citations", []),
-        }
-
-    return {"search_functions": search_functions, "load_functions": load_functions, "web_search": web_search}
-
-
-async def get_valid_tools(tool_ids: list[str], registry: ToolRegistry) -> tuple[list[str], list[str]]:
-    """For a given list of tool_ids, validates the tools and returns a list of links for the apps that have not been logged in"""
-    correct, incorrect = [], []
-    connections = await registry.list_connected_apps()
-    connected_apps = {connection["app_id"] for connection in connections}
-    unconnected = set()
-    unconnected_links = []
-    app_tool_list: dict[str, set[str]] = {}
-
-    # Group tool_ids by app for fewer registry calls
-    app_to_tools: dict[str, list[tuple[str, str]]] = {}
-    for tool_id in tool_ids:
-        if "__" not in tool_id:
-            incorrect.append(tool_id)
-            continue
-        app, tool_name = tool_id.split("__", 1)
-        app_to_tools.setdefault(app, []).append((tool_id, tool_name))
-
-    # Fetch all apps concurrently
-    async def fetch_tools(app: str):
-        try:
-            tools_dict = await registry.list_tools(app)
-            return app, {tool_unit["name"] for tool_unit in tools_dict}
-        except Exception:
-            return app, None
-
-    results = await asyncio.gather(*(fetch_tools(app) for app in app_to_tools))
-
-    # Build map of available tools per app
-    for app, tools in results:
-        if tools is not None:
-            app_tool_list[app] = tools
-
-    # Validate tool_ids
-    for app, tool_entries in app_to_tools.items():
-        available = app_tool_list.get(app)
-        if available is None:
-            incorrect.extend(tool_id for tool_id, _ in tool_entries)
-            continue
-        if app not in connected_apps and app not in unconnected:
-            unconnected.add(app)
-            text = registry.client.get_authorization_url(app)
-            start = text.find(":") + 1
-            end = text.find(". R", start)
-            url = text[start:end].strip()
-            markdown_link = f"[{app}]({url})"
-            unconnected_links.append(markdown_link)
-        for tool_id, tool_name in tool_entries:
-            if tool_name in available:
-                correct.append(tool_id)
-            else:
-                incorrect.append(tool_id)
-
-    return correct, unconnected_links

universal_mcp/agents/unified/utils.py

@@ -1,388 +0,0 @@
-import ast
-import importlib
-import re
-from collections.abc import Sequence
-from typing import Any
-
-from langchain_core.messages import BaseMessage
-
-MAX_CHARS = 5000
-
-
-def light_copy(data):
-    """
-    Deep copy a dict[str, any] or Sequence[any] with string truncation.
-
-    Args:
-        data: Either a dictionary with string keys, or a sequence of such dictionaries
-
-    Returns:
-        A deep copy where all string values are truncated to MAX_CHARS characters
-    """
-
-    def truncate_string(value):
-        """Truncate string to MAX_CHARS chars, preserve other types"""
-        if isinstance(value, str) and len(value) > MAX_CHARS:
-            return value[:MAX_CHARS] + "..."
-        return value
-
-    def copy_dict(d):
-        """Recursively copy a dictionary, truncating strings"""
-        result = {}
-        for key, value in d.items():
-            if isinstance(value, dict):
-                result[key] = copy_dict(value)
-            elif isinstance(value, Sequence) and not isinstance(value, str):
-                result[key] = [
-                    copy_dict(item) if isinstance(item, dict) else truncate_string(item) for item in value[:20]
-                ]  # Limit to first 20 items
-            else:
-                result[key] = truncate_string(value)
-        return result
-
-    # Handle the two main cases
-    if isinstance(data, dict):
-        return copy_dict(data)
-    elif isinstance(data, Sequence) and not isinstance(data, str):
-        return [
-            copy_dict(item) if isinstance(item, dict) else truncate_string(item) for item in data[:20]
-        ]  # Limit to first 20 items
-    else:
-        # For completeness, handle other types
-        return truncate_string(data)
-
-
-def get_message_text(msg: BaseMessage) -> str:
-    """Get the text content of a message."""
-    content = msg.content
-    if isinstance(content, str):
-        return content
-    elif isinstance(content, dict):
-        return content.get("text", "")
-    else:
-        txts = [c if isinstance(c, str) else (c.get("text") or "") for c in content]
-        return "".join(txts).strip()
-
-
-def make_safe_function_name(name: str) -> str:
-    """Convert a tool name to a valid Python function name."""
-    # Replace non-alphanumeric characters with underscores
-    safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
-    # Ensure the name doesn't start with a digit
-    if safe_name and safe_name[0].isdigit():
-        safe_name = f"tool_{safe_name}"
-    # Handle empty name edge case
-    if not safe_name:
-        safe_name = "unnamed_tool"
-    return safe_name
-
-
-def derive_context(code: str, context: dict[str, Any]) -> dict[str, Any]:
-    """
-    Derive context from code by extracting classes, functions, and import statements.
-
-    Args:
-        code: Python code as a string
-        context: Existing context dictionary to append to
-
-    Returns:
-        Updated context dictionary with extracted entities
-    """
-
-    # Initialize context keys if they don't exist
-    if "imports" not in context:
-        context["imports"] = []
-    if "classes" not in context:
-        context["classes"] = []
-    if "functions" not in context:
-        context["functions"] = []
-
-    try:
-        # Parse the code into an AST
-        tree = ast.parse(code)
-
-        # Extract imports
-        for node in ast.walk(tree):
-            if isinstance(node, ast.Import):
-                for alias in node.names:
-                    if alias.asname:
-                        import_stmt = f"import {alias.name} as {alias.asname}"
-                    else:
-                        import_stmt = f"import {alias.name}"
-                    if import_stmt not in context["imports"]:
-                        context["imports"].append(import_stmt)
-
-            elif isinstance(node, ast.ImportFrom):
-                module = node.module or ""
-                # Handle multiple imports in a single from statement
-                import_names = []
-                for alias in node.names:
-                    if alias.asname:
-                        import_names.append(f"{alias.name} as {alias.asname}")
-                    else:
-                        import_names.append(alias.name)
-
-                import_stmt = f"from {module} import {', '.join(import_names)}"
-                if import_stmt not in context["imports"]:
-                    context["imports"].append(import_stmt)
-
-        # Extract class definitions
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef):
-                # Get the class definition as a string
-                class_lines = code.split("\n")[node.lineno - 1 : node.end_lineno]
-                class_def = "\n".join(class_lines)
-
-                # Clean up the class definition (remove leading/trailing whitespace)
-                class_def = class_def.strip()
-
-                if class_def not in context["classes"]:
-                    context["classes"].append(class_def)
-
-        # Extract function definitions (including async)
-        for node in ast.walk(tree):
-            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                func_lines = code.split("\n")[node.lineno - 1 : node.end_lineno]
-                func_def = "\n".join(func_lines)
-
-                # Only top-level functions (col_offset == 0)
-                if node.col_offset == 0:
-                    func_def = func_def.strip()
-                    if func_def not in context["functions"]:
-                        context["functions"].append(func_def)
-
-    except SyntaxError:
-        # If the code has syntax errors, try a simpler regex-based approach
-
-        # Extract import statements using regex
-        import_patterns = [
-            r"import\s+(\w+(?:\.\w+)*)(?:\s+as\s+(\w+))?",
-            r"from\s+(\w+(?:\.\w+)*)\s+import\s+(\w+(?:\s+as\s+\w+)?)",
-        ]
-
-        for pattern in import_patterns:
-            matches = re.finditer(pattern, code)
-            for match in matches:
-                if "from" in pattern:
-                    module = match.group(1)
-                    imports = match.group(2).split(",")
-                    for import_name in imports:
-                        imp = import_name.strip()
-                        if " as " in imp:
-                            name, alias = imp.split(" as ")
-                            import_stmt = f"from {module} import {name.strip()} as {alias.strip()}"
-                        else:
-                            import_stmt = f"from {module} import {imp}"
-                        if import_stmt not in context["imports"]:
-                            context["imports"].append(import_stmt)
-                else:
-                    module = match.group(1)
-                    alias = match.group(2)
-                    if alias:
-                        import_stmt = f"import {module} as {alias}"
-                    else:
-                        import_stmt = f"import {module}"
-                    if import_stmt not in context["imports"]:
-                        context["imports"].append(import_stmt)
-
-        # Extract class definitions using regex
-        class_pattern = r"class\s+(\w+).*?(?=class\s+\w+|def\s+\w+|$)"
-        class_matches = re.finditer(class_pattern, code, re.DOTALL)
-        for match in class_matches:
-            class_def = match.group(0).strip()
-            if class_def not in context["classes"]:
-                context["classes"].append(class_def)
-
-        # Extract function definitions using regex
-        func_pattern = r"def\s+(\w+).*?(?=class\s+\w+|def\s+\w+|$)"
-        func_matches = re.finditer(func_pattern, code, re.DOTALL)
-        for match in func_matches:
-            func_def = match.group(0).strip()
-            if func_def not in context["functions"]:
-                context["functions"].append(func_def)
-
-    return context
-
-
-def inject_context(
-    context_dict: dict[str, list[str]], existing_namespace: dict[str, Any] | None = None
-) -> dict[str, Any]:
-    """
-    Inject Python entities from a dictionary into a namespace.
-
-    This function takes a dictionary where keys represent entity types (imports, classes, functions, etc.)
-    and values are lists of entity definitions. It attempts to import or create these entities and returns
-    them in a namespace dictionary. Can optionally build upon an existing namespace and apply additional aliases.
-
-    Args:
-        context_dict: Dictionary with entity types as keys and lists of entity definitions as values.
-                     Supported keys: 'imports', 'classes', 'functions'
-                     - 'imports': List of import statements as strings (e.g., ['import pandas', 'import numpy as np'])
-                     - 'classes': List of class definitions as strings
-                     - 'functions': List of function definitions as strings
-        existing_namespace: Optional existing namespace to build upon. If provided, new entities
-                          will be added to this namespace rather than creating a new one.
-
-    Returns:
-        Dictionary containing the injected entities as key-value pairs
-
-    Example:
-        context = {
-            'imports': ['import pandas as pd', 'import numpy as np'],
-            'classes': ['class MyClass:\n    def __init__(self, x):\n        self.x = x'],
-            'functions': ['def my_function(x):\n    return x * 2']
-        }
-        existing_ns = {'math': <math module>, 'data': [1, 2, 3]}
-        namespace = inject_context(context, existing_ns)
-        # namespace will contain: {'math': <math module>, 'data': [1, 2, 3], 'pandas': <module>, 'pd': <module>, 'numpy': <module>, 'np': <module>, 'MyClass': <class>, 'MC': <class>, 'my_function': <function>, ...}
-    """
-
-    # Start with existing namespace or create new one
-    namespace: dict[str, Any] = existing_namespace.copy() if existing_namespace is not None else {}
-
-    # Handle imports (execute import statements as strings)
-    if "imports" in context_dict:
-        for import_statement in context_dict["imports"]:
-            try:
-                # Execute the import statement in the current namespace
-                exec(import_statement, namespace)
-            except Exception as e:
-                # If execution fails, try to extract module name and create placeholder
-
-                # Handle different import patterns
-                import_match = re.search(r"import\s+(\w+)(?:\s+as\s+(\w+))?", import_statement)
-                if import_match:
-                    module_name = import_match.group(1)
-                    alias_name = import_match.group(2)
-
-                    try:
-                        # Try to import the module manually
-                        module = importlib.import_module(module_name)
-                        namespace[module_name] = module
-                        if alias_name:
-                            namespace[alias_name] = module
-                    except ImportError:
-                        # Create placeholders for missing imports
-                        namespace[module_name] = f"<import '{module_name}' not available>"
-                        if alias_name:
-                            namespace[alias_name] = f"<import '{module_name}' as '{alias_name}' not available>"
-                else:
-                    # If we can't parse the import statement, create a generic placeholder
-                    namespace[f"import_{len(namespace)}"] = f"<import statement failed: {str(e)}>"
-
-    # Handle classes - execute class definitions as strings
-    if "classes" in context_dict:
-        for class_definition in context_dict["classes"]:
-            try:
-                # Execute the class definition in the current namespace
-                exec(class_definition, namespace)
-            except Exception:
-                # If execution fails, try to extract class name and create placeholder
-
-                class_match = re.search(r"class\s+(\w+)", class_definition)
-                if class_match:
-                    class_name = class_match.group(1)
-
-                    # Create a placeholder class
-                    class PlaceholderClass:
-                        def __init__(self, *args, **kwargs):
-                            raise NotImplementedError("Class '{class_name}' failed to load")
-
-                    namespace[class_name] = PlaceholderClass
-                else:
-                    # If we can't extract class name, create a generic placeholder
-                    class GenericPlaceholderClass:
-                        def __init__(self, *args, **kwargs):
-                            raise NotImplementedError("Class definition failed to load")
-
-                    namespace[f"class_{len(namespace)}"] = GenericPlaceholderClass
-
-    # Handle functions - execute function definitions as strings
-    if "functions" in context_dict:
-        for function_definition in context_dict["functions"]:
-            try:
-                # Execute the function definition in the current namespace
-                exec(function_definition, namespace)
-            except Exception:
-                # If execution fails, try to extract function name and create placeholder
-                func_match = re.search(r"(async\s+)?def\s+(\w+)", function_definition)
-                if func_match:
-                    func_name = func_match.group(2)
-                    is_async = bool(func_match.group(1))
-
-                    if is_async:
-
-                        async def placeholder_func(*args, **kwargs):
-                            raise NotImplementedError(f"Async function '{func_name}' failed to load")
-                    else:
-
-                        def placeholder_func(*args, **kwargs):
-                            raise NotImplementedError(f"Function '{func_name}' failed to load")
-
-                    placeholder_func.__name__ = func_name
-                    namespace[func_name] = placeholder_func
-
-    return namespace
-
-
-def schema_to_signature(schema: dict, func_name="my_function") -> str:
-    type_map = {
-        "integer": "int",
-        "string": "str",
-        "boolean": "bool",
-        "null": "None",
-    }
-
-    params = []
-    for name, meta in schema.items():
-        # figure out type
-        if "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))
-        else:
-            typ = "Any"
-
-        default = meta.get("default", None)
-        default_repr = repr(default)
-
-        params.append(f"{name}: {typ} = {default_repr}")
-
-    # join into signature
-    param_str = ",\n    ".join(params)
-    return f"def {func_name}(\n    {param_str},\n):"
-
-
-def smart_truncate(
-    output: str, max_chars_full: int = 2000, max_lines_headtail: int = 20, summary_threshold: int = 10000
-) -> str:
-    """
-    Truncates or summarizes output intelligently to avoid filling the context too fast.
-
-    Args:
-        output (str): The string output from code execution.
-        max_chars_full (int): Max characters to keep full output.
-        max_lines_headtail (int): Number of lines to keep from head and tail for medium outputs.
-        summary_threshold (int): If truncated output exceeds this, hard-truncate.
-
-    Returns:
-        str: Truncated or summarized output.
-    """
-    if len(output) <= max_chars_full:
-        return output  # Small output, include fully
-
-    lines = output.splitlines()
-    if len(lines) <= 2 * max_lines_headtail:
-        return output  # Medium output, include fully
-
-    # Medium-large output: take head + tail
-    head = "\n".join(lines[:max_lines_headtail])
-    tail = "\n".join(lines[-max_lines_headtail:])
-    truncated = f"{head}\n... [truncated {len(lines) - 2 * max_lines_headtail} lines] ...\n{tail}"
-
-    # If still too big, cut to summary threshold
-    if len(truncated) > summary_threshold:
-        truncated = truncated[:summary_threshold] + "\n... [output truncated to fit context] ..."
-
-    return truncated

universal_mcp_agents-0.1.19rc1.dist-info/RECORD

@@ -1,64 +0,0 @@
-universal_mcp/agents/__init__.py,sha256=rXWhqmhXdhUdId7QzuQHUpWUwfioPmj7ksu6RHZvCFI,1368
-universal_mcp/agents/base.py,sha256=GmagwWFJdPpp_yLeAfsrr4fu-zzxh7CgIlBJbTgFgWM,7072
-universal_mcp/agents/cli.py,sha256=AG9e4iSX3GazT537573YrYT1wSaZYOr42rrYQ7xP3YA,1016
-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/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
-universal_mcp/agents/utils.py,sha256=P6W9k6XAOBp6tdjC2VTP4tE0B2M4-b1EDmr-ylJ47Pw,7765
-universal_mcp/agents/bigtool/__init__.py,sha256=mZG8dsaCVyKlm82otxtiTA225GIFLUCUUYPEIPF24uw,2299
-universal_mcp/agents/bigtool/__main__.py,sha256=0i-fbd2yQ90qa8n2nM3luqoJVN9Reh5HZXR5oK7SAck,445
-universal_mcp/agents/bigtool/agent.py,sha256=mtCDNN8WjE2hjJjooDqusmbferKBHeJMHrhXUPUWaVc,252
-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/tools.py,sha256=-u80ta6xEaqzEMSzDVe3QZiTZm3YlgLkBD8WTghzClw,6315
-universal_mcp/agents/builder/__main__.py,sha256=VJDJOr-dJJerT53ibh5LVqIsMJ0m0sG2UlzFB784pKw,11680
-universal_mcp/agents/builder/builder.py,sha256=mh3MZpMVB1FE1DWzvMW9NnfiaF145VGn8cJzKSYUlzY,8587
-universal_mcp/agents/builder/helper.py,sha256=8igR1b3Gy_N2u3WxHYKIWzvw7F5BMnfpO2IU74v6vsw,2680
-universal_mcp/agents/builder/prompts.py,sha256=8Xs6uzTUHguDRngVMLak3lkXFkk2VV_uQXaDllzP5cI,4670
-universal_mcp/agents/builder/state.py,sha256=7DeWllxfN-yD6cd9wJ3KIgjO8TctkJvVjAbZT8W_zqk,922
-universal_mcp/agents/codeact/__init__.py,sha256=rLE8gvOo5H4YSr71DRq76b3RV3uuotxuAy_VnBVaVwk,60
-universal_mcp/agents/codeact/__main__.py,sha256=W2cHXRwH1dZG3ETIkMwUqA_d62K3IctHP-FDZWDjxdw,1067
-universal_mcp/agents/codeact/agent.py,sha256=sKZWokTHcuL68Y6SNyaaHe6_XkWxaIq36TrNmPJfQto,9762
-universal_mcp/agents/codeact/models.py,sha256=2fdAcF5bxWDpljjEwDEdPBflTMShSPwwncHrphRjsYg,222
-universal_mcp/agents/codeact/prompts.py,sha256=EMI-imnd0Ps0Bd2FOvSqgiicvvtFFu0MF9s93PiC_3k,4493
-universal_mcp/agents/codeact/sandbox.py,sha256=NjN6ISj8psFtHf8V0w24ChJdUMUWkq7OrlbHdzm4wBc,2299
-universal_mcp/agents/codeact/state.py,sha256=WTPfpxDlGRnlr5tZuXMg_KU7GS7TZbnrIKslOvZLbQI,565
-universal_mcp/agents/codeact/utils.py,sha256=JUbT_HYGS_D1BzmzoVpORIe7SGur1KgJguTZ_1tZ4JY,1918
-universal_mcp/agents/codeact0/__init__.py,sha256=ebKkpgg-0UnsvDtagEJ2tMer1VsfhmEE5KJcFzUk9fU,133
-universal_mcp/agents/codeact0/__main__.py,sha256=xeqNuawP9M8JVAnkhLesalnpI_TakC49ATJaSCzCsYs,880
-universal_mcp/agents/codeact0/agent.py,sha256=9BInAQr3csES-XHSscmeJlYJ3-wQUHPvLOf-6wFILUU,6695
-universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
-universal_mcp/agents/codeact0/langgraph_agent.py,sha256=ehjMV_Z1118pCFWB_Sa5H7XnUp0udsbUHjfjXjhIQM8,435
-universal_mcp/agents/codeact0/llm_tool.py,sha256=q-hiqkKtjVmpyNceFoRgo7hvKh4HtQf_I1VudRUEPR0,11075
-universal_mcp/agents/codeact0/playbook_agent.py,sha256=Eq_us8j7plxgep1LuJ4I3u8qxjS95_2vGEaPR3g8A-o,17796
-universal_mcp/agents/codeact0/prompts.py,sha256=CF2X6zSK1lYQ9ef78cn0iN0oQN_tDe3T02Ecfn1o45U,8627
-universal_mcp/agents/codeact0/sandbox.py,sha256=zMgHrWnQYkSkJb2MzfXvT3euCc4hvqzBE_EbX2_iLxA,3142
-universal_mcp/agents/codeact0/state.py,sha256=Y-Rzn_S7--aXH18KPvyhqDqOOB-miu1lsAmLgmMlaAg,1259
-universal_mcp/agents/codeact0/tools.py,sha256=7hcFJxR26w_VCOWL8Oec8Ezfn3Auyv3YgeRv9f8j9xo,7642
-universal_mcp/agents/codeact0/utils.py,sha256=jAZItSd3KGDkY9PquSWRIFCj9N26K9Kt0HKQ_jwvvSQ,15944
-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/agents/unified/README.md,sha256=lcZobDA7MVm7vOAefLr4EMlEmgmODhndOZhwrOQO8lg,3658
-universal_mcp/agents/unified/__init__.py,sha256=Oi5nfloc1saGh0HuYZvw2h7NRRWKKVptBXg6PFK6lnw,60
-universal_mcp/agents/unified/__main__.py,sha256=XzHdp_AEd7k2CaWmsUekk3r1eefjmZSKsPhyBBWQDHU,865
-universal_mcp/agents/unified/agent.py,sha256=jQrEk_AcaWpbty5hlncI9cTOOw1W_U4KYQB7xiraoYA,13551
-universal_mcp/agents/unified/langgraph_agent.py,sha256=7v76Uv_1UydCsQpDj99k1FtR1wm7e9yZihwCYdFebwY,403
-universal_mcp/agents/unified/llm_tool.py,sha256=-pAz04OrbZ_dJ2ueysT1qZd02DrbLY4EbU0tiuF_UNU,798
-universal_mcp/agents/unified/prompts.py,sha256=ojHoZUJ1tLc7CwOZPWRJvzdwC_H3hE6PgZ9GKfHqAhU,9521
-universal_mcp/agents/unified/sandbox.py,sha256=zMgHrWnQYkSkJb2MzfXvT3euCc4hvqzBE_EbX2_iLxA,3142
-universal_mcp/agents/unified/state.py,sha256=6gtl1TV4qnnvkhXgHntH13jlVL53S00dFtw_mPKTFw4,1380
-universal_mcp/agents/unified/tools.py,sha256=7hcFJxR26w_VCOWL8Oec8Ezfn3Auyv3YgeRv9f8j9xo,7642
-universal_mcp/agents/unified/utils.py,sha256=jAZItSd3KGDkY9PquSWRIFCj9N26K9Kt0HKQ_jwvvSQ,15944
-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=oqX3byvlFRmeRo4jJJxUBGy-iTDGm2fplMEKA2pcMtw,12743
-universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.19rc1.dist-info/METADATA,sha256=6euKZt6O6J-GgvtqE57uQbZRrNtvL7Al2wGdOEBALvQ,881
-universal_mcp_agents-0.1.19rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.19rc1.dist-info/RECORD,,