mcp-proxy-adapter 6.0.0__py3-none-any.whl → 6.0.1__py3-none-any.whl

mcp_proxy_adapter/examples/basic_server/custom_settings_example.py

@@ -1,238 +0,0 @@
-"""
-Custom Settings Example for Basic Server
-
-This example demonstrates how to use custom settings in a basic server.
-"""
-
-import json
-import os
-from mcp_proxy_adapter.core.settings import (
-    add_custom_settings,
-    get_custom_setting_value,
-    set_custom_setting_value,
-    get_custom_settings
-)
-from mcp_proxy_adapter.core.logging import get_logger
-
-
-def setup_basic_custom_settings():
-    """
-    Setup basic custom settings for the basic server example.
-    
-    This demonstrates how to add custom settings to the framework
-    and access them throughout the application.
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    # Define basic custom settings
-    basic_settings = {
-        "application": {
-            "name": "Basic MCP Proxy Server",
-            "version": "1.0.0",
-            "environment": "development"
-        },
-        "features": {
-            "basic_logging": True,
-            "simple_commands": True,
-            "custom_settings_demo": True
-        },
-        "server_info": {
-            "description": "Basic server with custom settings example",
-            "author": "MCP Proxy Adapter Team",
-            "contact": "support@example.com"
-        },
-        "demo_settings": {
-            "welcome_message": "Welcome to Basic MCP Proxy Server!",
-            "max_connections": 100,
-            "timeout": 30,
-            "debug_mode": True
-        }
-    }
-    
-    # Add settings to the framework
-    add_custom_settings(basic_settings)
-    
-    logger.info("✅ Basic custom settings loaded")
-    logger.info(f"📋 Application: {basic_settings['application']['name']} v{basic_settings['application']['version']}")
-    logger.info(f"🔧 Features: {list(basic_settings['features'].keys())}")
-    
-    return basic_settings
-
-
-def demonstrate_custom_settings_usage():
-    """
-    Demonstrate how to use custom settings in the application.
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    # Get specific settings
-    app_name = get_custom_setting_value("application.name", "Unknown")
-    app_version = get_custom_setting_value("application.version", "0.0.0")
-    welcome_msg = get_custom_setting_value("demo_settings.welcome_message", "Hello!")
-    max_connections = get_custom_setting_value("demo_settings.max_connections", 50)
-    
-    logger.info(f"🏷️  Application: {app_name} v{app_version}")
-    logger.info(f"💬 Welcome Message: {welcome_msg}")
-    logger.info(f"🔗 Max Connections: {max_connections}")
-    
-    # Check if features are enabled
-    features = get_custom_setting_value("features", {})
-    enabled_features = [name for name, enabled in features.items() if enabled]
-    
-    logger.info(f"✅ Enabled Features: {', '.join(enabled_features)}")
-    
-    # Set a new custom setting
-    set_custom_setting_value("demo_settings.last_updated", "2025-08-08")
-    logger.info("🔧 Set new custom setting: demo_settings.last_updated")
-    
-    # Get all custom settings
-    all_custom_settings = get_custom_settings()
-    logger.info(f"📊 Total custom settings: {len(all_custom_settings)} sections")
-    
-    return {
-        "app_name": app_name,
-        "app_version": app_version,
-        "welcome_message": welcome_msg,
-        "max_connections": max_connections,
-        "enabled_features": enabled_features,
-        "total_settings_sections": len(all_custom_settings)
-    }
-
-
-def create_custom_settings_file():
-    """
-    Create a custom settings JSON file for the basic server.
-    """
-    custom_settings = {
-        "application": {
-            "name": "Basic MCP Proxy Server with Custom Settings",
-            "version": "1.1.0",
-            "environment": "development",
-            "description": "Basic server demonstrating custom settings usage"
-        },
-        "features": {
-            "basic_logging": True,
-            "simple_commands": True,
-            "custom_settings_demo": True,
-            "file_based_config": True
-        },
-        "server_info": {
-            "description": "Basic server with file-based custom settings",
-            "author": "MCP Proxy Adapter Team",
-            "contact": "support@example.com",
-            "documentation": "https://example.com/docs"
-        },
-        "demo_settings": {
-            "welcome_message": "Welcome to Basic MCP Proxy Server with Custom Settings!",
-            "max_connections": 150,
-            "timeout": 45,
-            "debug_mode": True,
-            "log_level": "INFO"
-        },
-        "performance": {
-            "enable_caching": True,
-            "cache_ttl": 300,
-            "max_cache_size": 1000
-        },
-        "security": {
-            "enable_rate_limiting": False,
-            "max_request_size": "5MB",
-            "allowed_origins": ["*"]
-        }
-    }
-    
-    # Write to file
-    settings_file = "basic_custom_settings.json"
-    with open(settings_file, 'w', encoding='utf-8') as f:
-        json.dump(custom_settings, f, indent=2, ensure_ascii=False)
-    
-    print(f"✅ Created custom settings file: {settings_file}")
-    return settings_file
-
-
-def load_custom_settings_from_file(file_path: str = "basic_custom_settings.json"):
-    """
-    Load custom settings from a JSON file.
-    
-    Args:
-        file_path: Path to the custom settings JSON file
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    try:
-        if os.path.exists(file_path):
-            with open(file_path, 'r', encoding='utf-8') as f:
-                custom_settings = json.load(f)
-            
-            # Add to framework
-            add_custom_settings(custom_settings)
-            
-            logger.info(f"📁 Loaded custom settings from: {file_path}")
-            logger.info(f"📋 Application: {custom_settings.get('application', {}).get('name', 'Unknown')}")
-            
-            return custom_settings
-        else:
-            logger.warning(f"⚠️  Custom settings file not found: {file_path}")
-            return None
-            
-    except Exception as e:
-        logger.error(f"❌ Failed to load custom settings from {file_path}: {e}")
-        return None
-
-
-def print_custom_settings_summary():
-    """
-    Print a summary of current custom settings.
-    """
-    logger = get_logger("basic_server_custom_settings")
-    
-    all_settings = get_custom_settings()
-    
-    logger.info("📊 Custom Settings Summary:")
-    
-    # Application info
-    app_name = get_custom_setting_value("application.name", "Unknown")
-    app_version = get_custom_setting_value("application.version", "0.0.0")
-    logger.info(f"   Application: {app_name} v{app_version}")
-    
-    # Features
-    features = get_custom_setting_value("features", {})
-    enabled_features = [name for name, enabled in features.items() if enabled]
-    logger.info(f"   Enabled Features: {', '.join(enabled_features) if enabled_features else 'None'}")
-    
-    # Demo settings
-    welcome_msg = get_custom_setting_value("demo_settings.welcome_message", "Hello!")
-    max_connections = get_custom_setting_value("demo_settings.max_connections", 50)
-    logger.info(f"   Welcome Message: {welcome_msg}")
-    logger.info(f"   Max Connections: {max_connections}")
-    
-    # Performance
-    caching_enabled = get_custom_setting_value("performance.enable_caching", False)
-    logger.info(f"   Caching: {'Enabled' if caching_enabled else 'Disabled'}")
-    
-    # Security
-    rate_limiting = get_custom_setting_value("security.enable_rate_limiting", False)
-    logger.info(f"   Rate Limiting: {'Enabled' if rate_limiting else 'Disabled'}")
-    
-    logger.info(f"   Total Settings Sections: {len(all_settings)}")
-
-
-if __name__ == "__main__":
-    # Setup basic custom settings
-    setup_basic_custom_settings()
-    
-    # Demonstrate usage
-    demo_info = demonstrate_custom_settings_usage()
-    
-    # Create custom settings file
-    settings_file = create_custom_settings_file()
-    
-    # Load from file
-    load_custom_settings_from_file(settings_file)
-    
-    # Print summary
-    print_custom_settings_summary()
-    
-    print("\n🎉 Custom settings demonstration completed!")
-    print(f"📁 Custom settings file: {settings_file}")
-    print("🔧 You can now use these settings in your basic server application.") 

mcp_proxy_adapter/examples/basic_server/server.py

@@ -1,114 +0,0 @@
-"""
-Basic Server Example
-
-This example demonstrates a minimal MCP Proxy Adapter server
-without any additional custom commands.
-"""
-
-import asyncio
-import uvicorn
-import sys
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
-
-from mcp_proxy_adapter import create_app
-from mcp_proxy_adapter.core.logging import get_logger, setup_logging
-from mcp_proxy_adapter.core.settings import (
-    Settings, 
-    get_server_host, 
-    get_server_port, 
-    get_server_debug,
-    get_setting
-)
-from mcp_proxy_adapter.core.ssl_utils import SSLUtils
-
-
-def main():
-    """Run the basic server example."""
-    # Load configuration from config.json in the same directory
-    config_path = os.path.join(os.path.dirname(__file__), "config.json")
-    if os.path.exists(config_path):
-        from mcp_proxy_adapter.config import config
-        config.load_from_file(config_path)
-        print(f"✅ Loaded configuration from: {config_path}")
-    else:
-        print(f"⚠️  Configuration file not found: {config_path}")
-        print("   Using default configuration")
-    
-    # Setup logging with configuration
-    setup_logging()
-    logger = get_logger("basic_server")
-    
-    # Get settings from configuration
-    server_settings = Settings.get_server_settings()
-    logging_settings = Settings.get_logging_settings()
-    commands_settings = Settings.get_commands_settings()
-    ssl_settings = Settings.get_custom_setting("ssl", {})
-    custom_settings = Settings.get_custom_setting("custom", {})
-    
-    # Print server header and description
-    print("=" * 80)
-    print("🔧 BASIC MCP PROXY ADAPTER SERVER")
-    print("=" * 80)
-    print("📋 Description:")
-    print(f"   {custom_settings.get('description', 'Basic server example')}")
-    print()
-    print("⚙️  Configuration:")
-    print(f"   • Server: {server_settings['host']}:{server_settings['port']}")
-    print(f"   • Debug: {server_settings['debug']}")
-    print(f"   • Log Level: {logging_settings['level']}")
-    print(f"   • Log Directory: {logging_settings['log_dir']}")
-    print(f"   • Auto Discovery: {commands_settings['auto_discovery']}")
-    print(f"   • Discovery Path: {commands_settings['discovery_path']}")
-    print(f"   • SSL Enabled: {ssl_settings.get('enabled', False)}")
-    if ssl_settings.get('enabled', False):
-        print(f"   • SSL Mode: {ssl_settings.get('mode', 'https_only')}")
-        print(f"   • SSL Cert: {ssl_settings.get('cert_file', 'Not specified')}")
-    print()
-    print("🔧 Available Commands:")
-    print("   • help - Built-in help command")
-    print("   • health - Built-in health command")
-    print("   • config - Built-in config command")
-    print("   • reload - Built-in reload command")
-    print()
-    print("📁 Command Discovery:")
-    print(f"   • Commands will be discovered from: {commands_settings['discovery_path']}")
-    print("   • This path is configured in config.json under 'commands.discovery_path'")
-    print()
-    print("🎯 Features:")
-    print("   • Standard JSON-RPC API")
-    print("   • Built-in command discovery")
-    print("   • Basic logging and error handling")
-    print("   • OpenAPI schema generation")
-    print("   • Configuration-driven settings")
-    print("=" * 80)
-    print()
-    
-    logger.info("Starting Basic MCP Proxy Adapter Server...")
-    logger.info(f"Server configuration: {server_settings}")
-    logger.info(f"Logging configuration: {logging_settings}")
-    logger.info(f"Commands configuration: {commands_settings}")
-    logger.info(f"SSL configuration: {ssl_settings}")
-    
-    # Create application with settings from configuration
-    app = create_app(
-        title=custom_settings.get('server_name', 'Basic MCP Proxy Adapter Server'),
-        description=custom_settings.get('description', 'Minimal server example with only built-in commands'),
-        version="1.0.0"
-    )
-    
-    # Get SSL configuration for uvicorn
-    uvicorn_ssl_config = SSLUtils.get_ssl_config_for_uvicorn(ssl_settings)
-    
-    # Run the server with configuration settings
-    uvicorn.run(
-        app,
-        host=server_settings['host'],
-        port=server_settings['port'],
-        log_level=server_settings['log_level'].lower(),
-        **uvicorn_ssl_config
-    )
-
-
-if __name__ == "__main__":
-    main() 

mcp_proxy_adapter/examples/custom_commands/README.md

@@ -1,127 +0,0 @@
-# Custom Commands Server Example
-
-This example demonstrates both auto-registration and manual registration of commands in the MCP Proxy Adapter framework.
-
-## Registration Methods
-
-### 1. Auto-Registration
-
-Commands are automatically discovered and registered by the framework if they:
-- Are located in packages that follow the naming convention
-- Have class names ending with "Command"
-- Inherit from the `Command` base class
-
-**Location:** `auto_commands/` package
-**Files:** 
-- `auto_echo_command.py` - AutoEchoCommand
-- `auto_info_command.py` - AutoInfoCommand
-
-**How it works:**
-```python
-# Framework automatically discovers commands in auto_commands/ package
-registry.discover_commands("mcp_proxy_adapter.examples.custom_commands.auto_commands")
-```
-
-### 2. Manual Registration
-
-Commands are explicitly registered in the server code using:
-- `registry.register()` - for regular commands
-- `registry.register_custom_command()` - for commands that override built-ins
-
-**Location:** Main server file
-**Files:**
-- `echo_command.py` - EchoCommand
-- `custom_help_command.py` - CustomHelpCommand
-- `custom_health_command.py` - CustomHealthCommand
-- `data_transform_command.py` - DataTransformCommand
-- `intercept_command.py` - InterceptCommand
-- `manual_echo_command.py` - ManualEchoCommand
-
-**How it works:**
-```python
-# Explicit registration in server code
-registry.register(EchoCommand)
-registry.register_custom_command(CustomHelpCommand)  # Overrides built-in
-```
-
-### 3. Built-in Commands
-
-Framework provides default commands that are registered automatically:
-- `help` - HelpCommand
-- `health` - HealthCommand
-
-These can be overridden by custom commands using `register_custom_command()`.
-
-## Command Hierarchy
-
-1. **Custom Commands** (highest priority) - registered with `register_custom_command()`
-2. **Manually Registered Commands** - registered with `register()`
-3. **Auto-Registered Commands** - discovered automatically
-4. **Built-in Commands** (lowest priority) - framework defaults
-
-## Testing Commands
-
-### Auto-Registered Commands
-```bash
-# Test auto-registered echo
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc": "2.0", "method": "auto_echo", "params": {"message": "Hello!"}, "id": 1}'
-
-# Test auto-registered info
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc": "2.0", "method": "auto_info", "params": {"topic": "test"}, "id": 2}'
-```
-
-### Manually Registered Commands
-```bash
-# Test manually registered echo
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc": "2.0", "method": "manual_echo", "params": {"message": "Hello!"}, "id": 3}'
-
-# Test other manually registered commands
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc": "2.0", "method": "echo", "params": {"message": "Hello!"}, "id": 4}'
-```
-
-### Built-in Commands (or overridden)
-```bash
-# Test help command (custom or built-in)
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc": "2.0", "method": "help", "id": 5}'
-
-# Test health command (custom or built-in)
-curl -X POST http://localhost:8000/cmd \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc": "2.0", "method": "health", "id": 6}'
-```
-
-## Features Demonstrated
-
-### Auto-Registration
-- ✅ Automatic command discovery
-- ✅ Naming convention compliance
-- ✅ Package-based organization
-- ✅ Framework integration
-
-### Manual Registration
-- ✅ Explicit command registration
-- ✅ Custom command overrides
-- ✅ Priority management
-- ✅ Dependency control
-
-### Built-in Commands
-- ✅ Framework defaults
-- ✅ Override capability
-- ✅ Fallback behavior
-- ✅ Consistent API
-
-### Advanced Features
-- ✅ Command hierarchy
-- ✅ Priority resolution
-- ✅ Hook integration
-- ✅ Error handling 

mcp_proxy_adapter/examples/custom_commands/__init__.py

@@ -1,27 +0,0 @@
-"""
-Custom Commands Example
-
-An example of MCP Proxy Adapter server with custom commands:
-- echo command
-- custom help command
-- custom health command
-"""
-
-__version__ = "1.0.0"
-
-# Import all modules to make them available
-from . import echo_command
-from . import custom_help_command
-from . import custom_health_command
-from . import manual_echo_command
-from . import intercept_command
-from . import data_transform_command
-from . import advanced_hooks
-from . import hooks
-from . import custom_settings_manager
-from . import custom_openapi_generator
-# Server import removed to avoid circular imports
-
-# Import auto commands
-from .auto_commands import auto_echo_command
-from .auto_commands import auto_info_command