universal-mcp 0.1.13rc14__tar.gz → 0.1.15rc5__tar.gz

{universal_mcp-0.1.13rc14 → universal_mcp-0.1.15rc5}/PKG-INFO

@@ -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 → universal_mcp-0.1.15rc5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.13-rc14"
+version = "0.1.15-rc5"
 description = "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."
 readme = "README.md"
 authors = [
@@ -16,6 +16,7 @@ dependencies = [
     "Jinja2>=3.1.3",
     "cookiecutter>=2.6.0",
     "gql[all]>=3.5.2",
+    "jsonref>=1.1.0",
     "keyring>=25.6.0",
     "litellm>=1.30.7",
     "loguru>=0.7.3",

{universal_mcp-0.1.13rc14 → universal_mcp-0.1.15rc5}/src/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-0.1.15rc5/src/universal_mcp/config.py

@@ -0,0 +1,105 @@
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field, SecretStr, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class StoreConfig(BaseModel):
+    """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):
+    """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):
+    """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-0.1.15rc5/src/universal_mcp/logger.py

@@ -0,0 +1,68 @@
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from loguru import 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()
+
+    # Add stderr handler
+    logger.add(
+        sink=sys.stderr,
+        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-0.1.13rc14 → universal_mcp-0.1.15rc5}/src/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-0.1.15rc5/src/universal_mcp/templates/README.md.j2

@@ -0,0 +1,17 @@
+# {{ name }} MCP Server
+
+An MCP Server for the {{ name }} API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the {{ name }} API.
+
+{% if tools %}
+| Tool | Description |
+|------|-------------|
+{%- for tool_name, tool_desc in tools %}
+| `{{ tool_name }}` | {{ tool_desc }} |
+{%- endfor %}
+{% else %}
+No tools with documentation were found in this API client.
+{% endif %}

universal_mcp-0.1.15rc5/src/universal_mcp/tools/__init__.py

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

{universal_mcp-0.1.13rc14 → universal_mcp-0.1.15rc5}/src/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-0.1.13rc14 → universal_mcp-0.1.15rc5}/src/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-0.1.13rc14/src/universal_mcp/tools/tools.py → universal_mcp-0.1.15rc5/src/universal_mcp/tools/manager.py

@@ -1,177 +1,17 @@
-from __future__ import annotations as _annotations
-
-import inspect
 from collections.abc import Callable
 from typing import Any, Literal
 
-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."""
-
-    fn: Callable[..., Any] = Field(exclude=True)
-    name: str = Field(description="Name of the tool")
-    description: str = Field(description="Summary line from the tool's docstring")
-    args_description: dict[str, str] = Field(
-        default_factory=dict, description="Descriptions of arguments from the docstring"
-    )
-    returns_description: str = Field(
-        default="", description="Description of the return value from the docstring"
-    )
-    raises_description: dict[str, str] = Field(
-        default_factory=dict,
-        description="Descriptions of exceptions raised from the docstring",
-    )
-    tags: list[str] = Field(
-        default_factory=list, description="Tags for categorizing the tool"
-    )
-    parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
-    fn_metadata: FuncMetadata = Field(
-        description="Metadata about the function including a pydantic model for tool"
-        " arguments"
-    )
-    is_async: bool = Field(description="Whether the tool is async")
-
-    @classmethod
-    def from_function(
-        cls,
-        fn: Callable[..., Any],
-        name: str | None = None,
-    ) -> Tool:
-        """Create a Tool from a function."""
-
-        func_name = name or fn.__name__
-
-        if func_name == "<lambda>":
-            raise ValueError("You must provide a name for lambda functions")
-
-        raw_doc = inspect.getdoc(fn)
-        parsed_doc = parse_docstring(raw_doc)
-
-        is_async = inspect.iscoroutinefunction(fn)
-
-        func_arg_metadata = FuncMetadata.func_metadata(
-            fn,
-        )
-        parameters = func_arg_metadata.arg_model.model_json_schema()
-
-        return cls(
-            fn=fn,
-            name=func_name,
-            description=parsed_doc["summary"],
-            args_description=parsed_doc["args"],
-            returns_description=parsed_doc["returns"],
-            raises_description=parsed_doc["raises"],
-            tags=parsed_doc["tags"],
-            parameters=parameters,
-            fn_metadata=func_arg_metadata,
-            is_async=is_async,
-        )
-
-    async def run(
-        self,
-        arguments: dict[str, Any],
-        context=None,
-    ) -> Any:
-        """Run the tool with arguments."""
-        try:
-            return await self.fn_metadata.call_fn_with_arg_validation(
-                self.fn, self.is_async, arguments, None
-            )
-        except NotAuthorizedError as e:
-            message = f"Not authorized to call tool {self.name}: {e.message}"
-            return message
-        except httpx.HTTPError as e:
-            message = f"HTTP error calling tool {self.name}: {str(e)}"
-            raise ToolError(message) from e
-        except ValueError as e:
-            message = f"Invalid arguments for tool {self.name}: {e}"
-            raise ToolError(message) from e
-        except Exception as e:
-            raise ToolError(f"Error executing tool {self.name}: {e}") from e
+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: