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

mcp_proxy_adapter/examples/custom_commands/config_single_transport.json

@@ -1,33 +0,0 @@
-{
-  "server": {
-    "host": "0.0.0.0",
-    "port": 8000,
-    "debug": true,
-    "log_level": "INFO"
-  },
-  "logging": {
-    "level": "INFO",
-    "log_dir": "./logs",
-    "console_output": true
-  },
-  "commands": {
-    "auto_discovery": true,
-    "discovery_path": "mcp_proxy_adapter.commands"
-  },
-  "transport": {
-    "type": "http",
-    "port": null,
-    "ssl": {
-      "enabled": false,
-      "cert_file": null,
-      "key_file": null,
-      "ca_cert": null,
-      "verify_client": false,
-      "client_cert_required": false
-    }
-  },
-  "custom": {
-    "description": "Single transport server example",
-    "server_name": "Single Transport MCP Proxy Adapter Server"
-  }
-} 

mcp_proxy_adapter/examples/custom_commands/custom_health_command.py

@@ -1,169 +0,0 @@
-"""
-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

@@ -1,215 +0,0 @@
-"""
-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

@@ -1,76 +0,0 @@
-"""
-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

@@ -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"
-    }
-  }
-}