universal-mcp 0.1.13rc14__py3-none-any.whl → 0.1.15rc5__py3-none-any.whl

universal_mcp/cli.py

@@ -2,7 +2,7 @@ import re
 from pathlib import Path
 
 import typer
-from rich import print as rprint
+from rich.console import Console
 from rich.panel import Panel
 
 from universal_mcp.utils.installation import (
@@ -11,6 +11,9 @@ from universal_mcp.utils.installation import (
     install_cursor,
 )
 
+# Setup rich console and logging
+console = Console()
+
 app = typer.Typer()
 
 
@@ -39,7 +42,7 @@ def generate(
     from universal_mcp.utils.api_generator import generate_api_from_schema
 
     if not schema_path.exists():
-        typer.echo(f"Error: Schema file {schema_path} does not exist", err=True)
+        console.print(f"[red]Error: Schema file {schema_path} does not exist[/red]")
         raise typer.Exit(1)
 
     try:
@@ -49,10 +52,10 @@ def generate(
             output_path=output_path,
             class_name=class_name,
         )
-        typer.echo("API client successfully generated and installed.")
-        typer.echo(f"Application file: {app_file}")
+        console.print("[green]API client successfully generated and installed.[/green]")
+        console.print(f"[blue]Application file: {app_file}[/blue]")
     except Exception as e:
-        typer.echo(f"Error generating API client: {e}", err=True)
+        console.print(f"[red]Error generating API client: {e}[/red]")
         raise typer.Exit(1) from e
 
 
@@ -70,7 +73,7 @@ def readme(
     from universal_mcp.utils.readme import generate_readme
 
     readme_file = generate_readme(file_path, class_name)
-    typer.echo(f"README.md file generated at: {readme_file}")
+    console.print(f"[green]README.md file generated at: {readme_file}[/green]")
 
 
 @app.command()
@@ -91,14 +94,14 @@ def docgen(
     from universal_mcp.utils.docgen import process_file
 
     if not file_path.exists():
-        typer.echo(f"Error: File not found: {file_path}", err=True)
+        console.print(f"[red]Error: File not found: {file_path}[/red]")
         raise typer.Exit(1)
 
     try:
         processed = process_file(str(file_path), model)
-        typer.echo(f"Successfully processed {processed} functions")
+        console.print(f"[green]Successfully processed {processed} functions[/green]")
     except Exception as e:
-        typer.echo(f"Error: {e}", err=True)
+        console.print(f"[red]Error: {e}[/red]")
         raise typer.Exit(1) from e
 
 
@@ -130,15 +133,14 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
     supported_apps = get_supported_apps()
 
     if app_name not in supported_apps:
-        typer.echo("Available apps:")
+        console.print("[yellow]Available apps:[/yellow]")
         for app in supported_apps:
-            typer.echo(f"  - {app}")
-        typer.echo(f"\nApp '{app_name}' not supported")
+            console.print(f"  - {app}")
+        console.print(f"\n[red]App '{app_name}' not supported[/red]")
         raise typer.Exit(1)
 
     # Print instructions before asking for API key
-
-    rprint(
+    console.print(
         Panel(
             "API key is required. Visit [link]https://agentr.dev[/link] to create an API key.",
             title="Instruction",
@@ -156,15 +158,15 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
     )
     try:
         if app_name == "claude":
-            typer.echo(f"Installing mcp server for: {app_name}")
+            console.print(f"[blue]Installing mcp server for: {app_name}[/blue]")
             install_claude(api_key)
-            typer.echo("App installed successfully")
+            console.print("[green]App installed successfully[/green]")
         elif app_name == "cursor":
-            typer.echo(f"Installing mcp server for: {app_name}")
+            console.print(f"[blue]Installing mcp server for: {app_name}[/blue]")
             install_cursor(api_key)
-            typer.echo("App installed successfully")
+            console.print("[green]App installed successfully[/green]")
     except Exception as e:
-        typer.echo(f"Error installing app: {e}", err=True)
+        console.print(f"[red]Error installing app: {e}[/red]")
         raise typer.Exit(1) from e
 
 
@@ -198,9 +200,8 @@ def init(
 
     def validate_pattern(value: str, field_name: str) -> None:
         if not re.match(NAME_PATTERN, value):
-            typer.secho(
-                f"❌ Invalid {field_name}; only letters, numbers, hyphens, and underscores allowed.",
-                fg=typer.colors.RED,
+            console.print(
+                f"[red]❌ Invalid {field_name}; only letters, numbers, hyphens, and underscores allowed.[/red]"
             )
             raise typer.Exit(code=1)
 
@@ -224,20 +225,17 @@ def init(
     if not output_dir.exists():
         try:
             output_dir.mkdir(parents=True, exist_ok=True)
-            typer.secho(
-                f"✅ Created output directory at '{output_dir}'",
-                fg=typer.colors.GREEN,
+            console.print(
+                f"[green]✅ Created output directory at '{output_dir}'[/green]"
             )
         except Exception as e:
-            typer.secho(
-                f"❌ Failed to create output directory '{output_dir}': {e}",
-                fg=typer.colors.RED,
+            console.print(
+                f"[red]❌ Failed to create output directory '{output_dir}': {e}[/red]"
             )
             raise typer.Exit(code=1) from e
     elif not output_dir.is_dir():
-        typer.secho(
-            f"❌ Output path '{output_dir}' exists but is not a directory.",
-            fg=typer.colors.RED,
+        console.print(
+            f"[red]❌ Output path '{output_dir}' exists but is not a directory.[/red]"
         )
         raise typer.Exit(code=1)
 
@@ -249,13 +247,12 @@ def init(
             prompt_suffix=" (api_key, oauth, agentr, none): ",
         ).lower()
     if integration_type not in ("api_key", "oauth", "agentr", "none"):
-        typer.secho(
-            "❌ Integration type must be one of: api_key, oauth, agentr, none",
-            fg=typer.colors.RED,
+        console.print(
+            "[red]❌ Integration type must be one of: api_key, oauth, agentr, none[/red]"
         )
         raise typer.Exit(code=1)
 
-    typer.secho("🚀 Generating project using cookiecutter...", fg=typer.colors.BLUE)
+    console.print("[blue]🚀 Generating project using cookiecutter...[/blue]")
     try:
         cookiecutter(
             "https://github.com/AgentrDev/universal-mcp-app-template.git",
@@ -267,11 +264,11 @@ def init(
             },
         )
     except Exception as exc:
-        typer.secho(f"❌ Project generation failed: {exc}", fg=typer.colors.RED)
+        console.print(f"❌ Project generation failed: {exc}", fg=typer.colors.RED)
         raise typer.Exit(code=1) from exc
 
     project_dir = output_dir / f"universal-mcp-{app_name}"
-    typer.secho(f"✅ Project created at {project_dir}", fg=typer.colors.GREEN)
+    console.print(f"✅ Project created at {project_dir}", fg=typer.colors.GREEN)
 
 
 if __name__ == "__main__":

universal_mcp/config.py

@@ -1,32 +1,105 @@
-from typing import Literal
+from pathlib import Path
+from typing import Any, Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, SecretStr, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class StoreConfig(BaseModel):
-    name: str = "universal_mcp"
-    type: Literal["memory", "environment", "keyring", "agentr"]
+    """Configuration for credential storage."""
+
+    name: str = Field(default="universal_mcp", description="Name of the store")
+    type: Literal["memory", "environment", "keyring", "agentr"] = Field(
+        default="memory", description="Type of credential storage to use"
+    )
+    path: Path | None = Field(
+        default=None, description="Path to store credentials (if applicable)"
+    )
 
 
 class IntegrationConfig(BaseModel):
-    name: str
-    type: Literal["api_key", "oauth", "agentr", "oauth2"]
-    credentials: dict | None = None
-    store: StoreConfig | None = None
+    """Configuration for API integrations."""
+
+    name: str = Field(..., description="Name of the integration")
+    type: Literal["api_key", "oauth", "agentr", "oauth2"] = Field(
+        default="api_key", description="Type of authentication to use"
+    )
+    credentials: dict[str, Any] | None = Field(
+        default=None, description="Integration-specific credentials"
+    )
+    store: StoreConfig | None = Field(
+        default=None, description="Store configuration for credentials"
+    )
 
 
 class AppConfig(BaseModel):
-    name: str
-    integration: IntegrationConfig | None = None
-    actions: list[str] | None = None
-
-
-class ServerConfig(BaseModel):
-    name: str = "Universal MCP"
-    description: str = "Universal MCP"
-    api_key: str | None = None
-    type: Literal["local", "agentr"] = "agentr"
-    transport: Literal["stdio", "sse", "http"] = "stdio"
-    port: int = 8005
-    apps: list[AppConfig] | None = None
-    store: StoreConfig | None = None
+    """Configuration for individual applications."""
+
+    name: str = Field(..., description="Name of the application")
+    integration: IntegrationConfig | None = Field(
+        default=None, description="Integration configuration"
+    )
+    actions: list[str] | None = Field(
+        default=None, description="List of available actions"
+    )
+
+
+class ServerConfig(BaseSettings):
+    """Main server configuration."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="MCP_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True,
+        extra="allow",
+    )
+
+    name: str = Field(default="Universal MCP", description="Name of the MCP server")
+    description: str = Field(
+        default="Universal MCP", description="Description of the MCP server"
+    )
+    api_key: SecretStr | None = Field(
+        default=None, description="API key for authentication"
+    )
+    type: Literal["local", "agentr"] = Field(
+        default="agentr", description="Type of server deployment"
+    )
+    transport: Literal["stdio", "sse", "http"] = Field(
+        default="stdio", description="Transport protocol to use"
+    )
+    port: int = Field(
+        default=8005, description="Port to run the server on (if applicable)"
+    )
+    host: str = Field(
+        default="localhost", description="Host to bind the server to (if applicable)"
+    )
+    apps: list[AppConfig] | None = Field(
+        default=None, description="List of configured applications"
+    )
+    store: StoreConfig | None = Field(
+        default=None, description="Default store configuration"
+    )
+    debug: bool = Field(default=False, description="Enable debug mode")
+    log_level: str = Field(default="INFO", description="Logging level")
+    max_connections: int = Field(
+        default=100, description="Maximum number of concurrent connections"
+    )
+    request_timeout: int = Field(
+        default=60, description="Default request timeout in seconds"
+    )
+
+    @field_validator("log_level", mode="before")
+    def validate_log_level(cls, v: str) -> str:
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if v.upper() not in valid_levels:
+            raise ValueError(
+                f"Invalid log level. Must be one of: {', '.join(valid_levels)}"
+            )
+        return v.upper()
+
+    @field_validator("port", mode="before")
+    def validate_port(cls, v: int) -> int:
+        if not 1 <= v <= 65535:
+            raise ValueError("Port must be between 1 and 65535")
+        return v

universal_mcp/logger.py

@@ -1,17 +1,68 @@
 import sys
+from datetime import datetime
+from pathlib import Path
 
 from loguru import logger
 
 
-def setup_logger():
+def setup_logger(
+    log_file: Path | None = None,
+    rotation: str = "10 MB",
+    retention: str = "1 week",
+    compression: str = "zip",
+    level: str = "INFO",
+    format: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+) -> None:
+    """Setup the logger with both stderr and optional file logging with rotation.
+
+    Args:
+        log_file: Optional path to log file. If None, only stderr logging is enabled.
+        rotation: When to rotate the log file. Can be size (e.g., "10 MB") or time (e.g., "1 day").
+        retention: How long to keep rotated log files (e.g., "1 week").
+        compression: Compression format for rotated logs ("zip", "gz", or None).
+        level: Minimum logging level.
+        format: Log message format string.
+    """
+    # Remove default handler
     logger.remove()
-    # STDOUT cant be used as a sink because it will break the stream
-    # logger.add(
-    #     sink=sys.stdout,
-    #     level="INFO",
-    # )
-    # STDERR
+
+    # Add stderr handler
     logger.add(
         sink=sys.stderr,
-        level="INFO",
+        level=level,
+        format=format,
+        enqueue=True,
+        backtrace=True,
+        diagnose=True,
     )
+
+    # Add file handler if log_file is specified
+    if log_file:
+        # Ensure log directory exists
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.add(
+            sink=str(log_file),
+            rotation=rotation,
+            retention=retention,
+            compression=compression,
+            level=level,
+            format=format,
+            enqueue=True,
+            backtrace=True,
+            diagnose=True,
+        )
+
+
+def get_log_file_path(app_name: str) -> Path:
+    """Get a standardized log file path for an application.
+
+    Args:
+        app_name: Name of the application.
+
+    Returns:
+        Path to the log file in the format: logs/{app_name}/{app_name}_{date}.log
+    """
+    date_str = datetime.now().strftime("%Y%m%d")
+    log_dir = Path("logs") / app_name
+    return log_dir / f"{app_name}_{date_str}.log"

universal_mcp/servers/__init__.py

@@ -1,5 +1,5 @@
 from universal_mcp.config import ServerConfig
-from universal_mcp.servers.server import AgentRServer, LocalServer
+from universal_mcp.servers.server import AgentRServer, LocalServer, SingleMCPServer
 
 
 def server_from_config(config: ServerConfig):
@@ -12,4 +12,4 @@ def server_from_config(config: ServerConfig):
         raise ValueError(f"Unsupported server type: {config.type}")
 
 
-__all__ = [AgentRServer, LocalServer, server_from_config]
+__all__ = [AgentRServer, LocalServer, SingleMCPServer, server_from_config]

universal_mcp/templates/README.md.j2

@@ -2,47 +2,6 @@
 
 An MCP Server for the {{ name }} API.
 
-## 📋 Prerequisites
-
-Before you begin, ensure you have met the following requirements:
-* Python 3.11+ (Recommended)
-* [uv](https://github.com/astral-sh/uv) installed globally (`pip install uv`)
-
-## 🛠️ Setup Instructions
-
-Follow these steps to get the development environment up and running:
-
-### 1. Sync Project Dependencies
-Navigate to the project root directory (where `pyproject.toml` is located).
-```bash
-uv sync
-```
-This command uses `uv` to install all dependencies listed in `pyproject.toml` into a virtual environment (`.venv`) located in the project root.
-
-### 2. Activate the Virtual Environment
-Activating the virtual environment ensures that you are using the project's specific dependencies and Python interpreter.
-- On **Linux/macOS**:
-```bash
-source .venv/bin/activate
-```
-- On **Windows**:
-```bash
-.venv\\Scripts\\activate
-```
-
-### 3. Start the MCP Inspector
-Use the MCP CLI to start the application in development mode.
-```bash
-mcp dev src/{{ name.lower() }}/mcp.py
-```
-The MCP inspector should now be running. Check the console output for the exact address and port.
-
-## 🔌 Supported Integrations
-
-- AgentR
-- API Key (Coming Soon)
-- OAuth (Coming Soon)
-
 ## 🛠️ Tool List
 
 This is automatically generated from OpenAPI schema for the {{ name }} API.
@@ -56,38 +15,3 @@ This is automatically generated from OpenAPI schema for the {{ name }} API.
 {% else %}
 No tools with documentation were found in this API client.
 {% endif %}
-
-## 📁 Project Structure
-
-The generated project has a standard layout:
-```
-.
-├── src/                  # Source code directory
-│   └── {{ name.lower() }}/
-│       ├── __init__.py
-│       └── mcp.py        # Server is launched here
-│       └── app.py        # Application tools are defined here
-├── tests/                # Directory for project tests
-├── .env                  # Environment variables (for local development)
-├── pyproject.toml        # Project dependencies managed by uv
-├── README.md             # This file
-```
-
-## 📝 License
-
-This project is licensed under the MIT License.
-
----
-
-_This project was generated using **MCP CLI** — Happy coding! 🚀_
-
-## Usage
-
-- Login to AgentR
-- Follow the quickstart guide to setup MCP Server for your client
-- Visit Apps Store and enable the {{ name }} app
-- Restart the MCP Server
-
-### Local Development
-
-- Follow the README to test with the local MCP Server 

universal_mcp/tools/__init__.py

@@ -1,3 +1,4 @@
-from .tools import Tool, ToolManager
+from .manager import ToolManager
+from .tools import Tool
 
 __all__ = ["Tool", "ToolManager"]

universal_mcp/tools/adapters.py

@@ -41,3 +41,17 @@ def convert_tool_to_langchain_tool(
         coroutine=call_tool,
         response_format="content",
     )
+
+
+def convert_tool_to_openai_tool(
+    tool: Tool,
+):
+    """Convert a Tool object to an OpenAI function."""
+    return {
+        "type": "function",
+        "function": {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": tool.parameters,
+        },
+    }

universal_mcp/tools/func_metadata.py

@@ -61,7 +61,7 @@ class ArgModelBase(BaseModel):
         That is, sub-models etc are not dumped - they are kept as pydantic models.
         """
         kwargs: dict[str, Any] = {}
-        for field_name in self.model_fields:
+        for field_name in self.__class__.model_fields:
             kwargs[field_name] = getattr(self, field_name)
         return kwargs
 

universal_mcp/tools/manager.py

@@ -0,0 +1,180 @@
+from collections.abc import Callable
+from typing import Any, Literal
+
+from loguru import logger
+
+from universal_mcp.analytics import analytics
+from universal_mcp.applications.application import BaseApplication
+from universal_mcp.exceptions import ToolError
+from universal_mcp.tools.adapters import (
+    convert_tool_to_langchain_tool,
+    convert_tool_to_mcp_tool,
+    convert_tool_to_openai_tool,
+)
+from universal_mcp.tools.tools import Tool
+
+
+class ToolManager:
+    """Manages FastMCP tools."""
+
+    def __init__(self, warn_on_duplicate_tools: bool = True):
+        self._tools: dict[str, Tool] = {}
+        self.warn_on_duplicate_tools = warn_on_duplicate_tools
+
+    def get_tool(self, name: str) -> Tool | None:
+        """Get tool by name."""
+        return self._tools.get(name)
+
+    def list_tools(
+        self, format: Literal["mcp", "langchain", "openai"] = "mcp"
+    ) -> list[Tool]:
+        """List all registered tools."""
+        if format == "mcp":
+            return [convert_tool_to_mcp_tool(tool) for tool in self._tools.values()]
+        elif format == "langchain":
+            return [
+                convert_tool_to_langchain_tool(tool) for tool in self._tools.values()
+            ]
+        elif format == "openai":
+            return [convert_tool_to_openai_tool(tool) for tool in self._tools.values()]
+        else:
+            raise ValueError(f"Invalid format: {format}")
+
+    # Modified add_tool to accept name override explicitly
+    def add_tool(
+        self, fn: Callable[..., Any] | Tool, name: str | None = None
+    ) -> Tool:  # Changed any to Any
+        """Add a tool to the server, allowing name override."""
+        # Create the Tool object using the provided name if available
+        tool = fn if isinstance(fn, Tool) else Tool.from_function(fn, name=name)
+        existing = self._tools.get(tool.name)
+        if existing:
+            if self.warn_on_duplicate_tools:
+                # Check if it's the *exact* same function object being added again
+                if existing.fn is not tool.fn:
+                    logger.warning(
+                        f"Tool name '{tool.name}' conflicts with an existing tool. Skipping addition of new function."
+                    )
+                else:
+                    logger.debug(
+                        f"Tool '{tool.name}' with the same function already exists."
+                    )
+            return existing  # Return the existing tool if name conflicts
+
+        logger.debug(f"Adding tool: {tool.name}")
+        self._tools[tool.name] = tool
+        return tool
+
+    async def call_tool(
+        self,
+        name: str,
+        arguments: dict[str, Any],
+        context=None,
+    ) -> Any:
+        """Call a tool by name with arguments."""
+        tool = self.get_tool(name)
+        if not tool:
+            raise ToolError(f"Unknown tool: {name}")
+        try:
+            result = await tool.run(arguments)
+            analytics.track_tool_called(name, "success")
+            return result
+        except Exception as e:
+            analytics.track_tool_called(name, "error", str(e))
+            raise
+
+    def get_tools_by_tags(self, tags: list[str]) -> list[Tool]:
+        """Get tools by tags."""
+        return [
+            tool
+            for tool in self._tools.values()
+            if any(tag in tool.tags for tag in tags)
+        ]
+
+    def register_tools_from_app(
+        self,
+        app: BaseApplication,
+        tools: list[str] | None = None,
+        tags: list[str] | None = None,
+    ) -> None:
+        try:
+            available_tool_functions = app.list_tools()
+        except TypeError as e:
+            logger.error(f"Error calling list_tools for app '{app.name}'. Error: {e}")
+            return
+        except Exception as e:
+            logger.error(f"Failed to get tool list from app '{app.name}': {e}")
+            return
+
+        if not isinstance(available_tool_functions, list):
+            logger.error(
+                f"App '{app.name}' list_tools() did not return a list. Skipping registration."
+            )
+            return
+
+        # Determine the effective filter lists *before* the loop for efficiency
+        # Use an empty list if None is passed, simplifies checks later
+        tools_name_filter = tools or []
+
+        # For tags, determine the filter list based on priority: passed 'tags' or default 'important'
+        # This list is only used if tools_name_filter is empty.
+        active_tags_filter = tags if tags else ["important"]  # Default filter
+
+        logger.debug(
+            f"Registering tools for '{app.name}'. Name filter: {tools_name_filter or 'None'}. Tag filter (if name filter empty): {active_tags_filter}"
+        )
+
+        for tool_func in available_tool_functions:
+            if not callable(tool_func):
+                logger.warning(
+                    f"Item returned by {app.name}.list_tools() is not callable: {tool_func}. Skipping."
+                )
+                continue
+
+            try:
+                # Create the Tool metadata object from the function.
+                # This parses docstring (including tags), gets signature etc.
+                tool_instance = Tool.from_function(tool_func)
+            except Exception as e:
+                logger.error(
+                    f"Failed to create Tool object from function '{getattr(tool_func, '__name__', 'unknown')}' in app '{app.name}': {e}"
+                )
+                continue  # Skip this tool if metadata creation fails
+
+            # --- Modify the Tool instance before filtering/registration ---
+            original_name = tool_instance.name
+            prefixed_name = f"{app.name}_{original_name}"
+            tool_instance.name = prefixed_name  # Update the name
+
+            # Add the app name itself as a tag for categorization
+            if app.name not in tool_instance.tags:
+                tool_instance.tags.append(app.name)
+
+            # --- Filtering Logic ---
+            should_register = False  # Default to not registering
+
+            if tools_name_filter:
+                # --- Primary Filter: Check against specific tool names ---
+                if tool_instance.name in tools_name_filter:
+                    should_register = True
+                    logger.debug(f"Tool '{tool_instance.name}' matched name filter.")
+                # If not in the name filter, it's skipped (should_register remains False)
+
+            else:
+                # --- Secondary Filter: Check against tags (since tools_name_filter is empty) ---
+                # Check if *any* tag in active_tags_filter exists in the tool's tags
+                # tool_instance.tags includes tags parsed from the docstring + app.name
+                if any(tag in tool_instance.tags for tag in active_tags_filter):
+                    should_register = True
+                    logger.debug(
+                        f"Tool '{tool_instance.name}' matched tag filter {active_tags_filter}."
+                    )
+                # else:
+                #     logger.debug(f"Tool '{tool_instance.name}' did NOT match tag filter {active_tags_filter}. Tool tags: {tool_instance.tags}")
+
+            # --- Add the tool if it passed the filters ---
+            if should_register:
+                # Pass the fully configured Tool *instance* to add_tool
+                self.add_tool(tool_instance)
+            # else: If not registered, optionally log it for debugging:
+            #    logger.trace(f"Tool '{tool_instance.name}' skipped due to filters.") # Use trace level

universal_mcp/tools/tools.py

@@ -1,94 +1,16 @@
-from __future__ import annotations as _annotations
-
 import inspect
 from collections.abc import Callable
-from typing import Any, Literal
+from typing import Any
 
 import httpx
-from loguru import logger
 from pydantic import BaseModel, Field
 
-from universal_mcp.analytics import analytics
-from universal_mcp.applications import BaseApplication
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.utils.docstring_parser import parse_docstring
 
 from .func_metadata import FuncMetadata
 
 
-def convert_tool_to_openai_tool(
-    tool: Tool,
-):
-    """Convert a Tool object to an OpenAI function."""
-    return {
-        "type": "function",
-        "function": {
-            "name": tool.name,
-            "description": tool.description,
-            "parameters": tool.parameters,
-        },
-    }
-
-
-def convert_tool_to_mcp_tool(
-    tool: Tool,
-):
-    from mcp.server.fastmcp.server import MCPTool
-
-    return MCPTool(
-        name=tool.name,
-        description=tool.description or "",
-        inputSchema=tool.parameters,
-    )
-
-
-def convert_tool_to_langchain_tool(
-    tool: Tool,
-):
-    """Convert a Tool object to a LangChain StructuredTool.
-
-    NOTE: this tool can be executed only in a context of an active MCP client session.
-
-    Args:
-        tool: Tool object to convert
-
-    Returns:
-        a LangChain StructuredTool
-    """
-    from langchain_core.tools import (  # Keep import inside if preferred, or move top
-        StructuredTool,
-        ToolException,
-    )
-
-    async def call_tool(
-        **arguments: dict[
-            str, any
-        ],  # arguments received here are validated by StructuredTool
-    ):
-        # tool.run already handles validation via fn_metadata.call_fn_with_arg_validation
-        # It should be able to handle the validated/coerced types from StructuredTool
-        try:
-            call_tool_result = await tool.run(arguments)
-            return call_tool_result
-        except ToolError as e:
-            # Langchain expects ToolException for controlled errors
-            raise ToolException(f"Error running tool '{tool.name}': {e}") from e
-        except Exception as e:
-            # Catch unexpected errors
-            raise ToolException(f"Unexpected error in tool '{tool.name}': {e}") from e
-
-    return StructuredTool(
-        name=tool.name,
-        description=tool.description
-        or f"Tool named {tool.name}.",  # Provide fallback description
-        coroutine=call_tool,
-        args_schema=tool.fn_metadata.arg_model,  # <<< --- ADD THIS LINE
-        # handle_tool_error=True, # Optional: Consider adding error handling config
-        # return_direct=False,    # Optional: Default is usually fine
-        # response_format="content", # This field might not be valid for StructuredTool, check LangChain docs if needed. Let's remove for now.
-    )
-
-
 class Tool(BaseModel):
     """Internal tool registration info."""
 
@@ -120,7 +42,7 @@ class Tool(BaseModel):
         cls,
         fn: Callable[..., Any],
         name: str | None = None,
-    ) -> Tool:
+    ) -> "Tool":
         """Create a Tool from a function."""
 
         func_name = name or fn.__name__
@@ -172,169 +94,3 @@ class Tool(BaseModel):
             raise ToolError(message) from e
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e
-
-
-class ToolManager:
-    """Manages FastMCP tools."""
-
-    def __init__(self, warn_on_duplicate_tools: bool = True):
-        self._tools: dict[str, Tool] = {}
-        self.warn_on_duplicate_tools = warn_on_duplicate_tools
-
-    def get_tool(self, name: str) -> Tool | None:
-        """Get tool by name."""
-        return self._tools.get(name)
-
-    def list_tools(
-        self, format: Literal["mcp", "langchain", "openai"] = "mcp"
-    ) -> list[Tool]:
-        """List all registered tools."""
-        if format == "mcp":
-            return [convert_tool_to_mcp_tool(tool) for tool in self._tools.values()]
-        elif format == "langchain":
-            return [
-                convert_tool_to_langchain_tool(tool) for tool in self._tools.values()
-            ]
-        elif format == "openai":
-            return [convert_tool_to_openai_tool(tool) for tool in self._tools.values()]
-        else:
-            raise ValueError(f"Invalid format: {format}")
-
-    # Modified add_tool to accept name override explicitly
-    def add_tool(
-        self, fn: Callable[..., Any] | Tool, name: str | None = None
-    ) -> Tool:  # Changed any to Any
-        """Add a tool to the server, allowing name override."""
-        # Create the Tool object using the provided name if available
-        tool = fn if isinstance(fn, Tool) else Tool.from_function(fn, name=name)
-        existing = self._tools.get(tool.name)
-        if existing:
-            if self.warn_on_duplicate_tools:
-                # Check if it's the *exact* same function object being added again
-                if existing.fn is not tool.fn:
-                    logger.warning(
-                        f"Tool name '{tool.name}' conflicts with an existing tool. Skipping addition of new function."
-                    )
-                else:
-                    logger.debug(
-                        f"Tool '{tool.name}' with the same function already exists."
-                    )
-            return existing  # Return the existing tool if name conflicts
-
-        logger.debug(f"Adding tool: {tool.name}")
-        self._tools[tool.name] = tool
-        return tool
-
-    async def call_tool(
-        self,
-        name: str,
-        arguments: dict[str, Any],
-        context=None,
-    ) -> Any:
-        """Call a tool by name with arguments."""
-        tool = self.get_tool(name)
-        if not tool:
-            raise ToolError(f"Unknown tool: {name}")
-        try:
-            result = await tool.run(arguments)
-            analytics.track_tool_called(name, "success")
-            return result
-        except Exception as e:
-            analytics.track_tool_called(name, "error", str(e))
-            raise
-
-    def get_tools_by_tags(self, tags: list[str]) -> list[Tool]:
-        """Get tools by tags."""
-        return [
-            tool
-            for tool in self._tools.values()
-            if any(tag in tool.tags for tag in tags)
-        ]
-
-    def register_tools_from_app(
-        self,
-        app: BaseApplication,
-        tools: list[str] | None = None,
-        tags: list[str] | None = None,
-    ) -> None:
-        try:
-            available_tool_functions = app.list_tools()
-        except TypeError as e:
-            logger.error(f"Error calling list_tools for app '{app.name}'. Error: {e}")
-            return
-        except Exception as e:
-            logger.error(f"Failed to get tool list from app '{app.name}': {e}")
-            return
-
-        if not isinstance(available_tool_functions, list):
-            logger.error(
-                f"App '{app.name}' list_tools() did not return a list. Skipping registration."
-            )
-            return
-
-        # Determine the effective filter lists *before* the loop for efficiency
-        # Use an empty list if None is passed, simplifies checks later
-        tools_name_filter = tools or []
-
-        # For tags, determine the filter list based on priority: passed 'tags' or default 'important'
-        # This list is only used if tools_name_filter is empty.
-        active_tags_filter = tags if tags else ["important"]  # Default filter
-
-        logger.debug(
-            f"Registering tools for '{app.name}'. Name filter: {tools_name_filter or 'None'}. Tag filter (if name filter empty): {active_tags_filter}"
-        )
-
-        for tool_func in available_tool_functions:
-            if not callable(tool_func):
-                logger.warning(
-                    f"Item returned by {app.name}.list_tools() is not callable: {tool_func}. Skipping."
-                )
-                continue
-
-            try:
-                # Create the Tool metadata object from the function.
-                # This parses docstring (including tags), gets signature etc.
-                tool_instance = Tool.from_function(tool_func)
-            except Exception as e:
-                logger.error(
-                    f"Failed to create Tool object from function '{getattr(tool_func, '__name__', 'unknown')}' in app '{app.name}': {e}"
-                )
-                continue  # Skip this tool if metadata creation fails
-
-            # --- Modify the Tool instance before filtering/registration ---
-            original_name = tool_instance.name
-            prefixed_name = f"{app.name}_{original_name}"
-            tool_instance.name = prefixed_name  # Update the name
-
-            # Add the app name itself as a tag for categorization
-            if app.name not in tool_instance.tags:
-                tool_instance.tags.append(app.name)
-
-            # --- Filtering Logic ---
-            should_register = False  # Default to not registering
-
-            if tools_name_filter:
-                # --- Primary Filter: Check against specific tool names ---
-                if tool_instance.name in tools_name_filter:
-                    should_register = True
-                    logger.debug(f"Tool '{tool_instance.name}' matched name filter.")
-                # If not in the name filter, it's skipped (should_register remains False)
-
-            else:
-                # --- Secondary Filter: Check against tags (since tools_name_filter is empty) ---
-                # Check if *any* tag in active_tags_filter exists in the tool's tags
-                # tool_instance.tags includes tags parsed from the docstring + app.name
-                if any(tag in tool_instance.tags for tag in active_tags_filter):
-                    should_register = True
-                    logger.debug(
-                        f"Tool '{tool_instance.name}' matched tag filter {active_tags_filter}."
-                    )
-                # else:
-                #     logger.debug(f"Tool '{tool_instance.name}' did NOT match tag filter {active_tags_filter}. Tool tags: {tool_instance.tags}")
-
-            # --- Add the tool if it passed the filters ---
-            if should_register:
-                # Pass the fully configured Tool *instance* to add_tool
-                self.add_tool(tool_instance)
-            # else: If not registered, optionally log it for debugging:
-            #    logger.trace(f"Tool '{tool_instance.name}' skipped due to filters.") # Use trace level

universal_mcp/utils/installation.py

@@ -61,7 +61,7 @@ def install_claude(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp[applications]@latest", "run"],
+        "args": ["universal_mcp@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
     with open(config_path, "w") as f:
@@ -90,7 +90,7 @@ def install_cursor(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp[applications]@latest", "run"],
+        "args": ["universal_mcp@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
 
@@ -120,7 +120,7 @@ def install_cline(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp[applications]@latest", "run"],
+        "args": ["universal_mcp@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
 
@@ -156,7 +156,7 @@ def install_continue(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp[applications]@latest", "run"],
+        "args": ["universal_mcp@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
 
@@ -192,7 +192,7 @@ def install_goose(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp[applications]@latest", "run"],
+        "args": ["universal_mcp@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
 
@@ -228,7 +228,7 @@ def install_windsurf(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp[applications]@latest", "run"],
+        "args": ["universal_mcp@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
 
@@ -267,7 +267,7 @@ def install_zed(api_key: str) -> None:
             server.update(
                 {
                     "command": get_uvx_path(),
-                    "args": ["universal_mcp[applications]@latest", "run"],
+                    "args": ["universal_mcp@latest", "run"],
                     "env": {"AGENTR_API_KEY": api_key},
                 }
             )
@@ -278,7 +278,7 @@ def install_zed(api_key: str) -> None:
             {
                 "name": "universal_mcp",
                 "command": get_uvx_path(),
-                "args": ["universal_mcp[applications]@latest", "run"],
+                "args": ["universal_mcp@latest", "run"],
                 "env": {"AGENTR_API_KEY": api_key},
             }
         )

universal_mcp/utils/openapi.py

@@ -1,6 +1,5 @@
 import json
 import re
-from functools import cache
 from pathlib import Path
 from typing import Any, Literal
 
@@ -80,65 +79,15 @@ def convert_to_snake_case(identifier: str) -> str:
     return result.lower()
 
 
-@cache
-def _resolve_schema_reference(reference, schema):
-    """
-    Resolve a JSON schema reference to its target schema.
-
-    Args:
-        reference (str): The reference string (e.g., '#/components/schemas/User')
-        schema (dict): The complete OpenAPI schema that contains the reference
-
-    Returns:
-        dict: The resolved schema, or None if not found
-    """
-    if not reference.startswith("#/"):
-        return None
-
-    # Split the reference path and navigate through the schema
-    parts = reference[2:].split("/")
-    current = schema
-
-    for part in parts:
-        if part in current:
-            current = current[part]
-        else:
-            return None
-
-    return current
-
-
-def _resolve_references(schema: dict[str, Any]):
-    """
-    Recursively walk the OpenAPI schema and inline all JSON Schema $ref references.
-    """
-
-    def _resolve(node):
-        if isinstance(node, dict):
-            # If this dict is a reference, replace it with the resolved schema
-            if "$ref" in node:
-                ref = node["$ref"]
-                resolved = _resolve_schema_reference(ref, schema)
-                # If resolution fails, leave the ref dict as-is
-                return _resolve(resolved) if resolved is not None else node
-            # Otherwise, recurse into each key/value
-            return {key: _resolve(value) for key, value in node.items()}
-        elif isinstance(node, list):
-            # Recurse into list elements
-            return [_resolve(item) for item in node]
-        # Primitive value, return as-is
-        return node
-
-    return _resolve(schema)
-
-
 def _load_and_resolve_references(path: Path):
+    from jsonref import replace_refs
+
     # Load the schema
     type = "yaml" if path.suffix == ".yaml" else "json"
     with open(path) as f:
         schema = yaml.safe_load(f) if type == "yaml" else json.load(f)
     # Resolve references
-    return _resolve_references(schema)
+    return replace_refs(schema)
 
 
 def _determine_return_type(operation: dict[str, Any]) -> str:

{universal_mcp-0.1.13rc14.dist-info → universal_mcp-0.1.15rc5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.13rc14
+Version: 0.1.15rc5
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT
@@ -8,6 +8,7 @@ Requires-Python: >=3.11
 Requires-Dist: cookiecutter>=2.6.0
 Requires-Dist: gql[all]>=3.5.2
 Requires-Dist: jinja2>=3.1.3
+Requires-Dist: jsonref>=1.1.0
 Requires-Dist: keyring>=25.6.0
 Requires-Dist: litellm>=1.30.7
 Requires-Dist: loguru>=0.7.3

{universal_mcp-0.1.13rc14.dist-info → universal_mcp-0.1.15rc5.dist-info}/RECORD

@@ -1,9 +1,9 @@
 universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/analytics.py,sha256=aGCg0Okpcy06W70qCA9I8_ySOiCgAtzJAIWAdhBsOeA,2212
-universal_mcp/cli.py,sha256=aQioMc0ZpE5uL9h_qrk_eS514H0woQOsTsjEzL6Khto,8552
-universal_mcp/config.py,sha256=sJaPI4q51CDPPG0z32rMJiE7a64eaa9nxbjJgYnaFA4,838
+universal_mcp/cli.py,sha256=XujnWHxz5NVxQjwu2BRHUcGC--Vp98M32n8hTsEqayI,8689
+universal_mcp/config.py,sha256=xqz5VNxtk6Clepjw-aK-HrgMFQLzFuxiDb1fuHGpbxE,3717
 universal_mcp/exceptions.py,sha256=WApedvzArNujD0gZfUofYBxjQo97ZDJLqDibtLWZoRk,373
-universal_mcp/logger.py,sha256=D947u1roUf6WqlcEsPpvmWDqGc8L41qF3MO1suK5O1Q,308
+universal_mcp/logger.py,sha256=JtAC8ImO74lvt5xepV3W5BIz-u3nZOAY1ecdhmQhub0,2081
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/applications/__init__.py,sha256=ZjV0P55Ej0vjIQ_bCSNatWTX-VphDJ6OGePWBu3bu3U,3196
 universal_mcp/applications/application.py,sha256=0eC9D4HHRwIGpuFusaCxTZ0u64U68VbBpRSxjxGB5y8,8152
@@ -11,29 +11,29 @@ universal_mcp/integrations/README.md,sha256=lTAPXO2nivcBe1q7JT6PRa6v9Ns_ZersQMId
 universal_mcp/integrations/__init__.py,sha256=tg6Yk59AEhwPsrTp0hZQ3NBfmJuYGu2sNCOXuph-h9k,922
 universal_mcp/integrations/integration.py,sha256=genBiaWuzCs-XCf3UD1j8PQYyGU3GiVO4uupSdJRHnA,12601
 universal_mcp/servers/README.md,sha256=ytFlgp8-LO0oogMrHkMOp8SvFTwgsKgv7XhBVZGNTbM,2284
-universal_mcp/servers/__init__.py,sha256=dDtvvMzbWskABlobTZHztrWMb3hbzgidza3BmEmIAD8,474
+universal_mcp/servers/__init__.py,sha256=etFrqXFODIl9oGeqQS-aUxzw4J6pjzYjHl4VPvQaR3A,508
 universal_mcp/servers/server.py,sha256=0oJQQUiwPdG2q79tzsVv3WPMV5YIFbF14PRvBF-SxMQ,9395
 universal_mcp/stores/README.md,sha256=jrPh_ow4ESH4BDGaSafilhOVaN8oQ9IFlFW-j5Z5hLA,2465
 universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
 universal_mcp/stores/store.py,sha256=lYaFd-9YKC404BPeqzNw_Xm3ziQjksZyvQtaW1yd9FM,6900
-universal_mcp/templates/README.md.j2,sha256=gNry-IrGUdumhgWyHFVxOKgXf_MR4RFK6SI6jF3Tuns,2564
+universal_mcp/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
 universal_mcp/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
 universal_mcp/tools/README.md,sha256=RuxliOFqV1ZEyeBdj3m8UKfkxAsfrxXh-b6V4ZGAk8I,2468
-universal_mcp/tools/__init__.py,sha256=hVL-elJLwD_K87Gpw_s2_o43sQRPyRNOnxlzt0_Pfn8,72
-universal_mcp/tools/adapters.py,sha256=2HvpyFiI0zg9dp0XshnG7t6KrVqFHM7hgtmgY1bsHN0,927
-universal_mcp/tools/func_metadata.py,sha256=f_5LdDNsOu1DpXvDUeZYiJswVmwGZz6IMPtpJJ5B2-Y,7975
-universal_mcp/tools/tools.py,sha256=9YzFbX0YHdz7RrVyKKBx-eyFEnYD4HPoUVtSAftgdk4,12889
+universal_mcp/tools/__init__.py,sha256=GgK8CAxskkoif4WCaXsjs4zTgqN9VcVMyQa2G2LaYJ4,92
+universal_mcp/tools/adapters.py,sha256=oCF042vsOKP9bUT6000YbYEmOpOiroXEnMdDMs847CU,1235
+universal_mcp/tools/func_metadata.py,sha256=bxcwwKkHcITZQXt1eal7rFr5NGCrC0SLSGZwOsyCVKo,7985
+universal_mcp/tools/manager.py,sha256=Ne37cLlyk0oku0iUXbc6BmzNH-3a98oWcpe_nlyZRtU,7516
+universal_mcp/tools/tools.py,sha256=2ddZdi618xTs36iM062Pc6cnIbVP17L4NRBMNiFuv1k,3306
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
 universal_mcp/utils/agentr.py,sha256=3sobve7Odk8pIAZm3RHTX4Rc21rkBClcXQgXXslbSUA,3490
 universal_mcp/utils/api_generator.py,sha256=x3LkJm3tXgl2qVQq-ZQW86w7IqbErEdFTfwBP3aOwyI,4763
 universal_mcp/utils/docgen.py,sha256=zPmZ-b-fK6xk-dwHEx2hwShN-iquPD_O15CGuPwlj2k,21870
 universal_mcp/utils/docstring_parser.py,sha256=j7aE-LLnBOPTJI0qXayf0NlYappzxICv5E_hUPNmAlc,11459
-universal_mcp/utils/dump_app_tools.py,sha256=9bQePJ4ZKzGtcIYrBgLxbKDOZmL7ajIAHhXljT_AlyA,2041
-universal_mcp/utils/installation.py,sha256=H6woSY5AljEy_m5KgiAlHtNfe8eygOu4ZXNs5Q4H_y4,10307
-universal_mcp/utils/openapi.py,sha256=GhUdSefVOrOFMw15ZAIaEma-XKu6ptHv65ds0g7ntBo,24924
+universal_mcp/utils/installation.py,sha256=1n5X_aIiuY8WNQn6Oji_gZ-aiRmNXxrg-qYRv-pGjxw,10195
+universal_mcp/utils/openapi.py,sha256=fd4rfiT_hFmEHtzGg-tM3FMSAn-AT0EskKfOc71--jE,23317
 universal_mcp/utils/readme.py,sha256=Q4E3RidWVg0ngYBGZCKcoA4eX6wlkCpvU-clU0E7Q20,3305
 universal_mcp/utils/singleton.py,sha256=kolHnbS9yd5C7z-tzaUAD16GgI-thqJXysNi3sZM4No,733
-universal_mcp-0.1.13rc14.dist-info/METADATA,sha256=2lpAZEt7uenPEs6meQ9c4kE65jno2gcWcIVZCHuxbxk,9804
-universal_mcp-0.1.13rc14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.13rc14.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.13rc14.dist-info/RECORD,,
+universal_mcp-0.1.15rc5.dist-info/METADATA,sha256=OXwhLXpEIbkAsrFWmwx6aO_nhtHjjhif2yN-2kthT_M,9833
+universal_mcp-0.1.15rc5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.15rc5.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.15rc5.dist-info/RECORD,,

universal_mcp/utils/dump_app_tools.py

@@ -1,78 +0,0 @@
-import csv
-from pathlib import Path
-
-from universal_mcp.applications import app_from_slug
-
-
-def discover_available_app_slugs():
-    apps_dir = Path(__file__).resolve().parent.parent / "applications"
-    app_slugs = []
-
-    for item in apps_dir.iterdir():
-        if not item.is_dir() or item.name.startswith("_"):
-            continue
-
-        if (item / "app.py").exists():
-            slug = item.name.replace("_", "-")
-            app_slugs.append(slug)
-
-    return app_slugs
-
-
-def extract_app_tools(app_slugs):
-    all_apps_tools = []
-
-    for slug in app_slugs:
-        try:
-            print(f"Loading app: {slug}")
-            app_class = app_from_slug(slug)
-
-            app_instance = app_class(integration=None)
-
-            tools = app_instance.list_tools()
-
-            for tool in tools:
-                tool_name = tool.__name__
-                description = (
-                    tool.__doc__.strip().split("\n")[0]
-                    if tool.__doc__
-                    else "No description"
-                )
-
-                all_apps_tools.append(
-                    {
-                        "app_name": slug,
-                        "tool_name": tool_name,
-                        "description": description,
-                    }
-                )
-
-        except Exception as e:
-            print(f"Error loading app {slug}: {e}")
-
-    return all_apps_tools
-
-
-def write_to_csv(app_tools, output_file="app_tools.csv"):
-    fieldnames = ["app_name", "tool_name", "description"]
-
-    with open(output_file, "w", newline="") as csvfile:
-        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-        writer.writeheader()
-        writer.writerows(app_tools)
-
-    print(f"CSV file created: {output_file}")
-
-
-def main():
-    app_slugs = discover_available_app_slugs()
-    print(f"Found {len(app_slugs)} app slugs: {', '.join(app_slugs)}")
-
-    app_tools = extract_app_tools(app_slugs)
-    print(f"Extracted {len(app_tools)} tools from all apps")
-
-    write_to_csv(app_tools)
-
-
-if __name__ == "__main__":
-    main()