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

mcp_proxy_adapter/examples/custom_commands/custom_health_command.py

@@ -0,0 +1,169 @@
+"""
+Custom Health Command Example
+
+A custom health command with enhanced system information.
+"""
+
+import os
+import platform
+import sys
+import psutil
+from datetime import datetime
+from typing import Dict, Any
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+from mcp_proxy_adapter.commands.command_registry import registry
+
+
+class CustomHealthResult(SuccessResult):
+    """
+    Result of the custom health command execution.
+    """
+    
+    def __init__(self, status: str, version: str, uptime: float, 
+                 components: Dict[str, Any], custom_metrics: Dict[str, Any]):
+        """
+        Initialize custom health command result.
+        
+        Args:
+            status: Server status ("ok" or "error")
+            version: Server version
+            uptime: Server uptime in seconds
+            components: Dictionary with components status
+            custom_metrics: Additional custom metrics
+        """
+        super().__init__(
+            data={
+                "status": status,
+                "version": version,
+                "uptime": uptime,
+                "components": components,
+                "custom_metrics": custom_metrics,
+                "custom_health": 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": {
+                        "status": {"type": "string"},
+                        "version": {"type": "string"},
+                        "uptime": {"type": "number"},
+                        "components": {"type": "object"},
+                        "custom_metrics": {"type": "object"},
+                        "custom_health": {"type": "boolean"}
+                    },
+                    "required": ["status", "version", "uptime", "components", "custom_metrics", "custom_health"]
+                }
+            },
+            "required": ["data"]
+        }
+
+
+class CustomHealthCommand(Command):
+    """
+    Custom health command with enhanced system information.
+    """
+    
+    name = "health"
+    result_class = CustomHealthResult
+    
+    async def execute(self, **kwargs) -> CustomHealthResult:
+        """
+        Execute custom health command.
+        
+        Returns:
+            CustomHealthResult: Custom health command result
+        """
+        # Get version from package
+        try:
+            from mcp_proxy_adapter.version import __version__ as version
+        except ImportError:
+            version = "unknown"
+        
+        # Get process start time
+        process = psutil.Process(os.getpid())
+        start_time = datetime.fromtimestamp(process.create_time())
+        uptime_seconds = (datetime.now() - start_time).total_seconds()
+        
+        # Get system information
+        system_info = {
+            "platform": platform.platform(),
+            "python_version": sys.version,
+            "cpu_count": psutil.cpu_count(),
+            "memory_total": psutil.virtual_memory().total,
+            "memory_available": psutil.virtual_memory().available
+        }
+        
+        # Get process information
+        process_info = {
+            "pid": os.getpid(),
+            "memory_usage": process.memory_info().rss,
+            "cpu_percent": process.cpu_percent(),
+            "create_time": process.create_time()
+        }
+        
+        # Get commands information
+        from mcp_proxy_adapter.commands.command_registry import registry
+        commands_info = {
+            "total_commands": len(registry.get_all_commands()),
+            "custom_commands": ["echo", "help", "health"],
+            "registry_status": "active"
+        }
+        
+        # Custom metrics
+        custom_metrics = {
+            "custom_health_check": True,
+            "enhanced_monitoring": True,
+            "system_load": psutil.getloadavg() if hasattr(psutil, 'getloadavg') else None,
+            "disk_usage": {
+                "total": psutil.disk_usage('/').total,
+                "free": psutil.disk_usage('/').free,
+                "used": psutil.disk_usage('/').used
+            },
+            "network_interfaces": len(psutil.net_if_addrs()),
+            "custom_features": ["enhanced_metrics", "system_monitoring", "custom_health"],
+            "hook_enhanced": kwargs.get("hook_enhanced", False),
+            "health_check_id": kwargs.get("health_check_id"),
+            "global_hook_processed": kwargs.get("global_hook_processed", False)
+        }
+        
+        components = {
+            "system": system_info,
+            "process": process_info,
+            "commands": commands_info
+        }
+        
+        return CustomHealthResult(
+            status="ok",
+            version=version,
+            uptime=uptime_seconds,
+            components=components,
+            custom_metrics=custom_metrics
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {},
+            "description": "Get enhanced system health information"
+        } 

mcp_proxy_adapter/examples/custom_commands/custom_help_command.py

@@ -0,0 +1,215 @@
+"""
+Custom Help Command Example
+
+A custom help command that provides enhanced help information.
+"""
+
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.errors import NotFoundError
+
+
+class CustomHelpResult(CommandResult):
+    """
+    Result of the custom help command execution.
+    """
+    
+    def __init__(self, commands_info: Optional[Dict[str, Any]] = None, 
+                 command_info: Optional[Dict[str, Any]] = None,
+                 custom_info: Optional[Dict[str, Any]] = None):
+        """
+        Initialize custom help command result.
+        
+        Args:
+            commands_info: Information about all commands
+            command_info: Information about a specific command
+            custom_info: Additional custom information
+        """
+        self.commands_info = commands_info
+        self.command_info = command_info
+        self.custom_info = custom_info or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dict[str, Any]: Result as dictionary
+        """
+        if self.command_info is not None:
+            return {
+                "cmdname": self.command_info.get("name", "unknown"),
+                "info": {
+                    "description": self.command_info.get("description", ""),
+                    "summary": self.command_info.get("summary", ""),
+                    "params": self.command_info.get("params", {}),
+                    "examples": self.command_info.get("examples", []),
+                    "custom_help": True
+                }
+            }
+        
+        if self.commands_info is None:
+            return {
+                "tool_info": {
+                    "name": "Custom MCP-Proxy API Service",
+                    "description": "Enhanced JSON-RPC API with custom commands",
+                    "version": "2.0.0",
+                    "custom_help": True
+                },
+                "help_usage": {
+                    "description": "Get enhanced information about commands",
+                    "examples": [
+                        {"command": "help", "description": "List of all available commands"},
+                        {"command": "help", "params": {"cmdname": "command_name"}, "description": "Get detailed information about a specific command"}
+                    ]
+                },
+                "commands": {},
+                "total": 0,
+                "custom_features": self.custom_info
+            }
+        
+        result = self.commands_info.copy()
+        commands = result.get("commands", {})
+        result["total"] = len(commands)
+        result["custom_help"] = True
+        result["custom_features"] = self.custom_info
+        
+        return result
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for the result.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "cmdname": {
+                    "type": "string",
+                    "description": "Name of the command"
+                },
+                "info": {
+                    "type": "object",
+                    "properties": {
+                        "description": {"type": "string"},
+                        "summary": {"type": "string"},
+                        "params": {"type": "object"},
+                        "examples": {"type": "array"},
+                        "custom_help": {"type": "boolean"}
+                    }
+                },
+                "tool_info": {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                        "description": {"type": "string"},
+                        "version": {"type": "string"},
+                        "custom_help": {"type": "boolean"}
+                    }
+                },
+                "help_usage": {
+                    "type": "object",
+                    "properties": {
+                        "description": {"type": "string"},
+                        "examples": {"type": "array"}
+                    }
+                },
+                "commands": {"type": "object"},
+                "total": {"type": "integer"},
+                "custom_features": {"type": "object"}
+            }
+        }
+
+
+class CustomHelpCommand(Command):
+    """
+    Custom help command with enhanced functionality.
+    """
+    
+    name = "help"
+    result_class = CustomHelpResult
+    
+    async def execute(self, cmdname: Optional[str] = None, **kwargs) -> CustomHelpResult:
+        """
+        Execute custom help command.
+        
+        Args:
+            cmdname: Name of specific command to get help for
+            **kwargs: Additional parameters
+            
+        Returns:
+            CustomHelpResult: Custom help command result
+        """
+        try:
+            # Check if hook processed this request
+            request_id = kwargs.get("request_id")
+            hook_processed = kwargs.get("hook_processed", False)
+            
+            if cmdname is not None:
+                # Get specific command info
+                command_info = registry.get_command_info(cmdname)
+                if command_info is None:
+                    raise NotFoundError(f"Command '{cmdname}' not found")
+                
+                custom_info = {
+                    "enhanced": True, 
+                    "command_specific": True,
+                    "request_id": request_id,
+                    "hook_processed": hook_processed
+                }
+                
+                return CustomHelpResult(
+                    command_info=command_info,
+                    custom_info=custom_info
+                )
+            else:
+                # Get all commands info
+                commands_info = registry.get_all_commands_info()
+                
+                custom_info = {
+                    "enhanced": True,
+                    "total_commands": len(commands_info.get("commands", {})),
+                    "custom_commands": ["echo", "help", "health"],
+                    "request_id": request_id,
+                    "hook_processed": hook_processed
+                }
+                
+                return CustomHelpResult(
+                    commands_info=commands_info,
+                    custom_info=custom_info
+                )
+                
+        except Exception as e:
+            # Return error result
+            return CustomHelpResult(
+                custom_info={
+                    "error": str(e),
+                    "enhanced": True,
+                    "error_handling": True,
+                    "request_id": request_id,
+                    "hook_processed": hook_processed
+                }
+            )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "cmdname": {
+                    "type": "string",
+                    "description": "Name of specific command to get help for"
+                }
+            }
+        } 

mcp_proxy_adapter/examples/custom_commands/custom_openapi_generator.py

@@ -0,0 +1,76 @@
+"""
+Custom OpenAPI generator example for the extended server.
+
+This demonstrates how to create a custom OpenAPI schema generator
+that can be registered with the framework.
+"""
+
+from typing import Dict, Any
+from fastapi import FastAPI
+
+from mcp_proxy_adapter.custom_openapi import register_openapi_generator, CustomOpenAPIGenerator
+from mcp_proxy_adapter.core.logging import logger
+
+
+def custom_openapi_generator(app: FastAPI) -> Dict[str, Any]:
+    """
+    Custom OpenAPI generator for the extended server example.
+    
+    This generator extends the default generator with additional
+    information specific to the extended server.
+    
+    Args:
+        app: FastAPI application instance.
+        
+    Returns:
+        Custom OpenAPI schema.
+    """
+    # Use the default generator as base
+    default_generator = CustomOpenAPIGenerator()
+    schema = default_generator.generate(
+        title=getattr(app, 'title', None),
+        description=getattr(app, 'description', None),
+        version=getattr(app, 'version', None)
+    )
+    
+    # Add custom information to the schema
+    schema["info"]["description"] += "\n\n## Extended Server Features:\n"
+    schema["info"]["description"] += "- Custom commands with hooks\n"
+    schema["info"]["description"] += "- Data transformation hooks\n"
+    schema["info"]["description"] += "- Command interception hooks\n"
+    schema["info"]["description"] += "- Auto-registration and manual registration examples\n"
+    
+    # Add custom tags
+    if "tags" not in schema:
+        schema["tags"] = []
+    
+    schema["tags"].extend([
+        {
+            "name": "custom-commands",
+            "description": "Custom commands with advanced features"
+        },
+        {
+            "name": "hooks",
+            "description": "Command hooks for data transformation and interception"
+        },
+        {
+            "name": "registration",
+            "description": "Command registration examples"
+        }
+    ])
+    
+    # Add custom server information
+    if "servers" not in schema:
+        schema["servers"] = []
+    
+    schema["servers"].append({
+        "url": "http://localhost:8000",
+        "description": "Extended server with custom features"
+    })
+    
+    logger.info("Generated custom OpenAPI schema for extended server")
+    return schema
+
+
+# Register the custom generator
+register_openapi_generator("extended_server", custom_openapi_generator) 

mcp_proxy_adapter/examples/custom_commands/custom_settings.json

@@ -0,0 +1,96 @@
+{
+  "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"
+    }
+  }
+}