universal-mcp 0.1.17__py3-none-any.whl → 0.1.18__py3-none-any.whl

universal_mcp/applications/application.py

@@ -81,7 +81,7 @@ class APIApplication(BaseApplication):
         """
         super().__init__(name, **kwargs)
         self.default_timeout: int = 180
-        self.integration: Integration | None = integration
+        self.integration = integration
         logger.debug(f"Initializing APIApplication '{name}' with integration: {integration}")
         self._client: httpx.Client | None = client
         self.base_url: str = ""
@@ -169,14 +169,28 @@ class APIApplication(BaseApplication):
         logger.debug(f"GET request successful with status code: {response.status_code}")
         return response
 
-    def _post(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> httpx.Response:
+    def _post(
+        self,
+        url: str,
+        data: Any,
+        params: dict[str, Any] | None = None,
+        content_type: str = "application/json",
+        files: dict[str, Any] | None = None,
+    ) -> httpx.Response:
         """
         Make a POST request to the specified URL.
 
         Args:
             url: The URL to send the request to
-            data: The data to send in the request body
+            data: The data to send. For 'application/json', this is JSON-serializable.
+                  For 'application/x-www-form-urlencoded' or 'multipart/form-data', this is a dict of form fields.
+                  For other content types, this is raw bytes or string.
             params: Optional query parameters
+            content_type: The Content-Type of the request body.
+                         Examples: 'application/json', 'application/x-www-form-urlencoded',
+                                   'multipart/form-data', 'application/octet-stream', 'text/plain'.
+            files: Optional dictionary of files to upload for 'multipart/form-data'.
+                   Example: {'file_field_name': ('filename.txt', open('file.txt', 'rb'), 'text/plain')}
 
         Returns:
             httpx.Response: The response from the server
@@ -184,25 +198,69 @@ class APIApplication(BaseApplication):
         Raises:
             httpx.HTTPError: If the request fails
         """
-        logger.debug(f"Making POST request to {url} with params: {params} and data: {data}")
-        response = httpx.post(
-            url,
-            headers=self._get_headers(),
-            json=data,
-            params=params,
+        logger.debug(
+            f"Making POST request to {url} with params: {params}, data type: {type(data)}, content_type={content_type}, files: {'yes' if files else 'no'}"
         )
+        headers = self._get_headers().copy()
+
+        if content_type != "multipart/form-data":
+            headers["Content-Type"] = content_type
+
+        if content_type == "multipart/form-data":
+            response = self.client.post(
+                url,
+                headers=headers,
+                data=data,  # For regular form fields
+                files=files,  # For file parts
+                params=params,
+            )
+        elif content_type == "application/x-www-form-urlencoded":
+            response = self.client.post(
+                url,
+                headers=headers,
+                data=data,
+                params=params,
+            )
+        elif content_type == "application/json":
+            response = self.client.post(
+                url,
+                headers=headers,
+                json=data,
+                params=params,
+            )
+        else:  # Handles 'application/octet-stream', 'text/plain', 'image/jpeg', etc.
+            response = self.client.post(
+                url,
+                headers=headers,
+                content=data,  # Expect data to be bytes or str
+                params=params,
+            )
         response.raise_for_status()
         logger.debug(f"POST request successful with status code: {response.status_code}")
         return response
 
-    def _put(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> httpx.Response:
+    def _put(
+        self,
+        url: str,
+        data: Any,
+        params: dict[str, Any] | None = None,
+        content_type: str = "application/json",
+        files: dict[str, Any] | None = None,
+    ) -> httpx.Response:
         """
         Make a PUT request to the specified URL.
 
         Args:
             url: The URL to send the request to
-            data: The data to send in the request body
+            data: The data to send. For 'application/json', this is JSON-serializable.
+                  For 'application/x-www-form-urlencoded' or 'multipart/form-data', this is a dict of form fields.
+                  For other content types, this is raw bytes or string.
             params: Optional query parameters
+            content_type: The Content-Type of the request body.
+                         Examples: 'application/json', 'application/x-www-form-urlencoded',
+                                   'multipart/form-data', 'application/octet-stream', 'text/plain'.
+            files: Optional dictionary of files to upload for 'multipart/form-data'.
+                   Example: {'file_field_name': ('filename.txt', open('file.txt', 'rb'), 'text/plain')}
 
         Returns:
             httpx.Response: The response from the server
@@ -210,12 +268,44 @@ class APIApplication(BaseApplication):
         Raises:
             httpx.HTTPError: If the request fails
         """
-        logger.debug(f"Making PUT request to {url} with params: {params} and data: {data}")
-        response = self.client.put(
-            url,
-            json=data,
-            params=params,
+        logger.debug(
+            f"Making PUT request to {url} with params: {params}, data type: {type(data)}, content_type={content_type}, files: {'yes' if files else 'no'}"
         )
+        headers = self._get_headers().copy()
+        # For multipart/form-data, httpx handles the Content-Type header (with boundary)
+        # For other content types, we set it explicitly.
+        if content_type != "multipart/form-data":
+            headers["Content-Type"] = content_type
+
+        if content_type == "multipart/form-data":
+            response = self.client.put(
+                url,
+                headers=headers,
+                data=data,  # For regular form fields
+                files=files,  # For file parts
+                params=params,
+            )
+        elif content_type == "application/x-www-form-urlencoded":
+            response = self.client.put(
+                url,
+                headers=headers,
+                data=data,
+                params=params,
+            )
+        elif content_type == "application/json":
+            response = self.client.put(
+                url,
+                headers=headers,
+                json=data,
+                params=params,
+            )
+        else:  # Handles 'application/octet-stream', 'text/plain', 'image/jpeg', etc.
+            response = self.client.put(
+                url,
+                headers=headers,
+                content=data,  # Expect data to be bytes or str
+                params=params,
+            )
         response.raise_for_status()
         logger.debug(f"PUT request successful with status code: {response.status_code}")
         return response

universal_mcp/cli.py

@@ -45,14 +45,26 @@ def generate(
         raise typer.Exit(1)
 
     try:
-        # Run the async function in the event loop
-        app_file = generate_api_from_schema(
+        app_file_data = generate_api_from_schema(
             schema_path=schema_path,
             output_path=output_path,
             class_name=class_name,
         )
-        console.print("[green]API client successfully generated and installed.[/green]")
-        console.print(f"[blue]Application file: {app_file}[/blue]")
+        if isinstance(app_file_data, dict) and "code" in app_file_data:
+            console.print("[yellow]No output path specified, printing generated code to console:[/yellow]")
+            console.print(app_file_data["code"])
+        elif isinstance(app_file_data, Path):
+            console.print("[green]API client successfully generated and installed.[/green]")
+            console.print(f"[blue]Application file: {app_file_data}[/blue]")
+        else:
+            # Handle the error case from api_generator if validation fails
+            if isinstance(app_file_data, dict) and "error" in app_file_data:
+                 console.print(f"[red]{app_file_data['error']}[/red]")
+                 raise typer.Exit(1)
+            else:
+                console.print("[red]Unexpected return value from API generator.[/red]")
+                raise typer.Exit(1)
+
     except Exception as e:
         console.print(f"[red]Error generating API client: {e}[/red]")
         raise typer.Exit(1) from e
@@ -255,5 +267,33 @@ def preprocess(
     run_preprocessing(schema_path, output_path)
 
 
+@app.command()
+def split_api(
+    input_app_file: Path = typer.Argument(..., help="Path to the generated app.py file to split"),
+    output_dir: Path = typer.Option(..., "--output-dir", "-o", help="Directory to save the split files"),
+):
+    """Splits a single generated API client file into multiple files based on path groups."""
+    from universal_mcp.utils.openapi.api_splitter import split_generated_app_file
+
+    if not input_app_file.exists() or not input_app_file.is_file():
+        console.print(f"[red]Error: Input file {input_app_file} does not exist or is not a file.[/red]")
+        raise typer.Exit(1)
+
+    if not output_dir.exists():
+        output_dir.mkdir(parents=True, exist_ok=True)
+        console.print(f"[green]Created output directory: {output_dir}[/green]")
+    elif not output_dir.is_dir():
+        console.print(f"[red]Error: Output path {output_dir} is not a directory.[/red]")
+        raise typer.Exit(1)
+
+    try:
+        split_generated_app_file(input_app_file, output_dir)
+        console.print(f"[green]Successfully split {input_app_file} into {output_dir}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error splitting API client: {e}[/red]")
+      
+        raise typer.Exit(1) from e
+
+
 if __name__ == "__main__":
     app()

universal_mcp/config.py

@@ -38,7 +38,6 @@ class ServerConfig(BaseSettings):
     """Main server configuration."""
 
     model_config = SettingsConfigDict(
-        env_prefix="MCP_",
         env_file=".env",
         env_file_encoding="utf-8",
         case_sensitive=True,
@@ -49,15 +48,15 @@ class ServerConfig(BaseSettings):
     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)")
+    transport: Literal["stdio", "sse", "streamable-http"] = Field(
+        default="stdio", description="Transport protocol to use"
+    )
+    port: int = Field(default=8005, description="Port to run the server on (if applicable)", ge=1024, le=65535)
     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:

universal_mcp/exceptions.py

@@ -19,3 +19,7 @@ class StoreError(Exception):
 
 class KeyNotFoundError(StoreError):
     """Exception raised when a key is not found in the store."""
+
+
+class ConfigurationError(Exception):
+    """Exception raised when a configuration error occurs."""

universal_mcp/integrations/__init__.py

@@ -22,8 +22,8 @@ def integration_from_config(config: IntegrationConfig, store: BaseStore | None =
 
 __all__ = [
     "AgentRIntegration",
-    "Integration",
     "ApiKeyIntegration",
+    "Integration",
     "OAuthIntegration",
     "integration_from_config",
 ]

universal_mcp/integrations/integration.py

@@ -1,4 +1,3 @@
-from abc import ABC, abstractmethod
 from typing import Any
 
 import httpx
@@ -18,7 +17,7 @@ def sanitize_api_key_name(name: str) -> str:
         return f"{name.upper()}{suffix}"
 
 
-class Integration(ABC):
+class Integration:
     """Abstract base class for handling application integrations and authentication.
 
     This class defines the interface for different types of integrations that handle
@@ -35,9 +34,11 @@ class Integration(ABC):
 
     def __init__(self, name: str, store: BaseStore | None = None):
         self.name = name
-        self.store = store
+        if store is None:
+            self.store = MemoryStore()
+        else:
+            self.store = store
 
-    @abstractmethod
     def authorize(self) -> str | dict[str, Any]:
         """Authorize the integration.
 
@@ -49,7 +50,6 @@ class Integration(ABC):
         """
         pass
 
-    @abstractmethod
     def get_credentials(self) -> dict[str, Any]:
         """Get credentials for the integration.
 
@@ -59,9 +59,9 @@ class Integration(ABC):
         Raises:
             NotAuthorizedError: If credentials are not found or invalid.
         """
-        pass
+        credentials = self.store.get(self.name)
+        return credentials
 
-    @abstractmethod
     def set_credentials(self, credentials: dict[str, Any]) -> None:
         """Set credentials for the integration.
 
@@ -71,7 +71,7 @@ class Integration(ABC):
         Raises:
             ValueError: If credentials are invalid or missing required fields.
         """
-        pass
+        self.store.set(self.name, credentials)
 
 
 class ApiKeyIntegration(Integration):
@@ -91,7 +91,7 @@ class ApiKeyIntegration(Integration):
         store: Store instance for persisting credentials and other data
     """
 
-    def __init__(self, name: str, store: BaseStore = MemoryStore(), **kwargs):
+    def __init__(self, name: str, store: BaseStore | None = None, **kwargs):
         self.type = "api_key"
         sanitized_name = sanitize_api_key_name(name)
         super().__init__(sanitized_name, store, **kwargs)

universal_mcp/servers/__init__.py

@@ -1,5 +1,5 @@
 from universal_mcp.config import ServerConfig
-from universal_mcp.servers.server import AgentRServer, LocalServer, SingleMCPServer
+from universal_mcp.servers.server import AgentRServer, BaseServer, 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, SingleMCPServer, server_from_config]
+__all__ = [AgentRServer, LocalServer, SingleMCPServer, BaseServer, server_from_config]

universal_mcp/servers/server.py

@@ -1,4 +1,3 @@
-from abc import ABC, abstractmethod
 from collections.abc import Callable
 from typing import Any
 
@@ -6,16 +5,18 @@ import httpx
 from loguru import logger
 from mcp.server.fastmcp import FastMCP
 from mcp.types import TextContent
+from pydantic import ValidationError
 
 from universal_mcp.applications import BaseApplication, app_from_slug
 from universal_mcp.config import AppConfig, ServerConfig, StoreConfig
+from universal_mcp.exceptions import ConfigurationError, ToolError
 from universal_mcp.integrations import AgentRIntegration, integration_from_config
 from universal_mcp.stores import BaseStore, store_from_config
 from universal_mcp.tools import ToolManager
 from universal_mcp.utils.agentr import AgentrClient
 
 
-class BaseServer(FastMCP, ABC):
+class BaseServer(FastMCP):
     """Base server class with common functionality.
 
     This class provides core server functionality including store setup,
@@ -26,24 +27,27 @@ class BaseServer(FastMCP, ABC):
         **kwargs: Additional keyword arguments passed to FastMCP
     """
 
-    def __init__(self, config: ServerConfig, **kwargs):
-        super().__init__(config.name, config.description, port=config.port, **kwargs)
-        logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
-
-        self.config = config  # Store config at base level for consistency
-        self._tool_manager = ToolManager(warn_on_duplicate_tools=True)
-
-    @abstractmethod
-    def _load_apps(self) -> None:
-        """Load and register applications."""
-        pass
+    def __init__(self, config: ServerConfig, tool_manager: ToolManager | None = None, **kwargs):
+        try:
+            super().__init__(config.name, config.description, port=config.port, **kwargs)
+            logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
+            self.config = config
+            self._tool_manager = tool_manager or ToolManager(warn_on_duplicate_tools=True)
+            ServerConfig.model_validate(config)
+        except Exception as e:
+            logger.error(f"Failed to initialize server: {e}", exc_info=True)
+            raise ConfigurationError(f"Server initialization failed: {str(e)}") from e
 
     def add_tool(self, tool: Callable) -> None:
         """Add a tool to the server.
 
         Args:
             tool: Tool to add
+
+        Raises:
+            ValueError: If tool is invalid
         """
+
         self._tool_manager.add_tool(tool)
 
     async def list_tools(self) -> list[dict]:
@@ -83,11 +87,21 @@ class BaseServer(FastMCP, ABC):
 
         Raises:
             ToolError: If tool execution fails
+            ValueError: If tool name is invalid or arguments are malformed
         """
+        if not name:
+            raise ValueError("Tool name is required")
+        if not isinstance(arguments, dict):
+            raise ValueError("Arguments must be a dictionary")
+
         logger.info(f"Calling tool: {name} with arguments: {arguments}")
-        result = await self._tool_manager.call_tool(name, arguments)
-        logger.info(f"Tool '{name}' completed successfully")
-        return self._format_tool_result(result)
+        try:
+            result = await self._tool_manager.call_tool(name, arguments)
+            logger.info(f"Tool '{name}' completed successfully")
+            return self._format_tool_result(result)
+        except Exception as e:
+            logger.error(f"Tool '{name}' failed: {e}", exc_info=True)
+            raise ToolError(f"Tool execution failed: {str(e)}") from e
 
 
 class LocalServer(BaseServer):
@@ -111,14 +125,23 @@ class LocalServer(BaseServer):
 
         Returns:
             Configured store instance or None if no config provided
+
+        Raises:
+            ConfigurationError: If store configuration is invalid
         """
         if not store_config:
+            logger.info("No store configuration provided")
             return None
 
-        store = store_from_config(store_config)
-        self.add_tool(store.set)
-        self.add_tool(store.delete)
-        return store
+        try:
+            store = store_from_config(store_config)
+            self.add_tool(store.set)
+            self.add_tool(store.delete)
+            logger.info(f"Successfully configured store: {store_config.type}")
+            return store
+        except Exception as e:
+            logger.error(f"Failed to setup store: {e}", exc_info=True)
+            raise ConfigurationError(f"Store setup failed: {str(e)}") from e
 
     def _load_app(self, app_config: AppConfig) -> BaseApplication | None:
         """Load a single application with its integration.
@@ -129,22 +152,57 @@ class LocalServer(BaseServer):
         Returns:
             Configured application instance or None if loading fails
         """
+        if not app_config.name:
+            logger.error("App configuration missing name")
+            return None
+
         try:
-            integration = (
-                integration_from_config(app_config.integration, store=self.store) if app_config.integration else None
-            )
-            return app_from_slug(app_config.name)(integration=integration)
+            integration = None
+            if app_config.integration:
+                try:
+                    integration = integration_from_config(app_config.integration, store=self.store)
+                    logger.debug(f"Successfully configured integration for {app_config.name}")
+                except Exception as e:
+                    logger.error(f"Failed to setup integration for {app_config.name}: {e}", exc_info=True)
+                    # Continue without integration if it fails
+
+            app = app_from_slug(app_config.name)(integration=integration)
+            logger.info(f"Successfully loaded app: {app_config.name}")
+            return app
         except Exception as e:
             logger.error(f"Failed to load app {app_config.name}: {e}", exc_info=True)
             return None
 
     def _load_apps(self) -> None:
-        """Load all configured applications."""
-        logger.info(f"Loading apps: {self.config.apps}")
+        """Load all configured applications with graceful degradation."""
+        if not self.config.apps:
+            logger.warning("No applications configured")
+            return
+
+        logger.info(f"Loading {len(self.config.apps)} apps")
+        loaded_apps = 0
+        failed_apps = []
+
         for app_config in self.config.apps:
             app = self._load_app(app_config)
             if app:
-                self._tool_manager.register_tools_from_app(app, app_config.actions)
+                try:
+                    self._tool_manager.register_tools_from_app(app, app_config.actions)
+                    loaded_apps += 1
+                    logger.info(f"Successfully registered tools for {app_config.name}")
+                except Exception as e:
+                    logger.error(f"Failed to register tools for {app_config.name}: {e}", exc_info=True)
+                    failed_apps.append(app_config.name)
+            else:
+                failed_apps.append(app_config.name)
+
+        if failed_apps:
+            logger.warning(f"Failed to load {len(failed_apps)} apps: {', '.join(failed_apps)}")
+
+        if loaded_apps == 0:
+            logger.error("No apps were successfully loaded")
+        else:
+            logger.info(f"Successfully loaded {loaded_apps}/{len(self.config.apps)} apps")
 
 
 class AgentRServer(BaseServer):
@@ -154,27 +212,38 @@ class AgentRServer(BaseServer):
         config: Server configuration
         api_key: Optional API key for AgentR authentication. If not provided,
                 will attempt to read from AGENTR_API_KEY environment variable.
+        max_retries: Maximum number of retries for API calls (default: 3)
+        retry_delay: Delay between retries in seconds (default: 1)
         **kwargs: Additional keyword arguments passed to FastMCP
     """
 
     def __init__(self, config: ServerConfig, api_key: str | None = None, **kwargs):
-        self.client = AgentrClient(api_key=api_key)
+        self.api_key = api_key or str(config.api_key)
+        self.client = AgentrClient(api_key=self.api_key)
         super().__init__(config, **kwargs)
         self.integration = AgentRIntegration(name="agentr", api_key=self.client.api_key)
         self._load_apps()
 
     def _fetch_apps(self) -> list[AppConfig]:
-        """Fetch available apps from AgentR API.
+        """Fetch available apps from AgentR API with retry logic.
 
         Returns:
             List of application configurations
 
         Raises:
-            httpx.HTTPError: If API request fails
+            httpx.HTTPError: If API request fails after all retries
+            ValidationError: If app configuration validation fails
         """
         try:
             apps = self.client.fetch_apps()
-            return [AppConfig.model_validate(app) for app in apps]
+            validated_apps = []
+            for app in apps:
+                try:
+                    validated_apps.append(AppConfig.model_validate(app))
+                except ValidationError as e:
+                    logger.error(f"Failed to validate app config: {e}", exc_info=True)
+                    continue
+            return validated_apps
         except httpx.HTTPError as e:
             logger.error(f"Failed to fetch apps from AgentR: {e}", exc_info=True)
             raise
@@ -194,21 +263,37 @@ class AgentRServer(BaseServer):
                 if app_config.integration
                 else None
             )
-            return app_from_slug(app_config.name)(integration=integration)
+            app = app_from_slug(app_config.name)(integration=integration)
+            logger.info(f"Successfully loaded app: {app_config.name}")
+            return app
         except Exception as e:
             logger.error(f"Failed to load app {app_config.name}: {e}", exc_info=True)
             return None
 
     def _load_apps(self) -> None:
-        """Load all apps available from AgentR."""
+        """Load all apps available from AgentR with graceful degradation."""
         try:
-            for app_config in self._fetch_apps():
+            app_configs = self._fetch_apps()
+            if not app_configs:
+                logger.warning("No apps found from AgentR API")
+                return
+
+            loaded_apps = 0
+            for app_config in app_configs:
                 app = self._load_app(app_config)
                 if app:
                     self._tool_manager.register_tools_from_app(app, app_config.actions)
+                    loaded_apps += 1
+
+            if loaded_apps == 0:
+                logger.error("Failed to load any apps from AgentR")
+            else:
+                logger.info(f"Successfully loaded {loaded_apps}/{len(app_configs)} apps from AgentR")
+
         except Exception:
             logger.error("Failed to load apps", exc_info=True)
-            raise
+            # Don't raise the exception to allow server to start with partial functionality
+            logger.warning("Server will start with limited functionality due to app loading failures")
 
 
 class SingleMCPServer(BaseServer):
@@ -234,27 +319,13 @@ class SingleMCPServer(BaseServer):
         config: ServerConfig | None = None,
         **kwargs,
     ):
+        if not app_instance:
+            raise ValueError("app_instance is required")
         if not config:
             config = ServerConfig(
                 type="local",
-                name=f"{app_instance.name.title()} MCP Server for Local Development"
-                if app_instance
-                else "Unnamed MCP Server",
-                description=f"Minimal MCP server for the local {app_instance.name} application."
-                if app_instance
-                else "Minimal MCP server with no application loaded.",
+                name=f"{app_instance.name.title()} MCP Server for Local Development",
+                description=f"Minimal MCP server for the local {app_instance.name} application.",
             )
         super().__init__(config, **kwargs)
-
-        self.app_instance = app_instance
-        self._load_apps()
-
-    def _load_apps(self) -> None:
-        """Registers tools from the single provided application instance."""
-        if not self.app_instance:
-            logger.warning("No app_instance provided. No tools registered.")
-            return
-
-        tool_functions = self.app_instance.list_tools()
-        for tool_func in tool_functions:
-            self._tool_manager.add_tool(tool_func)
+        self._tool_manager.register_tools_from_app(app_instance)