universal-mcp 0.1.24rc14__py3-none-any.whl → 0.1.24rc17__py3-none-any.whl

universal_mcp/agents/simple.py

@@ -1,40 +0,0 @@
-import asyncio
-from typing import Annotated
-
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.graph import END, START, StateGraph
-from langgraph.graph.message import add_messages
-from typing_extensions import TypedDict
-
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-
-
-class State(TypedDict):
-    messages: Annotated[list, add_messages]
-
-
-class SimpleAgent(BaseAgent):
-    def __init__(self, name: str, instructions: str, model: str, memory: BaseCheckpointSaver = None, **kwargs):
-        super().__init__(name, instructions, model, memory, **kwargs)
-        self.llm = load_chat_model(model)
-
-    async def _build_graph(self):
-        graph_builder = StateGraph(State)
-
-        async def chatbot(state: State):
-            messages = [
-                {"role": "system", "content": self.instructions},
-                *state["messages"],
-            ]
-            return {"messages": [await self.llm.ainvoke(messages)]}
-
-        graph_builder.add_node("chatbot", chatbot)
-        graph_builder.add_edge(START, "chatbot")
-        graph_builder.add_edge("chatbot", END)
-        return graph_builder.compile(checkpointer=self.memory)
-
-
-if __name__ == "__main__":
-    agent = SimpleAgent("Simple Agent", "You are a helpful assistant", "azure/gpt-4o")
-    asyncio.run(agent.run_interactive())

universal_mcp/agents/tools.py

@@ -1,35 +0,0 @@
-import json
-
-from langchain_mcp_adapters.client import MultiServerMCPClient
-
-from universal_mcp.agentr.integration import AgentrIntegration
-from universal_mcp.applications import app_from_slug
-from universal_mcp.tools.adapters import ToolFormat
-from universal_mcp.tools.manager import ToolManager
-from universal_mcp.types import ToolConfig
-
-
-async def load_agentr_tools(agentr_servers: dict):
-    tool_manager = ToolManager()
-    for app_name, tool_names in agentr_servers.items():
-        app = app_from_slug(app_name)
-        integration = AgentrIntegration(name=app_name)
-        app_instance = app(integration=integration)
-        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names["tools"])
-    tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
-    return tools
-
-
-async def load_mcp_tools(mcp_servers: dict):
-    client = MultiServerMCPClient(mcp_servers)
-    tools = await client.get_tools()
-    return tools
-
-
-async def load_tools(path: str) -> ToolConfig:
-    with open(path) as f:
-        data = json.load(f)
-        config = ToolConfig.model_validate(data)
-        agentr_tools = await load_agentr_tools(config.model_dump(exclude_none=True)["agentrServers"])
-        mcp_tools = await load_mcp_tools(config.model_dump(exclude_none=True)["mcpServers"])
-        return agentr_tools + mcp_tools

universal_mcp/agents/utils.py

@@ -1,111 +0,0 @@
-import json
-from contextlib import contextmanager
-
-from rich.console import Console
-from rich.live import Live
-from rich.markdown import Markdown
-from rich.panel import Panel
-from rich.prompt import Prompt
-from rich.table import Table
-
-
-class RichCLI:
-    def __init__(self):
-        self.console = Console()
-
-    def display_welcome(self, agent_name: str):
-        """Display welcome message"""
-        welcome_text = f"""
-# Welcome to {agent_name}!
-
-Available commands:
-- Type your questions naturally
-- `/help` - Show help
-- `/tools` - List available tools
-- `/exit` - Exit the application
-        """
-        self.console.print(Panel(Markdown(welcome_text), title="🤖 AI Agent CLI", border_style="blue"))
-
-    def display_agent_response(self, response: str, agent_name: str):
-        """Display agent response with formatting"""
-        self.console.print(Panel(Markdown(response), title=f"🤖 {agent_name}", border_style="green", padding=(1, 2)))
-
-    @contextmanager
-    def display_agent_response_streaming(self, agent_name: str):
-        """Context manager for streaming agent response updates."""
-
-        with Live(refresh_per_second=10, console=self.console) as live:
-
-            class StreamUpdater:
-                content = []
-
-                def update(self, chunk: str):
-                    self.content.append(chunk)
-                    panel = Panel(
-                        Markdown("".join(self.content)),
-                        title=f"🤖 {agent_name}",
-                        border_style="green",
-                        padding=(1, 2),
-                    )
-                    live.update(panel)
-
-            yield StreamUpdater()
-
-    def display_thinking(self, thought: str):
-        """Display agent's thinking process"""
-        if thought:
-            self.console.print(Panel(thought, title="💭 Thinking", border_style="yellow", padding=(1, 2)))
-
-    def display_tools(self, tools: list):
-        """Display available tools in a table"""
-        table = Table(title="🛠️ Available Tools")
-        table.add_column("Tool Name", style="cyan")
-        table.add_column("Description", style="white")
-
-        for tool in tools:
-            func_info = tool["function"]
-            table.add_row(func_info["name"], func_info["description"])
-
-        self.console.print(table)
-
-    def display_tool_call(self, tool_call: dict):
-        """Display tool call"""
-        tool_call_str = json.dumps(tool_call, indent=2)
-        self.console.print(Panel(tool_call_str, title="🛠️ Tool Call", border_style="green", padding=(1, 2)))
-
-    def display_tool_result(self, tool_result: dict):
-        """Display tool result"""
-        tool_result_str = json.dumps(tool_result, indent=2)
-        self.console.print(Panel(tool_result_str, title="🛠️ Tool Result", border_style="green", padding=(1, 2)))
-
-    def display_error(self, error: str):
-        """Display error message"""
-        self.console.print(Panel(error, title="❌ Error", border_style="red"))
-
-    def get_user_input(self) -> str:
-        """Get user input with rich prompt"""
-        return Prompt.ask("[bold blue]You[/bold blue]", console=self.console)
-
-    def display_info(self, message: str):
-        """Display info message"""
-        self.console.print(f"[bold cyan]ℹ️ {message}[/bold cyan]")
-
-    def clear_screen(self):
-        """Clear the screen"""
-        self.console.clear()
-
-    def handle_interrupt(self, interrupt) -> str | bool:
-        interrupt_type = interrupt.value["type"]
-        if interrupt_type == "text":
-            value = Prompt.ask(interrupt.value["question"])
-            return value
-        elif interrupt_type == "bool":
-            value = Prompt.ask(interrupt.value["question"], choices=["y", "n"], default="y")
-            return value
-        elif interrupt_type == "choice":
-            value = Prompt.ask(
-                interrupt.value["question"], choices=interrupt.value["choices"], default=interrupt.value["choices"][0]
-            )
-            return value
-        else:
-            raise ValueError(f"Invalid interrupt type: {interrupt.value['type']}")

universal_mcp/analytics.py

@@ -1,111 +0,0 @@
-import os
-import uuid
-from functools import lru_cache
-from importlib.metadata import version
-
-import posthog
-from loguru import logger
-
-
-class Analytics:
-    """A singleton class for tracking analytics events using PostHog.
-
-    This class handles the initialization of the PostHog client and provides
-    methods to track key events such as application loading and tool execution.
-    Telemetry can be disabled by setting the TELEMETRY_DISABLED environment
-    variable to "true".
-    """
-
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._initialize()
-        return cls._instance
-
-    def _initialize(self):
-        """Initializes the PostHog client and sets up analytics properties.
-
-        This internal method configures the PostHog API key and host.
-        It also determines if analytics should be enabled based on the
-        TELEMETRY_DISABLED environment variable and generates a unique
-        user ID.
-        """
-        posthog.host = "https://us.i.posthog.com"
-        posthog.api_key = "phc_6HXMDi8CjfIW0l04l34L7IDkpCDeOVz9cOz1KLAHXh8"
-        self.enabled = os.getenv("TELEMETRY_DISABLED", "false").lower() != "true"
-        self.user_id = str(uuid.uuid4())[:8]
-
-    @staticmethod
-    @lru_cache(maxsize=1)
-    def get_version():
-        """Retrieves the installed version of the universal_mcp package.
-
-        Uses importlib.metadata to get the package version.
-        Caches the result for efficiency.
-
-        Returns:
-            str: The package version string, or "unknown" if not found.
-        """
-        try:
-            return version("universal_mcp")
-        except ImportError:  # Should be PackageNotFoundError, but matching existing code
-            return "unknown"
-
-    def track_app_loaded(self, app_name: str):
-        """Tracks an event when an application is successfully loaded.
-
-        This event helps understand which applications are being utilized.
-
-        Args:
-            app_name (str): The name of the application that was loaded.
-        """
-        if not self.enabled:
-            return
-        try:
-            properties = {
-                "version": self.get_version(),
-                "app_name": app_name,
-                "user_id": self.user_id,
-            }
-            posthog.capture("app_loaded", properties=properties)
-        except Exception as e:
-            logger.error(f"Failed to track app_loaded event: {e}")
-
-    def track_tool_called(
-        self,
-        tool_name: str,
-        app_name: str,
-        status: str,
-        error: str | None = None,
-    ):
-        """Tracks an event when a tool is called within an application.
-
-        This event provides insights into tool usage patterns, success rates,
-        and potential errors.
-
-        Args:
-            tool_name (str): The name of the tool that was called.
-            app_name (str): The name of the application the tool belongs to.
-            status (str): The status of the tool call (e.g., "success", "error").
-            error (str, optional): The error message if the tool call failed.
-                                 Defaults to None.
-        """
-        if not self.enabled:
-            return
-        try:
-            properties = {
-                "tool_name": tool_name,
-                "app_name": app_name,
-                "status": status,
-                "error": error,
-                "version": self.get_version(),
-                "user_id": self.user_id,
-            }
-            posthog.capture("tool_called", properties=properties)
-        except Exception as e:
-            logger.error(f"Failed to track tool_called event: {e}")
-
-
-analytics = Analytics()

universal_mcp/applications/__init__.py

@@ -1,70 +0,0 @@
-from loguru import logger
-
-from universal_mcp.applications.application import (
-    APIApplication,
-    BaseApplication,
-    GraphQLApplication,
-)
-from universal_mcp.config import AppConfig
-from universal_mcp.utils.common import (
-    load_app_from_local_file,
-    load_app_from_local_folder,
-    load_app_from_package,
-    load_app_from_remote_file,
-    load_app_from_remote_zip,
-)
-
-app_cache: dict[str, type[BaseApplication]] = {}
-
-
-def app_from_slug(slug: str) -> type[BaseApplication]:
-    """
-    Dynamically resolve and return the application class based on slug.
-    """
-    return app_from_config(AppConfig(name=slug, source_type="package"))
-
-
-def app_from_config(config: AppConfig) -> type[BaseApplication]:
-    """
-    Dynamically resolve and return the application class based on AppConfig.
-    """
-    if config.name in app_cache:
-        return app_cache[config.name]
-
-    app_class = None
-    try:
-        match config.source_type:
-            case "package":
-                app_class = load_app_from_package(config)
-            case "local_folder":
-                app_class = load_app_from_local_folder(config)
-            case "remote_zip":
-                app_class = load_app_from_remote_zip(config)
-            case "remote_file":
-                app_class = load_app_from_remote_file(config)
-            case "local_file":
-                app_class = load_app_from_local_file(config)
-            case _:
-                raise ValueError(f"Unsupported source_type: {config.source_type}")
-
-    except Exception as e:
-        logger.error(
-            f"Failed to load application '{config.name}' from source '{config.source_type}': {e}",
-            exc_info=True,
-        )
-        raise
-
-    if not app_class:
-        raise ImportError(f"Could not load application class for '{config.name}'")
-
-    logger.debug(f"Loaded class '{app_class.__name__}' for app '{config.name}'")
-    app_cache[config.name] = app_class
-    return app_class
-
-
-__all__ = [
-    "app_from_config",
-    "BaseApplication",
-    "APIApplication",
-    "GraphQLApplication",
-]

universal_mcp/utils/common.py

@@ -1,278 +0,0 @@
-import hashlib
-import importlib
-import importlib.util
-import inspect
-import io
-import os
-import subprocess
-import sys
-import zipfile
-from pathlib import Path
-
-import httpx
-from loguru import logger
-
-from universal_mcp.applications.application import BaseApplication
-from universal_mcp.config import AppConfig
-
-# --- Global Constants and Setup ---
-
-UNIVERSAL_MCP_HOME = Path.home() / ".universal-mcp" / "packages"
-REMOTE_CACHE_DIR = UNIVERSAL_MCP_HOME / "remote_cache"
-
-if not UNIVERSAL_MCP_HOME.exists():
-    UNIVERSAL_MCP_HOME.mkdir(parents=True, exist_ok=True)
-if not REMOTE_CACHE_DIR.exists():
-    REMOTE_CACHE_DIR.mkdir(exist_ok=True)
-
-# set python path to include the universal-mcp home directory
-if str(UNIVERSAL_MCP_HOME) not in sys.path:
-    sys.path.append(str(UNIVERSAL_MCP_HOME))
-
-
-# --- Default Name Generators ---
-
-
-def get_default_repository_path(slug: str) -> str:
-    """
-    Convert a repository slug to a repository URL.
-    """
-    slug = slug.strip().lower()
-    return f"universal-mcp-{slug}"
-
-
-def get_default_package_name(slug: str) -> str:
-    """
-    Convert a repository slug to a package name.
-    """
-    slug = slug.strip().lower()
-    package_name = f"universal_mcp_{slug.replace('-', '_')}"
-    return package_name
-
-
-def get_default_module_path(slug: str) -> str:
-    """
-    Convert a repository slug to a module path.
-    """
-    package_name = get_default_package_name(slug)
-    module_path = f"{package_name}.app"
-    return module_path
-
-
-def get_default_class_name(slug: str) -> str:
-    """
-    Convert a repository slug to a class name.
-    """
-    slug = slug.strip().lower()
-    class_name = "".join(part.capitalize() for part in slug.split("-")) + "App"
-    return class_name
-
-
-# --- Installation and Loading Helpers ---
-
-
-def install_or_upgrade_package(package_name: str, repository_path: str):
-    """
-    Helper to install a package via pip from the universal-mcp GitHub repository.
-    """
-    uv_path = os.getenv("UV_PATH")
-    uv_executable = str(Path(uv_path) / "uv") if uv_path else "uv"
-    logger.info(f"Using uv executable: {uv_executable}")
-    cmd = [
-        uv_executable,
-        "pip",
-        "install",
-        "--upgrade",
-        repository_path,
-        "--target",
-        str(UNIVERSAL_MCP_HOME),
-    ]
-    logger.debug(f"Installing package '{package_name}' with command: {' '.join(cmd)}")
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        if result.stdout:
-            logger.info(f"Command stdout: {result.stdout}")
-        if result.stderr:
-            logger.warning(f"Command stderr: {result.stderr}")
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Installation failed for '{package_name}': {e}")
-        logger.error(f"Command stdout:\n{e.stdout}")
-        logger.error(f"Command stderr:\n{e.stderr}")
-        raise ModuleNotFoundError(f"Installation failed for package '{package_name}'") from e
-    else:
-        logger.debug(f"Package {package_name} installed successfully")
-
-
-def install_dependencies_from_path(project_root: Path, target_install_dir: Path):
-    """
-    Installs dependencies from pyproject.toml or requirements.txt found in project_root.
-    """
-    uv_path = os.getenv("UV_PATH")
-    uv_executable = str(Path(uv_path) / "uv") if uv_path else "uv"
-    cmd = []
-
-    if (project_root / "pyproject.toml").exists():
-        logger.info(f"Found pyproject.toml in {project_root}, installing dependencies.")
-        cmd = [uv_executable, "pip", "install", ".", "--target", str(target_install_dir)]
-    elif (project_root / "requirements.txt").exists():
-        logger.info(f"Found requirements.txt in {project_root}, installing dependencies.")
-        cmd = [
-            uv_executable,
-            "pip",
-            "install",
-            "-r",
-            "requirements.txt",
-            "--target",
-            str(target_install_dir),
-        ]
-    else:
-        logger.debug(f"No dependency file found in {project_root}. Skipping dependency installation.")
-        return
-
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True, cwd=project_root)
-        if result.stdout:
-            logger.info(f"Dependency installation stdout:\n{result.stdout}")
-        if result.stderr:
-            logger.warning(f"Dependency installation stderr:\n{result.stderr}")
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Dependency installation failed for project at '{project_root}': {e}")
-        logger.error(f"Command stdout:\n{e.stdout}")
-        logger.error(f"Command stderr:\n{e.stderr}")
-        raise RuntimeError(f"Failed to install dependencies for {project_root}") from e
-
-
-def _load_class_from_project_root(project_root: Path, config: AppConfig) -> type[BaseApplication]:
-    """Internal helper to load an application class from a local project directory."""
-    logger.debug(f"Attempting to load '{config.name}' from project root: {project_root}")
-    src_path = project_root / "src"
-    if not src_path.is_dir():
-        raise FileNotFoundError(f"Required 'src' directory not found in project at {project_root}")
-
-    install_dependencies_from_path(project_root, UNIVERSAL_MCP_HOME)
-
-    if str(src_path) not in sys.path:
-        sys.path.insert(0, str(src_path))
-        logger.debug(f"Added to sys.path: {src_path}")
-
-    module_path_str = get_default_module_path(config.name)
-    class_name_str = get_default_class_name(config.name)
-
-    try:
-        module = importlib.import_module(module_path_str)
-        importlib.reload(module)  # Reload to pick up changes
-        app_class = getattr(module, class_name_str)
-        return app_class
-    except (ModuleNotFoundError, AttributeError) as e:
-        logger.error(f"Failed to load module/class '{module_path_str}.{class_name_str}': {e}")
-        raise
-
-
-# --- Application Loaders ---
-
-
-def load_app_from_package(config: AppConfig) -> type[BaseApplication]:
-    """Loads an application from a pip-installable package."""
-    logger.debug(f"Loading '{config.name}' as a package.")
-    slug = config.name
-    repository_path = get_default_repository_path(slug)
-    package_name = get_default_package_name(slug)
-    install_or_upgrade_package(package_name, repository_path)
-
-    module_path_str = get_default_module_path(slug)
-    class_name_str = get_default_class_name(slug)
-    module = importlib.import_module(module_path_str)
-    return getattr(module, class_name_str)
-
-
-def load_app_from_local_folder(config: AppConfig) -> type[BaseApplication]:
-    """Loads an application from a local folder path."""
-    project_path = Path(config.source_path).resolve()
-    return _load_class_from_project_root(project_path, config)
-
-
-def load_app_from_remote_zip(config: AppConfig) -> type[BaseApplication]:
-    """Downloads, caches, and loads an application from a remote .zip file."""
-    url_hash = hashlib.sha256(config.source_path.encode()).hexdigest()[:16]
-    project_path = REMOTE_CACHE_DIR / f"{config.name}-{url_hash}"
-
-    if not project_path.exists():
-        logger.info(f"Downloading remote project for '{config.name}' from {config.source_path}")
-        project_path.mkdir(parents=True, exist_ok=True)
-        response = httpx.get(config.source_path, follow_redirects=True, timeout=120)
-        response.raise_for_status()
-        with zipfile.ZipFile(io.BytesIO(response.content)) as z:
-            z.extractall(project_path)
-        logger.info(f"Extracted remote project to {project_path}")
-
-    return _load_class_from_project_root(project_path, config)
-
-
-def load_app_from_remote_file(config: AppConfig) -> type[BaseApplication]:
-    """Downloads, caches, and loads an application from a remote Python file."""
-    logger.debug(f"Loading '{config.name}' as a remote file from {config.source_path}")
-    url_hash = hashlib.sha256(config.source_path.encode()).hexdigest()[:16]
-    cached_file_path = REMOTE_CACHE_DIR / f"{config.name}-{url_hash}.py"
-
-    if not cached_file_path.exists():
-        logger.info(f"Downloading remote file for '{config.name}' from {config.source_path}")
-        try:
-            response = httpx.get(config.source_path, follow_redirects=True, timeout=60)
-            response.raise_for_status()
-            cached_file_path.write_text(response.text, encoding="utf-8")
-            logger.info(f"Cached remote file to {cached_file_path}")
-        except httpx.HTTPStatusError as e:
-            logger.error(f"Failed to download remote file: {e.response.status_code} {e.response.reason_phrase}")
-            raise
-        except Exception as e:
-            logger.error(f"An unexpected error occurred during download: {e}")
-            raise
-
-    if not cached_file_path.stat().st_size > 0:
-        raise ImportError(f"Remote file at {cached_file_path} is empty.")
-
-    module_name = f"remote_app_{config.name}_{url_hash}"
-    spec = importlib.util.spec_from_file_location(module_name, cached_file_path)
-    if spec is None or spec.loader is None:
-        raise ImportError(f"Could not create module spec for {cached_file_path}")
-
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)
-
-    for name, obj in inspect.getmembers(module, inspect.isclass):
-        if obj.__module__ == module_name and issubclass(obj, BaseApplication) and obj is not BaseApplication:
-            logger.debug(f"Found application class '{name}' defined in remote file for '{config.name}'.")
-            return obj
-
-    raise ImportError(f"No class inheriting from BaseApplication found in remote file {config.source_path}")
-
-
-def load_app_from_local_file(config: AppConfig) -> type[BaseApplication]:
-    """Loads an application from a local Python file."""
-    logger.debug(f"Loading '{config.name}' as a local file from {config.source_path}")
-    local_file_path = Path(config.source_path).resolve()
-
-    if not local_file_path.is_file():
-        raise FileNotFoundError(f"Local file not found at: {local_file_path}")
-
-    if not local_file_path.stat().st_size > 0:
-        raise ImportError(f"Local file at {local_file_path} is empty.")
-
-    path_hash = hashlib.sha256(str(local_file_path).encode()).hexdigest()[:16]
-    module_name = f"local_app_{config.name}_{path_hash}"
-
-    spec = importlib.util.spec_from_file_location(module_name, local_file_path)
-    if spec is None or spec.loader is None:
-        raise ImportError(f"Could not create module spec for {local_file_path}")
-
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)
-
-    for name, obj in inspect.getmembers(module, inspect.isclass):
-        if obj.__module__ == module_name and issubclass(obj, BaseApplication) and obj is not BaseApplication:
-            logger.debug(f"Found application class '{name}' in local file for '{config.name}'.")
-            return obj
-
-    raise ImportError(f"No class inheriting from BaseApplication found in local file {config.source_path}")