mcp-proxy-adapter 3.1.5__py3-none-any.whl → 4.0.0__py3-none-any.whl

mcp_proxy_adapter/core/settings.py

@@ -0,0 +1,376 @@
+"""
+Settings management for the MCP Proxy Adapter framework.
+Provides utilities for reading and managing framework settings from configuration.
+"""
+
+from typing import Any, Dict, Optional, Union
+from mcp_proxy_adapter.config import config
+
+
+class Settings:
+    """
+    Settings management class for the framework.
+    Provides easy access to configuration values with type conversion and validation.
+    """
+    
+    # Store custom settings as a class variable
+    _custom_settings: Dict[str, Any] = {}
+    
+    @classmethod
+    def add_custom_settings(cls, settings: Dict[str, Any]) -> None:
+        """
+        Add custom settings to the settings manager.
+        
+        Args:
+            settings: Dictionary with custom settings
+        """
+        cls._custom_settings.update(settings)
+    
+    @classmethod
+    def get_custom_settings(cls) -> Dict[str, Any]:
+        """
+        Get all custom settings.
+        
+        Returns:
+            Dictionary with all custom settings
+        """
+        return cls._custom_settings.copy()
+    
+    @classmethod
+    def get_custom_setting_value(cls, key: str, default: Any = None) -> Any:
+        """
+        Get custom setting value.
+        
+        Args:
+            key: Setting key
+            default: Default value if key not found
+            
+        Returns:
+            Setting value
+        """
+        return cls._custom_settings.get(key, default)
+    
+    @classmethod
+    def set_custom_setting_value(cls, key: str, value: Any) -> None:
+        """
+        Set custom setting value.
+        
+        Args:
+            key: Setting key
+            value: Value to set
+        """
+        cls._custom_settings[key] = value
+    
+    @classmethod
+    def clear_custom_settings(cls) -> None:
+        """
+        Clear all custom settings.
+        """
+        cls._custom_settings.clear()
+    
+    @staticmethod
+    def get_server_settings() -> Dict[str, Any]:
+        """
+        Get server configuration settings.
+        
+        Returns:
+            Dictionary with server settings
+        """
+        return {
+            "host": config.get("server.host", "0.0.0.0"),
+            "port": config.get("server.port", 8000),
+            "debug": config.get("server.debug", False),
+            "log_level": config.get("server.log_level", "INFO")
+        }
+    
+    @staticmethod
+    def get_logging_settings() -> Dict[str, Any]:
+        """
+        Get logging configuration settings.
+        
+        Returns:
+            Dictionary with logging settings
+        """
+        return {
+            "level": config.get("logging.level", "INFO"),
+            "file": config.get("logging.file"),
+            "log_dir": config.get("logging.log_dir", "./logs"),
+            "log_file": config.get("logging.log_file", "mcp_proxy_adapter.log"),
+            "error_log_file": config.get("logging.error_log_file", "mcp_proxy_adapter_error.log"),
+            "access_log_file": config.get("logging.access_log_file", "mcp_proxy_adapter_access.log"),
+            "max_file_size": config.get("logging.max_file_size", "10MB"),
+            "backup_count": config.get("logging.backup_count", 5),
+            "format": config.get("logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"),
+            "date_format": config.get("logging.date_format", "%Y-%m-%d %H:%M:%S"),
+            "console_output": config.get("logging.console_output", True),
+            "file_output": config.get("logging.file_output", True)
+        }
+    
+    @staticmethod
+    def get_commands_settings() -> Dict[str, Any]:
+        """
+        Get commands configuration settings.
+        
+        Returns:
+            Dictionary with commands settings
+        """
+        return {
+            "auto_discovery": config.get("commands.auto_discovery", True),
+            "discovery_path": config.get("commands.discovery_path", "mcp_proxy_adapter.commands"),
+            "custom_commands_path": config.get("commands.custom_commands_path")
+        }
+    
+    @staticmethod
+    def get_custom_setting(key: str, default: Any = None) -> Any:
+        """
+        Get custom setting from configuration.
+        
+        Args:
+            key: Configuration key in dot notation (e.g., "custom.feature_enabled")
+            default: Default value if key not found
+            
+        Returns:
+            Configuration value
+        """
+        return config.get(key, default)
+    
+    @staticmethod
+    def get_all_settings() -> Dict[str, Any]:
+        """
+        Get all configuration settings including custom settings.
+        
+        Returns:
+            Dictionary with all configuration settings
+        """
+        all_settings = config.get_all()
+        all_settings['custom_settings'] = Settings._custom_settings
+        return all_settings
+    
+    @staticmethod
+    def set_custom_setting(key: str, value: Any) -> None:
+        """
+        Set custom setting in configuration.
+        
+        Args:
+            key: Configuration key in dot notation
+            value: Value to set
+        """
+        config.set(key, value)
+    
+    @staticmethod
+    def reload_config() -> None:
+        """
+        Reload configuration from file and environment variables.
+        """
+        config.load_config()
+
+
+class ServerSettings:
+    """
+    Server-specific settings helper.
+    """
+    
+    @staticmethod
+    def get_host() -> str:
+        """Get server host."""
+        return config.get("server.host", "0.0.0.0")
+    
+    @staticmethod
+    def get_port() -> int:
+        """Get server port."""
+        return config.get("server.port", 8000)
+    
+    @staticmethod
+    def get_debug() -> bool:
+        """Get debug mode."""
+        return config.get("server.debug", False)
+    
+    @staticmethod
+    def get_log_level() -> str:
+        """Get log level."""
+        return config.get("server.log_level", "INFO")
+
+
+class LoggingSettings:
+    """
+    Logging-specific settings helper.
+    """
+    
+    @staticmethod
+    def get_level() -> str:
+        """Get logging level."""
+        return config.get("logging.level", "INFO")
+    
+    @staticmethod
+    def get_log_dir() -> str:
+        """Get log directory."""
+        return config.get("logging.log_dir", "./logs")
+    
+    @staticmethod
+    def get_log_file() -> Optional[str]:
+        """Get main log file name."""
+        return config.get("logging.log_file", "mcp_proxy_adapter.log")
+    
+    @staticmethod
+    def get_error_log_file() -> Optional[str]:
+        """Get error log file name."""
+        return config.get("logging.error_log_file", "mcp_proxy_adapter_error.log")
+    
+    @staticmethod
+    def get_access_log_file() -> Optional[str]:
+        """Get access log file name."""
+        return config.get("logging.access_log_file", "mcp_proxy_adapter_access.log")
+    
+    @staticmethod
+    def get_max_file_size() -> str:
+        """Get max file size."""
+        return config.get("logging.max_file_size", "10MB")
+    
+    @staticmethod
+    def get_backup_count() -> int:
+        """Get backup count."""
+        return config.get("logging.backup_count", 5)
+    
+    @staticmethod
+    def get_format() -> str:
+        """Get log format."""
+        return config.get("logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    
+    @staticmethod
+    def get_date_format() -> str:
+        """Get date format."""
+        return config.get("logging.date_format", "%Y-%m-%d %H:%M:%S")
+    
+    @staticmethod
+    def get_console_output() -> bool:
+        """Get console output setting."""
+        return config.get("logging.console_output", True)
+    
+    @staticmethod
+    def get_file_output() -> bool:
+        """Get file output setting."""
+        return config.get("logging.file_output", True)
+
+
+class CommandsSettings:
+    """
+    Commands-specific settings helper.
+    """
+    
+    @staticmethod
+    def get_auto_discovery() -> bool:
+        """Get auto discovery setting."""
+        return config.get("commands.auto_discovery", True)
+    
+    @staticmethod
+    def get_discovery_path() -> str:
+        """Get discovery path."""
+        return config.get("commands.discovery_path", "mcp_proxy_adapter.commands")
+    
+    @staticmethod
+    def get_custom_commands_path() -> Optional[str]:
+        """Get custom commands path."""
+        return config.get("commands.custom_commands_path")
+
+
+# Convenience functions for easy access
+def get_server_host() -> str:
+    """Get server host."""
+    return ServerSettings.get_host()
+
+
+def get_server_port() -> int:
+    """Get server port."""
+    return ServerSettings.get_port()
+
+
+def get_server_debug() -> bool:
+    """Get server debug mode."""
+    return ServerSettings.get_debug()
+
+
+def get_logging_level() -> str:
+    """Get logging level."""
+    return LoggingSettings.get_level()
+
+
+def get_logging_dir() -> str:
+    """Get logging directory."""
+    return LoggingSettings.get_log_dir()
+
+
+def get_auto_discovery() -> bool:
+    """Get auto discovery setting."""
+    return CommandsSettings.get_auto_discovery()
+
+
+def get_discovery_path() -> str:
+    """Get discovery path."""
+    return CommandsSettings.get_discovery_path()
+
+
+def get_setting(key: str, default: Any = None) -> Any:
+    """Get any setting by key."""
+    return Settings.get_custom_setting(key, default)
+
+
+def set_setting(key: str, value: Any) -> None:
+    """Set any setting by key."""
+    Settings.set_custom_setting(key, value)
+
+
+def reload_settings() -> None:
+    """Reload all settings from configuration."""
+    Settings.reload_config()
+
+
+def add_custom_settings(settings: Dict[str, Any]) -> None:
+    """
+    Add custom settings to the settings manager.
+    
+    Args:
+        settings: Dictionary with custom settings
+    """
+    Settings.add_custom_settings(settings)
+
+
+def get_custom_settings() -> Dict[str, Any]:
+    """
+    Get all custom settings.
+    
+    Returns:
+        Dictionary with all custom settings
+    """
+    return Settings.get_custom_settings()
+
+
+def get_custom_setting_value(key: str, default: Any = None) -> Any:
+    """
+    Get custom setting value.
+    
+    Args:
+        key: Setting key
+        default: Default value if key not found
+        
+    Returns:
+        Setting value
+    """
+    return Settings.get_custom_setting_value(key, default)
+
+
+def set_custom_setting_value(key: str, value: Any) -> None:
+    """
+    Set custom setting value.
+    
+    Args:
+        key: Setting key
+        value: Value to set
+    """
+    Settings.set_custom_setting_value(key, value)
+
+
+def clear_custom_settings() -> None:
+    """
+    Clear all custom settings.
+    """
+    Settings.clear_custom_settings() 

mcp_proxy_adapter/core/utils.py

@@ -8,7 +8,7 @@ import os
 import sys
 import time
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from mcp_proxy_adapter.core.logging import logger
@@ -45,7 +45,7 @@ def format_datetime(dt: Optional[datetime] = None, format_str: str = "%Y-%m-%dT%
     Returns:
         Formatted date/time string.
     """
-    dt = dt or datetime.utcnow()
+    dt = dt or datetime.now(timezone.utc)
     return dt.strftime(format_str)
 
 

mcp_proxy_adapter/custom_openapi.py

@@ -4,7 +4,7 @@ Custom OpenAPI schema generator for MCP Microservice compatible with MCP-Proxy.
 import json
 from copy import deepcopy
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Type
+from typing import Any, Dict, List, Optional, Set, Type, Callable
 
 from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
@@ -55,6 +55,15 @@ class CustomOpenAPIGenerator:
         # Get all commands from the registry
         commands = registry.get_all_commands()
         
+        # Ensure CommandRequest exists in schemas
+        if "CommandRequest" not in schema["components"]["schemas"]:
+            schema["components"]["schemas"]["CommandRequest"] = {
+                "properties": {
+                    "command": {"type": "string", "enum": []},
+                    "params": {"type": "object", "oneOf": []}
+                }
+            }
+        
         # Add command names to the CommandRequest enum
         schema["components"]["schemas"]["CommandRequest"]["properties"]["command"]["enum"] = [
             cmd for cmd in commands.keys()
@@ -284,4 +293,74 @@ def custom_openapi(app: FastAPI) -> Dict[str, Any]:
     # Cache the schema
     app.openapi_schema = openapi_schema
 
-    return openapi_schema 
+    return openapi_schema
+
+
+# Registry for custom OpenAPI generators
+_openapi_generators: Dict[str, Callable] = {}
+
+
+def register_openapi_generator(name: str, generator_func: Callable[[FastAPI], Dict[str, Any]]) -> None:
+    """
+    Register a custom OpenAPI generator.
+    
+    Args:
+        name: Generator name.
+        generator_func: Function that generates OpenAPI schema.
+    """
+    _openapi_generators[name] = generator_func
+    logger.info(f"Registered custom OpenAPI generator: {name}")
+
+
+def get_openapi_generator(name: str) -> Optional[Callable[[FastAPI], Dict[str, Any]]]:
+    """
+    Get a custom OpenAPI generator by name.
+    
+    Args:
+        name: Generator name.
+        
+    Returns:
+        Generator function or None if not found.
+    """
+    return _openapi_generators.get(name)
+
+
+def list_openapi_generators() -> List[str]:
+    """
+    Get list of registered OpenAPI generators.
+    
+    Returns:
+        List of generator names.
+    """
+    return list(_openapi_generators.keys())
+
+
+def custom_openapi_with_fallback(app: FastAPI) -> Dict[str, Any]:
+    """
+    EN:
+    Create a custom OpenAPI schema for the FastAPI application.
+    Checks for custom generators first, then falls back to default generator.
+    Passes app's title, description, and version to the generator.
+
+    RU:
+    Создаёт кастомную OpenAPI-схему для FastAPI-приложения.
+    Сначала проверяет наличие кастомных генераторов, затем использует встроенный генератор.
+    Передаёт параметры title, description и version из приложения в генератор схемы.
+    
+    Args:
+        app: The FastAPI application / FastAPI-приложение
+        
+    Returns:
+        Dict containing the custom OpenAPI schema / Словарь с кастомной OpenAPI-схемой
+    """
+    # Check if there are any custom generators
+    if _openapi_generators:
+        # Use the first registered generator
+        generator_name = list(_openapi_generators.keys())[0]
+        generator_func = _openapi_generators[generator_name]
+        logger.info(f"Using custom OpenAPI generator: {generator_name}")
+        return generator_func(app)
+    
+    # Fall back to default generator
+    logger.info("Using default OpenAPI generator")
+    return custom_openapi(app) 

mcp_proxy_adapter/examples/README.md

@@ -0,0 +1,124 @@
+# MCP Proxy Adapter Examples
+
+This directory contains examples demonstrating different usage patterns of the MCP Proxy Adapter framework.
+
+## Examples Overview
+
+### 1. Basic Server (`basic_server/`)
+Minimal server example with only built-in commands. Demonstrates:
+- Basic framework setup
+- Built-in command discovery
+- Standard JSON-RPC API
+- Backward compatibility with property setting
+
+### 2. Custom Commands Server (`custom_commands/`)
+Advanced server example with custom commands and hooks. Demonstrates:
+- Custom command registration
+- Basic hooks (before/after execution)
+- Global hooks
+- Performance and security monitoring
+- Advanced hooks with data transformation and command interception
+
+## Setting Application Title and Description
+
+The framework supports two ways to set application properties:
+
+### Method 1: During Creation (Recommended)
+```python
+from mcp_proxy_adapter import create_app
+
+app = create_app(
+    title="My Custom Server",
+    description="My custom server description",
+    version="2.0.0"
+)
+```
+
+### Method 2: After Creation (Backward Compatible)
+```python
+from mcp_proxy_adapter import create_app
+
+app = create_app()
+
+# Set properties after creation
+app.set_properties(
+    new_title="My Custom Server",
+    new_description="My custom server description",
+    new_version="2.0.0"
+)
+```
+
+## Running Examples
+
+### Basic Server
+```bash
+cd mcp_proxy_adapter/examples/basic_server
+python server.py
+```
+
+### Custom Commands Server
+```bash
+cd mcp_proxy_adapter/examples/custom_commands
+python server.py
+```
+
+## Testing Examples
+
+### Basic Server Commands
+```bash
+# Get help
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "method": "help", "id": 1}'
+
+# Get health
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "method": "health", "id": 2}'
+```
+
+### Custom Commands Server Commands
+```bash
+# Test echo command
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "method": "echo", "params": {"message": "Hello!"}, "id": 1}'
+
+# Test data transformation
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "method": "data_transform", "params": {"data": {"name": "test", "value": 123}}, "id": 2}'
+
+# Test command interception (bypass_flag=0)
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "method": "intercept", "params": {"bypass_flag": 0}, "id": 3}'
+
+# Test command execution (bypass_flag=1)
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc": "2.0", "method": "intercept", "params": {"bypass_flag": 1}, "id": 4}'
+```
+
+## Features Demonstrated
+
+### Basic Server
+- ✅ Standard JSON-RPC API
+- ✅ Built-in command discovery
+- ✅ Basic logging
+- ✅ OpenAPI schema generation
+- ✅ Backward compatibility
+
+### Custom Commands Server
+- ✅ Custom command registration
+- ✅ Command override with priority
+- ✅ Basic hooks (before/after)
+- ✅ Global hooks
+- ✅ Performance monitoring
+- ✅ Security monitoring
+- ✅ Data transformation hooks
+- ✅ Command interception hooks
+- ✅ Conditional processing
+- ✅ Smart interception
+- ✅ Centralized logging
+- ✅ Advanced error handling 

mcp_proxy_adapter/examples/__init__.py

@@ -0,0 +1,7 @@
+"""
+MCP Proxy Adapter Examples
+
+This package contains examples and templates for using the MCP Proxy Adapter framework.
+"""
+
+__version__ = "1.0.0" 

mcp_proxy_adapter/examples/basic_server/README.md

@@ -0,0 +1,60 @@
+# Basic Server Example
+
+A minimal example of MCP Proxy Adapter server without additional commands.
+
+## Features
+
+This example demonstrates:
+- Basic server setup
+- Built-in commands only (help, health)
+- Default configuration
+- No custom commands
+
+## Available Commands
+
+- `help` - Get information about available commands
+- `health` - Get server health status
+
+## Usage
+
+### Run the server
+
+```bash
+python server.py
+```
+
+### Test the server
+
+```bash
+# Get help
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"command": "help"}'
+
+# Get health status
+curl -X POST http://localhost:8000/cmd \
+  -H "Content-Type: application/json" \
+  -d '{"command": "health"}'
+```
+
+## API Endpoints
+
+- `POST /cmd` - Execute commands
+- `GET /health` - Health check
+- `GET /commands` - List available commands
+- `GET /docs` - API documentation
+
+## Configuration
+
+The server uses default configuration. You can customize it by:
+
+1. Creating a `config.json` file
+2. Setting environment variables
+3. Passing configuration to `create_app()`
+
+## Notes
+
+- This is the simplest possible setup
+- No custom commands are registered
+- Uses framework defaults
+- Good starting point for understanding the framework 

mcp_proxy_adapter/examples/basic_server/__init__.py

@@ -0,0 +1,7 @@
+"""
+Basic Server Example
+
+A minimal example of MCP Proxy Adapter server without additional commands.
+"""
+
+__version__ = "1.0.0"