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

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
-from . import server
-
-# Import auto commands
-from .auto_commands import auto_echo_command
-from .auto_commands import auto_info_command 

mcp_proxy_adapter/examples/custom_commands/advanced_hooks.py

@@ -1,250 +0,0 @@
-"""
-Advanced Hooks Example
-
-This module demonstrates advanced hook capabilities:
-1. Data transformation hooks - modify input data before command execution and format output after
-2. Interception hooks - completely bypass command execution based on conditions
-"""
-
-import time
-import logging
-from typing import Dict, Any
-from datetime import datetime
-
-from mcp_proxy_adapter.commands.hooks import HookContext, HookType
-from mcp_proxy_adapter.commands.result import CommandResult
-
-
-# Setup logging for advanced hooks
-logger = logging.getLogger("mcp_proxy_adapter.examples.advanced_hooks")
-
-
-def data_transform_before_hook(context: HookContext) -> None:
-    """
-    Before hook for data_transform command - modifies input data.
-    
-    Args:
-        context: Hook context with command information
-    """
-    logger.info(f"🔄 Data transform before hook: {context.params}")
-    
-    # Get original data
-    original_data = context.params.get("data", {})
-    
-    # Transform data before command execution
-    transformed_data = {}
-    for key, value in original_data.items():
-        if isinstance(value, str):
-            # Add prefix and suffix to string values
-            transformed_data[f"pre_{key}_post"] = f"ENHANCED_{value}_PROCESSED"
-        elif isinstance(value, (int, float)):
-            # Multiply numeric values by 2
-            transformed_data[f"doubled_{key}"] = value * 2
-        else:
-            # Keep other types as is
-            transformed_data[key] = value
-    
-    # Add metadata
-    transformed_data["_hook_modified"] = True
-    transformed_data["_modification_time"] = datetime.now().isoformat()
-    
-    # Replace original data with transformed data
-    context.params["data"] = transformed_data
-    context.params["data_modified"] = True
-    
-    logger.info(f"📊 Original data: {original_data}")
-    logger.info(f"🔄 Transformed data: {transformed_data}")
-
-
-def data_transform_after_hook(context: HookContext) -> None:
-    """
-    After hook for data_transform command - formats output data.
-    
-    Args:
-        context: Hook context with command information
-    """
-    logger.info(f"🔄 Data transform after hook: {context.result}")
-    
-    if context.result and hasattr(context.result, 'transformed_data'):
-        # Get the transformed data from command result
-        transformed_data = context.result.transformed_data
-        
-        # Apply additional formatting
-        formatted_data = {}
-        for key, value in transformed_data.items():
-            if isinstance(value, str):
-                # Add formatting to string values
-                formatted_data[f"formatted_{key}"] = f"✨ {value} ✨"
-            else:
-                formatted_data[key] = value
-        
-        # Add formatting metadata
-        formatted_data["_formatted_by_hook"] = True
-        formatted_data["_formatting_time"] = datetime.now().isoformat()
-        
-        # Update the result with formatted data
-        context.result.transformed_data = formatted_data
-        
-        logger.info(f"✨ Formatted data: {formatted_data}")
-
-
-def intercept_before_hook(context: HookContext) -> None:
-    """
-    Before hook for intercept command - can completely bypass execution.
-    
-    Args:
-        context: Hook context with command information
-    """
-    logger.info(f"🚫 Intercept before hook: {context.params}")
-    
-    # Check bypass flag
-    bypass_flag = context.params.get("bypass_flag", 1)
-    
-    if bypass_flag == 0:
-        # Completely bypass command execution
-        logger.info(f"🚫 Intercepting command execution - bypass_flag = 0")
-        
-        # Create a mock result without calling the actual command
-        from .intercept_command import InterceptResult
-        
-        mock_result = InterceptResult(
-            message="Command intercepted by hook - not executed",
-            executed=False,
-            intercept_reason="bypass_flag = 0",
-            hook_data={
-                "intercepted_by": "intercept_before_hook",
-                "interception_time": datetime.now().isoformat(),
-                "original_params": context.params.copy()
-            }
-        )
-        
-        # Set the result and stop standard processing
-        context.result = mock_result
-        context.standard_processing = False
-        
-        logger.info(f"✅ Command intercepted successfully")
-    else:
-        # Allow normal execution
-        logger.info(f"✅ Allowing normal execution - bypass_flag = {bypass_flag}")
-        context.params["hook_processed"] = True
-
-
-def intercept_after_hook(context: HookContext) -> None:
-    """
-    After hook for intercept command.
-    
-    Args:
-        context: Hook context with command information
-    """
-    if context.standard_processing:
-        logger.info(f"✅ Intercept command executed normally")
-    else:
-        logger.info(f"🚫 Intercept command was intercepted by hook")
-    
-    # Add execution metadata
-    if context.result and hasattr(context.result, 'hook_data'):
-        context.result.hook_data["after_hook_processed"] = True
-        context.result.hook_data["after_hook_time"] = datetime.now().isoformat()
-
-
-def conditional_transform_hook(context: HookContext) -> None:
-    """
-    Conditional transformation hook - applies different transformations based on data.
-    
-    Args:
-        context: Hook context with command information
-    """
-    if context.hook_type == HookType.BEFORE_EXECUTION:
-        logger.info(f"🎯 Conditional transform before hook: {context.command_name}")
-        
-        # Check if this is a data_transform command
-        if context.command_name == "data_transform":
-            data = context.params.get("data", {})
-            transform_type = context.params.get("transform_type", "default")
-            
-            # Apply conditional transformation based on data content
-            if "special" in str(data).lower():
-                logger.info(f"🎯 Special data detected - applying enhanced transformation")
-                context.params["transform_type"] = "uppercase"
-                context.params["_special_enhancement"] = True
-            elif "test" in str(data).lower():
-                logger.info(f"🎯 Test data detected - applying test transformation")
-                context.params["transform_type"] = "reverse"
-                context.params["_test_mode"] = True
-    
-    elif context.hook_type == HookType.AFTER_EXECUTION:
-        logger.info(f"🎯 Conditional transform after hook: {context.command_name}")
-        
-        # Add conditional metadata to result
-        if context.result and hasattr(context.result, 'processing_info'):
-            context.result.processing_info["conditional_processed"] = True
-            context.result.processing_info["conditional_time"] = datetime.now().isoformat()
-
-
-def smart_intercept_hook(context: HookContext) -> None:
-    """
-    Smart interception hook - intercepts based on multiple conditions.
-    
-    Args:
-        context: Hook context with command information
-    """
-    if context.hook_type == HookType.BEFORE_EXECUTION:
-        logger.info(f"🧠 Smart intercept before hook: {context.command_name}")
-        
-        # Check multiple conditions for interception
-        action = context.params.get("action", "")
-        bypass_flag = context.params.get("bypass_flag", 1)
-        
-        # Intercept if action is "blocked" or bypass_flag is 0
-        if action == "blocked" or bypass_flag == 0:
-            logger.info(f"🧠 Smart intercept: action='{action}', bypass_flag={bypass_flag}")
-            
-            # Create intercepted result
-            from .intercept_command import InterceptResult
-            
-            intercept_reason = "blocked_action" if action == "blocked" else "bypass_flag_zero"
-            
-            mock_result = InterceptResult(
-                message=f"Command intercepted by smart hook - reason: {intercept_reason}",
-                executed=False,
-                intercept_reason=intercept_reason,
-                hook_data={
-                    "intercepted_by": "smart_intercept_hook",
-                    "interception_time": datetime.now().isoformat(),
-                    "original_params": context.params.copy(),
-                    "smart_analysis": True
-                }
-            )
-            
-            # Set the result and stop standard processing
-            context.result = mock_result
-            context.standard_processing = False
-            
-            logger.info(f"✅ Smart interception completed")
-
-
-def register_advanced_hooks(hooks_manager) -> None:
-    """
-    Register advanced hooks with the hooks manager.
-    
-    Args:
-        hooks_manager: The hooks manager instance
-    """
-    logger.info("🔧 Registering advanced hooks...")
-    
-    # Register data transformation hooks
-    hooks_manager.register_before_hook("data_transform", data_transform_before_hook)
-    hooks_manager.register_after_hook("data_transform", data_transform_after_hook)
-    
-    # Register interception hooks
-    hooks_manager.register_before_hook("intercept", intercept_before_hook)
-    hooks_manager.register_after_hook("intercept", intercept_after_hook)
-    
-    # Register conditional hooks
-    hooks_manager.register_global_before_hook(conditional_transform_hook)
-    hooks_manager.register_global_after_hook(conditional_transform_hook)
-    
-    # Register smart interception hooks
-    hooks_manager.register_global_before_hook(smart_intercept_hook)
-    
-    logger.info("✅ Advanced hooks registered successfully") 

mcp_proxy_adapter/examples/custom_commands/auto_commands/__init__.py

@@ -1,6 +0,0 @@
-"""
-Auto-registered commands package.
-
-Commands in this package will be automatically discovered and registered
-by the framework's auto-discovery mechanism.
-""" 

mcp_proxy_adapter/examples/custom_commands/auto_commands/auto_echo_command.py

@@ -1,103 +0,0 @@
-"""
-Auto-registered Echo Command
-
-This command will be automatically discovered and registered by the framework.
-"""
-
-from typing import Dict, Any, Optional
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult
-
-
-class AutoEchoResult(CommandResult):
-    """
-    Result of the auto-registered echo command execution.
-    """
-    
-    def __init__(self, message: str, auto_registered: bool = True):
-        """
-        Initialize auto echo command result.
-        
-        Args:
-            message: Echoed message
-            auto_registered: Flag indicating this was auto-registered
-        """
-        self.message = message
-        self.auto_registered = auto_registered
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert result to dictionary.
-        
-        Returns:
-            Dict[str, Any]: Result as dictionary
-        """
-        return {
-            "message": self.message,
-            "auto_registered": self.auto_registered,
-            "command_type": "auto_echo"
-        }
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for the result.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "message": {"type": "string"},
-                "auto_registered": {"type": "boolean"},
-                "command_type": {"type": "string"}
-            }
-        }
-
-
-class AutoEchoCommand(Command):
-    """
-    Auto-registered echo command.
-    """
-    
-    name = "auto_echo"
-    result_class = AutoEchoResult
-    
-    async def execute(self, message: Optional[str] = None, **kwargs) -> AutoEchoResult:
-        """
-        Execute auto-registered echo command.
-        
-        Args:
-            message: Message to echo
-            **kwargs: Additional parameters
-            
-        Returns:
-            AutoEchoResult: Auto echo command result
-        """
-        if message is None:
-            message = "Hello from auto-registered command!"
-        
-        return AutoEchoResult(
-            message=message,
-            auto_registered=True
-        )
-    
-    @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 from auto-registered command!"
-                }
-            }
-        } 

mcp_proxy_adapter/examples/custom_commands/auto_commands/auto_info_command.py

@@ -1,111 +0,0 @@
-"""
-Auto-registered Info Command
-
-This command will be automatically discovered and registered by the framework.
-"""
-
-from typing import Dict, Any, Optional
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult
-
-
-class AutoInfoResult(CommandResult):
-    """
-    Result of the auto-registered info command execution.
-    """
-    
-    def __init__(self, info: Dict[str, Any], auto_registered: bool = True):
-        """
-        Initialize auto info command result.
-        
-        Args:
-            info: Information data
-            auto_registered: Flag indicating this was auto-registered
-        """
-        self.info = info
-        self.auto_registered = auto_registered
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert result to dictionary.
-        
-        Returns:
-            Dict[str, Any]: Result as dictionary
-        """
-        return {
-            "info": self.info,
-            "auto_registered": self.auto_registered,
-            "command_type": "auto_info"
-        }
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for the result.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "info": {"type": "object"},
-                "auto_registered": {"type": "boolean"},
-                "command_type": {"type": "string"}
-            }
-        }
-
-
-class AutoInfoCommand(Command):
-    """
-    Auto-registered info command.
-    """
-    
-    name = "auto_info"
-    result_class = AutoInfoResult
-    
-    async def execute(self, topic: Optional[str] = None, **kwargs) -> AutoInfoResult:
-        """
-        Execute auto-registered info command.
-        
-        Args:
-            topic: Information topic
-            **kwargs: Additional parameters
-            
-        Returns:
-            AutoInfoResult: Auto info command result
-        """
-        if topic is None:
-            topic = "general"
-        
-        info_data = {
-            "topic": topic,
-            "auto_registered": True,
-            "discovery_method": "automatic",
-            "registration_time": "startup",
-            "command_type": "auto_info"
-        }
-        
-        return AutoInfoResult(
-            info=info_data,
-            auto_registered=True
-        )
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters.
-        
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "topic": {
-                    "type": "string",
-                    "description": "Information topic",
-                    "default": "general"
-                }
-            }
-        } 

mcp_proxy_adapter/examples/custom_commands/config.json

@@ -1,35 +0,0 @@
-{
-  "server": {
-    "host": "0.0.0.0",
-    "port": 8000,
-    "debug": true,
-    "log_level": "DEBUG"
-  },
-  "logging": {
-    "level": "DEBUG",
-    "log_dir": "./logs/custom_commands",
-    "log_file": "custom_commands.log",
-    "error_log_file": "custom_commands_error.log",
-    "access_log_file": "custom_commands_access.log",
-    "max_file_size": "5MB",
-    "backup_count": 3,
-    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    "date_format": "%Y-%m-%d %H:%M:%S",
-    "console_output": true,
-    "file_output": true
-  },
-  "commands": {
-    "auto_discovery": true,
-    "discovery_path": "mcp_proxy_adapter.examples.custom_commands.auto_commands",
-    "custom_commands_path": null
-  },
-  "custom": {
-    "server_name": "Custom Commands MCP Proxy Server",
-    "description": "Example server with custom commands",
-    "features": {
-      "hooks_enabled": true,
-      "custom_commands_enabled": true,
-      "advanced_logging": true
-    }
-  }
-}