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

mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py

@@ -1,25 +1,18 @@
 """
 Custom Echo Command
-
 This module demonstrates a custom command implementation for the full application example.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
-
-
 class CustomEchoResult(CommandResult):
     """Result class for custom echo command."""
-    
     def __init__(self, message: str, timestamp: str, echo_count: int):
         self.message = message
         self.timestamp = timestamp
         self.echo_count = echo_count
-    
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary."""
         return {
@@ -28,7 +21,6 @@ class CustomEchoResult(CommandResult):
             "echo_count": self.echo_count,
             "command_type": "custom_echo"
         }
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get result schema."""
         return {
@@ -41,23 +33,17 @@ class CustomEchoResult(CommandResult):
             },
             "required": ["message", "timestamp", "echo_count", "command_type"]
         }
-
-
 class CustomEchoCommand(BaseCommand):
     """Custom echo command implementation."""
-    
     def __init__(self):
         super().__init__()
         self.echo_count = 0
-    
     def get_name(self) -> str:
         """Get command name."""
         return "custom_echo"
-    
     def get_description(self) -> str:
         """Get command description."""
         return "Custom echo command with enhanced features"
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get command schema."""
         return {
@@ -78,20 +64,15 @@ class CustomEchoCommand(BaseCommand):
             },
             "required": ["message"]
         }
-    
     async def execute(self, params: Dict[str, Any]) -> CustomEchoResult:
         """Execute the custom echo command."""
         message = params.get("message", "Hello from custom echo!")
         repeat = min(max(params.get("repeat", 1), 1), 10)
-        
         self.echo_count += 1
-        
         from datetime import datetime
         timestamp = datetime.now().isoformat()
-        
         # Repeat the message
         echoed_message = " ".join([message] * repeat)
-        
         return CustomEchoResult(
             message=echoed_message,
             timestamp=timestamp,

mcp_proxy_adapter/examples/full_application/commands/dynamic_calculator_command.py

@@ -1,25 +1,18 @@
 """
 Dynamic Calculator Command
-
 This module demonstrates a dynamically loaded command implementation for the full application example.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
-
-
 class CalculatorResult(CommandResult):
     """Result class for calculator command."""
-    
     def __init__(self, operation: str, result: float, expression: str):
         self.operation = operation
         self.result = result
         self.expression = expression
-    
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary."""
         return {
@@ -28,7 +21,6 @@ class CalculatorResult(CommandResult):
             "expression": self.expression,
             "command_type": "dynamic_calculator"
         }
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get result schema."""
         return {
@@ -41,19 +33,14 @@ class CalculatorResult(CommandResult):
             },
             "required": ["operation", "result", "expression", "command_type"]
         }
-
-
 class DynamicCalculatorCommand(BaseCommand):
     """Dynamic calculator command implementation."""
-    
     def get_name(self) -> str:
         """Get command name."""
         return "dynamic_calculator"
-    
     def get_description(self) -> str:
         """Get command description."""
         return "Dynamic calculator with basic mathematical operations"
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get command schema."""
         return {
@@ -75,13 +62,11 @@ class DynamicCalculatorCommand(BaseCommand):
             },
             "required": ["operation", "a", "b"]
         }
-    
     async def execute(self, params: Dict[str, Any]) -> CalculatorResult:
         """Execute the calculator command."""
         operation = params.get("operation")
         a = params.get("a")
         b = params.get("b")
-        
         if operation == "add":
             result = a + b
             expression = f"{a} + {b}"
@@ -98,7 +83,6 @@ class DynamicCalculatorCommand(BaseCommand):
             expression = f"{a} / {b}"
         else:
             raise ValueError(f"Unknown operation: {operation}")
-        
         return CalculatorResult(
             operation=operation,
             result=result,

mcp_proxy_adapter/examples/full_application/hooks/__init__.py

@@ -0,0 +1,7 @@
+"""Full Application Hooks.
+
+Application and command hooks for the full application example.
+"""
+
+from .application_hooks import ApplicationHooks
+from .builtin_command_hooks import BuiltinCommandHooks

mcp_proxy_adapter/examples/full_application/hooks/application_hooks.py

@@ -1,95 +1,73 @@
 """
 Application Hooks
-
 This module demonstrates application-level hooks in the full application example.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import logging
 from typing import Dict, Any, Optional
 from datetime import datetime
-
 logger = logging.getLogger(__name__)
-
-
 class ApplicationHooks:
     """Application-level hooks."""
-    
     @staticmethod
     def on_startup():
         """Hook executed on application startup."""
         logger.info("🚀 Application startup hook executed")
-        
         # Initialize application-specific resources
         logger.info("📊 Initializing application metrics")
         logger.info("🔐 Loading security configurations")
         logger.info("📝 Setting up logging")
-    
     @staticmethod
     def on_shutdown():
         """Hook executed on application shutdown."""
         logger.info("🛑 Application shutdown hook executed")
-        
         # Cleanup application resources
         logger.info("🧹 Cleaning up resources")
         logger.info("💾 Saving application state")
         logger.info("📊 Finalizing metrics")
-    
     @staticmethod
     def before_request(request_data: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before processing any request."""
         logger.info(f"🔧 Application hook: before_request with data: {request_data}")
-        
         # Add request metadata
         request_data["app_metadata"] = {
             "request_id": f"req_{datetime.now().timestamp()}",
             "timestamp": datetime.now().isoformat(),
             "application": "full_application_example"
         }
-        
         return request_data
-    
     @staticmethod
     def after_request(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after processing any request."""
         logger.info(f"🔧 Application hook: after_request with result: {result}")
-        
         # Add response metadata
         result["app_response_metadata"] = {
             "processed_at": datetime.now().isoformat(),
             "application": "full_application_example",
             "version": "1.0.0"
         }
-        
         return result
-    
     @staticmethod
     def on_error(error: Exception, context: Dict[str, Any]):
         """Hook executed when an error occurs."""
         logger.error(f"🔧 Application hook: on_error - {error} in context: {context}")
-        
         # Log error details
         logger.error(f"Error type: {type(error).__name__}")
         logger.error(f"Error message: {str(error)}")
         logger.error(f"Context: {context}")
-    
     @staticmethod
     def on_command_registered(command_name: str, command_info: Dict[str, Any]):
         """Hook executed when a command is registered."""
         logger.info(f"🔧 Application hook: on_command_registered - {command_name}")
         logger.info(f"Command info: {command_info}")
-        
         # Track registered commands
         logger.info(f"📝 Command '{command_name}' registered successfully")
-    
     @staticmethod
     def on_command_executed(command_name: str, execution_time: float, success: bool):
         """Hook executed when a command is executed."""
         logger.info(f"🔧 Application hook: on_command_executed - {command_name}")
         logger.info(f"Execution time: {execution_time}s, Success: {success}")
-        
         # Track command execution metrics
         if success:
             logger.info(f"✅ Command '{command_name}' executed successfully in {execution_time}s")

mcp_proxy_adapter/examples/full_application/hooks/builtin_command_hooks.py

@@ -1,64 +1,47 @@
 """
 Built-in Command Hooks
-
 This module demonstrates hooks for built-in commands in the full application example.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import logging
 from typing import Dict, Any, Optional
 from datetime import datetime
-
 logger = logging.getLogger(__name__)
-
-
 class BuiltinCommandHooks:
     """Hooks for built-in commands."""
-    
     @staticmethod
     def before_echo_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before echo command."""
         logger.info(f"🔧 Built-in hook: before_echo_command with params: {params}")
-        
         # Add timestamp to message
         if "message" in params:
             timestamp = datetime.now().isoformat()
             params["message"] = f"[{timestamp}] {params['message']}"
-        
         return params
-    
     @staticmethod
     def after_echo_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after echo command."""
         logger.info(f"🔧 Built-in hook: after_echo_command with result: {result}")
-        
         # Add hook metadata
         result["hook_metadata"] = {
             "hook_type": "builtin_after_echo",
             "timestamp": datetime.now().isoformat(),
             "processed": True
         }
-        
         return result
-    
     @staticmethod
     def before_health_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before health command."""
         logger.info(f"🔧 Built-in hook: before_health_command with params: {params}")
-        
         # Add custom health check parameters
         params["include_detailed_info"] = True
         params["check_dependencies"] = True
-        
         return params
-    
     @staticmethod
     def after_health_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after health command."""
         logger.info(f"🔧 Built-in hook: after_health_command with result: {result}")
-        
         # Add custom health metrics
         if "status" in result and result["status"] == "healthy":
             result["custom_metrics"] = {
@@ -66,30 +49,23 @@ class BuiltinCommandHooks:
                 "memory_usage": "45%",
                 "cpu_usage": "12%"
             }
-        
         return result
-    
     @staticmethod
     def before_config_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before config command."""
         logger.info(f"🔧 Built-in hook: before_config_command with params: {params}")
-        
         # Add configuration validation
         params["validate_config"] = True
         params["include_secrets"] = False
-        
         return params
-    
     @staticmethod
     def after_config_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after config command."""
         logger.info(f"🔧 Built-in hook: after_config_command with result: {result}")
-        
         # Add configuration metadata
         result["config_metadata"] = {
             "last_modified": datetime.now().isoformat(),
             "version": "1.0.0",
             "environment": "development"
         }
-        
         return result

mcp_proxy_adapter/examples/full_application/main.py

@@ -1,124 +1,149 @@
 #!/usr/bin/env python3
 """
 Full Application Example
-
 This is a complete application that demonstrates all features of MCP Proxy Adapter framework:
 - Built-in commands
 - Custom commands
 - Dynamically loaded commands
 - Built-in command hooks
 - Application hooks
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import sys
 import argparse
 import logging
 from pathlib import Path
-
 # Add the framework to the path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
+from mcp_proxy_adapter.core.app_factory import create_and_run_server
 from mcp_proxy_adapter.api.app import create_app
 from mcp_proxy_adapter.config import Config
 from mcp_proxy_adapter.commands.command_registry import CommandRegistry
-
-
 class FullApplication:
     """Full application example with all framework features."""
-    
     def __init__(self, config_path: str):
         self.config_path = config_path
         self.config = Config(config_path)
         self.app = None
         self.command_registry = None
-        
         # Setup logging
         logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)
-    
     def setup_hooks(self):
         """Setup application hooks."""
         try:
             # Import hooks
             from hooks.application_hooks import ApplicationHooks
             from hooks.builtin_command_hooks import BuiltinCommandHooks
-            
             # Register application hooks
             self.logger.info("🔧 Setting up application hooks...")
-            
             # Register built-in command hooks
             self.logger.info("🔧 Setting up built-in command hooks...")
-            
             # Note: In a real implementation, these hooks would be registered
             # with the framework's hook system
             self.logger.info("✅ Hooks setup completed")
-            
         except ImportError as e:
             self.logger.warning(f"⚠️ Could not import hooks: {e}")
-    
     def setup_custom_commands(self):
         """Setup custom commands."""
         try:
             self.logger.info("🔧 Setting up custom commands...")
-            
             # Import custom commands
             from commands.custom_echo_command import CustomEchoCommand
             from commands.dynamic_calculator_command import DynamicCalculatorCommand
-            
             # Register custom commands
             # Note: In a real implementation, these would be registered
             # with the framework's command registry
             self.logger.info("✅ Custom commands setup completed")
-            
         except ImportError as e:
             self.logger.warning(f"⚠️ Could not import custom commands: {e}")
-    
+    def setup_proxy_endpoints(self):
+        """Setup proxy registration endpoints."""
+        try:
+            self.logger.info("🔧 Setting up proxy endpoints...")
+            # Import proxy endpoints
+            from proxy_endpoints import router as proxy_router
+            # Add proxy router to the application
+            self.app.include_router(proxy_router)
+            self.logger.info("✅ Proxy endpoints setup completed")
+        except ImportError as e:
+            self.logger.warning(f"⚠️ Could not import proxy endpoints: {e}")
     def create_application(self):
         """Create the FastAPI application."""
         self.logger.info("🔧 Creating application...")
-        
         # Setup hooks and commands before creating app
         self.setup_hooks()
         self.setup_custom_commands()
-        
         # Create application with configuration
         self.app = create_app(app_config=self.config)
-        
+        # Setup proxy endpoints after app creation
+        self.setup_proxy_endpoints()
         self.logger.info("✅ Application created successfully")
-    
     def run(self, host: str = None, port: int = None, debug: bool = False):
-        """Run the application."""
+        """Run the application using the factory method."""
         # Override configuration if specified
+        config_overrides = {}
         if host:
-            self.config.set("server.host", host)
+            config_overrides["host"] = host
         if port:
-            self.config.set("server.port", port)
+            config_overrides["port"] = port
         if debug:
-            self.config.set("server.debug", True)
-        
-        # Create application
+            config_overrides["debug"] = True
+        print(f"🚀 Starting Full Application Example")
+        print(f"📋 Configuration: {self.config_path}")
+        print(f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks, Proxy endpoints")
+        print("=" * 60)
+        # Create application with configuration
         self.create_application()
-        
         # Get server configuration
         server_host = self.config.get("server.host", "0.0.0.0")
         server_port = self.config.get("server.port", 8000)
         server_debug = self.config.get("server.debug", False)
-        
-        print(f"🚀 Starting Full Application Example")
-        print(f"📋 Configuration: {self.config_path}")
+        # Get SSL configuration
+        ssl_enabled = self.config.get("ssl.enabled", False)
+        ssl_cert_file = self.config.get("ssl.cert_file")
+        ssl_key_file = self.config.get("ssl.key_file")
+        ssl_ca_cert = self.config.get("ssl.ca_cert")
+        verify_client = self.config.get("ssl.verify_client", False)
         print(f"🌐 Server: {server_host}:{server_port}")
         print(f"🔧 Debug: {server_debug}")
-        print(f"🔧 Features: Built-in commands, Custom commands, Dynamic commands, Hooks")
+        if ssl_enabled:
+            print(f"🔐 SSL: Enabled")
+            print(f"   Certificate: {ssl_cert_file}")
+            print(f"   Key: {ssl_key_file}")
+            if ssl_ca_cert:
+                print(f"   CA: {ssl_ca_cert}")
+            print(f"   Client verification: {verify_client}")
         print("=" * 60)
-        
-        # Import uvicorn here to avoid dependency issues
-        import uvicorn
-        uvicorn.run(self.app, host=server_host, port=server_port, log_level="info")
-
-
+        # Use hypercorn directly to run the application with proxy endpoints
+        try:
+            import hypercorn.asyncio
+            import hypercorn.config
+            import asyncio
+            # Configure hypercorn
+            config_hypercorn = hypercorn.config.Config()
+            config_hypercorn.bind = [f"{server_host}:{server_port}"]
+            config_hypercorn.loglevel = "debug" if server_debug else "info"
+            if ssl_enabled and ssl_cert_file and ssl_key_file:
+                config_hypercorn.certfile = ssl_cert_file
+                config_hypercorn.keyfile = ssl_key_file
+                if ssl_ca_cert:
+                    config_hypercorn.ca_certs = ssl_ca_cert
+                if verify_client:
+                    import ssl
+                    config_hypercorn.verify_mode = ssl.CERT_REQUIRED
+                print(f"🔐 Starting HTTPS server with hypercorn...")
+            else:
+                print(f"🌐 Starting HTTP server with hypercorn...")
+            # Run the server
+            asyncio.run(hypercorn.asyncio.serve(self.app, config_hypercorn))
+        except ImportError:
+            print("❌ hypercorn not installed. Installing...")
+            import subprocess
+            subprocess.run([sys.executable, "-m", "pip", "install", "hypercorn"])
+            print("✅ hypercorn installed. Please restart the application.")
+            return
 def main():
     """Main entry point for the full application example."""
     parser = argparse.ArgumentParser(description="Full Application Example")
@@ -126,13 +151,9 @@ def main():
     parser.add_argument("--host", help="Server host")
     parser.add_argument("--port", type=int, help="Server port")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-    
     args = parser.parse_args()
-    
     # Create and run application
     app = FullApplication(args.config)
     app.run(host=args.host, port=args.port, debug=args.debug)
-
-
 if __name__ == "__main__":
     main()