mcp-proxy-adapter 4.1.1__py3-none-any.whl → 6.1.0__py3-none-any.whl

mcp_proxy_adapter/examples/custom_commands/custom_settings.json

@@ -1,96 +0,0 @@
-{
-  "application": {
-    "name": "Extended MCP Proxy Server with Custom Settings",
-    "version": "2.1.0",
-    "environment": "development",
-    "description": "Advanced server with custom settings management"
-  },
-  "features": {
-    "advanced_hooks": true,
-    "custom_commands": true,
-    "data_transformation": true,
-    "command_interception": true,
-    "performance_monitoring": true,
-    "custom_settings_manager": true
-  },
-  "security": {
-    "enable_authentication": false,
-    "max_request_size": "15MB",
-    "rate_limiting": {
-      "enabled": true,
-      "requests_per_minute": 200,
-      "burst_limit": 50
-    },
-    "cors": {
-      "enabled": true,
-      "allowed_origins": ["*"],
-      "allowed_methods": ["GET", "POST", "PUT", "DELETE"]
-    }
-  },
-  "monitoring": {
-    "enable_metrics": true,
-    "metrics_interval": 30,
-    "health_check_interval": 15,
-    "log_level": "DEBUG",
-    "performance_tracking": {
-      "enabled": true,
-      "track_response_times": true,
-      "track_memory_usage": true
-    }
-  },
-  "custom_commands": {
-    "auto_echo": {
-      "enabled": true,
-      "max_length": 2000,
-      "enable_formatting": true
-    },
-    "data_transform": {
-      "enabled": true,
-      "transform_types": ["uppercase", "lowercase", "reverse", "capitalize", "title"],
-      "enable_custom_transforms": true
-    },
-    "intercept": {
-      "enabled": true,
-      "bypass_conditions": ["input_value == 0", "input_value < 0"],
-      "intercept_all_commands": false
-    },
-    "manual_echo": {
-      "enabled": true,
-      "description": "Manually registered echo command with custom settings"
-    }
-  },
-  "hooks": {
-    "data_transform": {
-      "enabled": true,
-      "transform_types": ["uppercase", "lowercase", "reverse"],
-      "apply_to_all_commands": false
-    },
-    "intercept": {
-      "enabled": true,
-      "bypass_conditions": ["input_value == 0"],
-      "log_interceptions": true
-    }
-  },
-  "database": {
-    "enabled": false,
-    "type": "sqlite",
-    "connection_string": "sqlite:///custom_server.db",
-    "pool_size": 10,
-    "max_overflow": 20
-  },
-  "cache": {
-    "enabled": true,
-    "type": "memory",
-    "ttl": 300,
-    "max_size": 1000
-  },
-  "api": {
-    "version": "v1",
-    "prefix": "/api/v1",
-    "documentation": {
-      "enabled": true,
-      "title": "Extended MCP Proxy API",
-      "description": "Advanced API with custom settings support"
-    }
-  }
-} 

mcp_proxy_adapter/examples/custom_commands/custom_settings_manager.py

@@ -1,241 +0,0 @@
-"""
-Custom Settings Manager Example
-
-This module demonstrates how to create a custom settings manager
-that extends the framework's settings system with application-specific settings.
-"""
-
-import json
-import os
-from typing import Dict, Any, Optional
-from mcp_proxy_adapter.core.settings import (
-    add_custom_settings,
-    get_custom_settings,
-    get_custom_setting_value,
-    set_custom_setting_value
-)
-from mcp_proxy_adapter.core.logging import get_logger
-
-
-class CustomSettingsManager:
-    """
-    Custom settings manager for the extended server example.
-    
-    This class demonstrates how to:
-    1. Load custom settings from JSON files
-    2. Add them to the framework's settings system
-    3. Provide convenient access methods
-    4. Handle settings validation and defaults
-    """
-    
-    def __init__(self, config_file: str = "custom_settings.json"):
-        """
-        Initialize the custom settings manager.
-        
-        Args:
-            config_file: Path to custom settings JSON file
-        """
-        self.config_file = config_file
-        self.logger = get_logger("custom_settings_manager")
-        self._load_custom_settings()
-    
-    def _load_custom_settings(self) -> None:
-        """Load custom settings from JSON file."""
-        try:
-            if os.path.exists(self.config_file):
-                with open(self.config_file, 'r', encoding='utf-8') as f:
-                    custom_settings = json.load(f)
-                
-                self.logger.info(f"📁 Loaded custom settings from: {self.config_file}")
-                self.logger.debug(f"📋 Custom settings: {custom_settings}")
-                
-                # Add to framework's settings system
-                add_custom_settings(custom_settings)
-                
-            else:
-                self.logger.warning(f"⚠️  Custom settings file not found: {self.config_file}")
-                self.logger.info("📝 Using default custom settings")
-                
-                # Use default settings
-                default_settings = self._get_default_settings()
-                add_custom_settings(default_settings)
-                
-        except Exception as e:
-            self.logger.error(f"❌ Failed to load custom settings: {e}")
-            self.logger.info("📝 Using default custom settings")
-            
-            # Use default settings on error
-            default_settings = self._get_default_settings()
-            add_custom_settings(default_settings)
-    
-    def _get_default_settings(self) -> Dict[str, Any]:
-        """Get default custom settings."""
-        return {
-            "application": {
-                "name": "Extended MCP Proxy Server",
-                "version": "2.0.0",
-                "environment": "development"
-            },
-            "features": {
-                "advanced_hooks": True,
-                "custom_commands": True,
-                "data_transformation": True,
-                "command_interception": True,
-                "performance_monitoring": False
-            },
-            "security": {
-                "enable_authentication": False,
-                "max_request_size": "10MB",
-                "rate_limiting": {
-                    "enabled": False,
-                    "requests_per_minute": 100
-                }
-            },
-            "monitoring": {
-                "enable_metrics": True,
-                "metrics_interval": 60,
-                "health_check_interval": 30
-            },
-            "custom_commands": {
-                "auto_echo": {
-                    "enabled": True,
-                    "max_length": 1000
-                },
-                "data_transform": {
-                    "enabled": True,
-                    "transform_types": ["uppercase", "lowercase", "reverse"]
-                },
-                "intercept": {
-                    "enabled": True,
-                    "bypass_conditions": ["input_value == 0"]
-                }
-            }
-        }
-    
-    def get_application_name(self) -> str:
-        """Get application name."""
-        return get_custom_setting_value("application.name", "Extended MCP Proxy Server")
-    
-    def get_application_version(self) -> str:
-        """Get application version."""
-        return get_custom_setting_value("application.version", "2.0.0")
-    
-    def get_environment(self) -> str:
-        """Get application environment."""
-        return get_custom_setting_value("application.environment", "development")
-    
-    def is_feature_enabled(self, feature_name: str) -> bool:
-        """Check if a feature is enabled."""
-        return get_custom_setting_value(f"features.{feature_name}", False)
-    
-    def get_security_setting(self, setting_name: str, default: Any = None) -> Any:
-        """Get security setting."""
-        return get_custom_setting_value(f"security.{setting_name}", default)
-    
-    def get_monitoring_setting(self, setting_name: str, default: Any = None) -> Any:
-        """Get monitoring setting."""
-        return get_custom_setting_value(f"monitoring.{setting_name}", default)
-    
-    def get_custom_command_setting(self, command_name: str, setting_name: str, default: Any = None) -> Any:
-        """Get custom command setting."""
-        return get_custom_setting_value(f"custom_commands.{command_name}.{setting_name}", default)
-    
-    def set_custom_setting(self, key: str, value: Any) -> None:
-        """Set a custom setting."""
-        set_custom_setting_value(key, value)
-        self.logger.info(f"🔧 Set custom setting: {key} = {value}")
-    
-    def get_all_custom_settings(self) -> Dict[str, Any]:
-        """Get all custom settings."""
-        return get_custom_settings()
-    
-    def reload_settings(self) -> None:
-        """Reload custom settings from file."""
-        self.logger.info("🔄 Reloading custom settings...")
-        self._load_custom_settings()
-        self.logger.info("✅ Custom settings reloaded")
-    
-    def validate_settings(self) -> Dict[str, Any]:
-        """
-        Validate current settings and return validation results.
-        
-        Returns:
-            Dictionary with validation results
-        """
-        validation_results = {
-            "valid": True,
-            "errors": [],
-            "warnings": []
-        }
-        
-        # Validate required settings
-        required_settings = [
-            "application.name",
-            "application.version",
-            "features.advanced_hooks"
-        ]
-        
-        for setting in required_settings:
-            if get_custom_setting_value(setting) is None:
-                validation_results["valid"] = False
-                validation_results["errors"].append(f"Missing required setting: {setting}")
-        
-        # Validate feature dependencies
-        if self.is_feature_enabled("data_transformation"):
-            if not self.is_feature_enabled("custom_commands"):
-                validation_results["warnings"].append(
-                    "data_transformation requires custom_commands to be enabled"
-                )
-        
-        # Validate security settings
-        if self.get_security_setting("enable_authentication"):
-            if not self.get_security_setting("rate_limiting.enabled"):
-                validation_results["warnings"].append(
-                    "Authentication enabled but rate limiting is disabled"
-                )
-        
-        return validation_results
-    
-    def print_settings_summary(self) -> None:
-        """Print a summary of current settings."""
-        self.logger.info("📊 Custom Settings Summary:")
-        self.logger.info(f"   Application: {self.get_application_name()} v{self.get_application_version()}")
-        self.logger.info(f"   Environment: {self.get_environment()}")
-        
-        # Features
-        features = []
-        for feature in ["advanced_hooks", "custom_commands", "data_transformation", "command_interception"]:
-            if self.is_feature_enabled(feature):
-                features.append(feature)
-        
-        self.logger.info(f"   Enabled Features: {', '.join(features) if features else 'None'}")
-        
-        # Security
-        auth_enabled = self.get_security_setting("enable_authentication", False)
-        rate_limiting = self.get_security_setting("rate_limiting.enabled", False)
-        self.logger.info(f"   Security: Auth={auth_enabled}, Rate Limiting={rate_limiting}")
-        
-        # Monitoring
-        metrics_enabled = self.get_monitoring_setting("enable_metrics", False)
-        self.logger.info(f"   Monitoring: Metrics={metrics_enabled}")
-
-
-# Convenience functions for easy access
-def get_app_name() -> str:
-    """Get application name."""
-    return get_custom_setting_value("application.name", "Extended MCP Proxy Server")
-
-
-def is_feature_enabled(feature_name: str) -> bool:
-    """Check if a feature is enabled."""
-    return get_custom_setting_value(f"features.{feature_name}", False)
-
-
-def get_security_setting(setting_name: str, default: Any = None) -> Any:
-    """Get security setting."""
-    return get_custom_setting_value(f"security.{setting_name}", default)
-
-
-def get_monitoring_setting(setting_name: str, default: Any = None) -> Any:
-    """Get monitoring setting."""
-    return get_custom_setting_value(f"monitoring.{setting_name}", default) 

mcp_proxy_adapter/examples/custom_commands/data_transform_command.py

@@ -1,135 +0,0 @@
-"""
-Data Transform Command Example
-
-A command that demonstrates advanced hooks with data transformation.
-"""
-
-from typing import Dict, Any, Optional
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult
-
-
-class DataTransformResult(CommandResult):
-    """
-    Result of the data transform command execution.
-    """
-    
-    def __init__(self, original_data: Dict[str, Any], transformed_data: Dict[str, Any], 
-                 processing_info: Dict[str, Any]):
-        """
-        Initialize data transform command result.
-        
-        Args:
-            original_data: Original input data
-            transformed_data: Transformed output data
-            processing_info: Information about processing steps
-        """
-        self.original_data = original_data
-        self.transformed_data = transformed_data
-        self.processing_info = processing_info
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert result to dictionary.
-        
-        Returns:
-            Dict[str, Any]: Result as dictionary
-        """
-        return {
-            "original_data": self.original_data,
-            "transformed_data": self.transformed_data,
-            "processing_info": self.processing_info,
-            "command_type": "data_transform"
-        }
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for the result.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "original_data": {"type": "object"},
-                "transformed_data": {"type": "object"},
-                "processing_info": {"type": "object"},
-                "command_type": {"type": "string"}
-            }
-        }
-
-
-class DataTransformCommand(Command):
-    """
-    Data transform command for demonstrating advanced hooks.
-    """
-    
-    name = "data_transform"
-    result_class = DataTransformResult
-    
-    async def execute(self, data: Optional[Dict[str, Any]] = None, 
-                     transform_type: Optional[str] = None, **kwargs) -> DataTransformResult:
-        """
-        Execute data transform command.
-        
-        Args:
-            data: Input data to transform
-            transform_type: Type of transformation to apply
-            **kwargs: Additional parameters
-            
-        Returns:
-            DataTransformResult: Data transform command result
-        """
-        # Get original data (may be modified by hooks)
-        original_data = data or {}
-        transform_type = transform_type or "default"
-        
-        # Apply transformation based on type
-        if transform_type == "uppercase":
-            transformed_data = {k: str(v).upper() for k, v in original_data.items()}
-        elif transform_type == "lowercase":
-            transformed_data = {k: str(v).lower() for k, v in original_data.items()}
-        elif transform_type == "reverse":
-            transformed_data = {k: str(v)[::-1] for k, v in original_data.items()}
-        else:
-            transformed_data = original_data.copy()
-        
-        # Add processing info
-        processing_info = {
-            "transform_type": transform_type,
-            "input_keys": list(original_data.keys()),
-            "output_keys": list(transformed_data.keys()),
-            "hook_enhanced": kwargs.get("hook_enhanced", False),
-            "data_modified": kwargs.get("data_modified", False)
-        }
-        
-        return DataTransformResult(
-            original_data=original_data,
-            transformed_data=transformed_data,
-            processing_info=processing_info
-        )
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "data": {
-                    "type": "object",
-                    "description": "Input data to transform"
-                },
-                "transform_type": {
-                    "type": "string",
-                    "enum": ["uppercase", "lowercase", "reverse", "default"],
-                    "description": "Type of transformation to apply"
-                }
-            }
-        } 

mcp_proxy_adapter/examples/custom_commands/echo_command.py

@@ -1,122 +0,0 @@
-"""
-Echo Command Example
-
-A simple echo command that returns the input message.
-"""
-
-from typing import Dict, Any, Optional
-from datetime import datetime
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import SuccessResult
-
-
-class EchoResult(SuccessResult):
-    """
-    Result of the echo command execution.
-    """
-    
-    def __init__(self, message: str, timestamp: str):
-        """
-        Initialize echo command result.
-        
-        Args:
-            message: The echoed message
-            timestamp: Timestamp of execution
-        """
-        super().__init__(
-            data={
-                "message": message,
-                "timestamp": timestamp,
-                "echoed": True
-            }
-        )
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result validation.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "data": {
-                    "type": "object",
-                    "properties": {
-                        "message": {"type": "string"},
-                        "timestamp": {"type": "string"},
-                        "echoed": {"type": "boolean"}
-                    },
-                    "required": ["message", "timestamp", "echoed"]
-                }
-            },
-            "required": ["data"]
-        }
-
-
-class EchoCommand(Command):
-    """
-    Echo command that returns the input message.
-    """
-    
-    name = "echo"
-    result_class = EchoResult
-    
-    async def execute(self, message: Optional[str] = None, **kwargs) -> EchoResult:
-        """
-        Execute echo command.
-        
-        Args:
-            message: Message to echo (optional)
-            **kwargs: Additional parameters
-            
-        Returns:
-            EchoResult: Echo command result
-        """
-        # Use provided message or default
-        if message is None:
-            message = kwargs.get("text", "Hello, World!")
-        
-        # Check if hook added timestamp
-        hook_timestamp = kwargs.get("hook_timestamp")
-        if hook_timestamp:
-            # Use hook timestamp if available
-            timestamp = hook_timestamp
-        else:
-            # Get current timestamp
-            timestamp = datetime.now().isoformat()
-        
-        # Add hook metadata to result
-        result = EchoResult(message=message, timestamp=timestamp)
-        
-        # Add hook information if available
-        if kwargs.get("hook_processed"):
-            result.data["hook_processed"] = True
-            result.data["hook_timestamp"] = hook_timestamp
-        
-        return result
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "message": {
-                    "type": "string",
-                    "description": "Message to echo",
-                    "default": "Hello, World!"
-                },
-                "text": {
-                    "type": "string", 
-                    "description": "Alternative parameter name for message"
-                }
-            }
-        }