mcp-proxy-adapter 6.7.2__py3-none-any.whl → 6.8.1__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -156,25 +156,36 @@ def create_lifespan(config_path: Optional[str] = None):
         if not server_port:
             raise ValueError("server.port is required")
 
+        # Check port availability BEFORE starting registration manager
+        from mcp_proxy_adapter.core.utils import check_port_availability, handle_port_conflict
+        
+        server_config = config.get("server", {})
+        server_host = server_config.get("host", "0.0.0.0")
+        server_port = server_config.get("port", 8000)
+        
+        print(f"🔍 Checking external server port availability: {server_host}:{server_port}")
+        if not check_port_availability(server_host, server_port):
+            print(f"❌ CRITICAL: External server port {server_port} is occupied")
+            handle_port_conflict(server_host, server_port)
+            return  # Exit the function immediately
+        print(f"✅ External server port {server_port} is available")
+
         # Determine registration URL using unified logic
         early_server_url = _determine_registration_url(config)
         try:
-            from mcp_proxy_adapter.core.async_proxy_registration import (
-                initialize_async_registration,
-                start_async_registration,
+            from mcp_proxy_adapter.core.proxy_registration import (
+                register_with_proxy,
+                unregister_from_proxy,
+                initialize_proxy_registration,
             )
 
-            # Initialize async registration manager
-            async_manager = initialize_async_registration(config)
+            # Initialize proxy registration
+            initialize_proxy_registration()
             logger.info(
-                "🔍 Initialized async registration manager with server_url: %s",
+                "🔍 Initialized proxy registration with server_url: %s",
                 early_server_url,
             )
             
-            # Start async registration in background thread
-            start_async_registration(early_server_url)
-            logger.info("🚀 Started async proxy registration and heartbeat thread")
-            
         except Exception as e:
             logger.error(f"Failed to initialize async registration: {e}")
 
@@ -201,25 +212,12 @@ def create_lifespan(config_path: Optional[str] = None):
             # Determine registration URL using unified logic
             server_url = _determine_registration_url(final_config)
             
-            # Update async registration manager with final server URL
+            # Update proxy registration with final server URL
             try:
-                from mcp_proxy_adapter.core.async_proxy_registration import (
-                    get_async_registration_manager,
-                )
-                
-                async_manager = get_async_registration_manager()
-                if async_manager:
-                    async_manager.set_server_url(server_url)
-                    logger.info(f"🔍 Updated async registration manager with final server_url: {server_url}")
-                    
-                    # Get current status
-                    status = async_manager.get_status()
-                    logger.info(f"📊 Registration status: {status}")
-                else:
-                    logger.warning("Async registration manager not available")
+                logger.info(f"🔍 Updated proxy registration with final server_url: {server_url}")
                     
             except Exception as e:
-                logger.error(f"Failed to update async registration manager: {e}")
+                logger.error(f"Failed to update proxy registration: {e}")
             
             try:
                 print("🔍 Registration server_url resolved to (print):", server_url)
@@ -255,30 +253,16 @@ def create_lifespan(config_path: Optional[str] = None):
         # Shutdown events
         logger.info("Application shutting down")
 
-        # Stop async registration manager (this will also unregister)
+        # Stop proxy registration (this will also unregister)
         try:
-            from mcp_proxy_adapter.core.async_proxy_registration import (
-                stop_async_registration,
-                get_registration_status,
-            )
-            
-            # Get final status before stopping
-            final_status = get_registration_status()
-            logger.info(f"📊 Final registration status: {final_status}")
-            
-            # Stop async registration (this will also unregister)
-            stop_async_registration()
-            logger.info("✅ Async registration manager stopped successfully")
-            
-        except Exception as e:
-            logger.error(f"❌ Failed to stop async registration: {e}")
-            
-            # Fallback to old unregistration method
             unregistration_success = await unregister_from_proxy()
             if unregistration_success:
-                logger.info("✅ Fallback proxy unregistration completed successfully")
+                logger.info("✅ Proxy unregistration completed successfully")
             else:
-                logger.warning("⚠️ Fallback proxy unregistration failed or was disabled")
+                logger.warning("⚠️ Proxy unregistration failed or was disabled")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to stop proxy registration: {e}")
 
     return lifespan
 

mcp_proxy_adapter/core/app_factory.py

@@ -19,6 +19,11 @@ from mcp_proxy_adapter.config import config
 from mcp_proxy_adapter.commands.builtin_commands import (
     register_builtin_commands,
 )
+from mcp_proxy_adapter.core.utils import (
+    check_port_availability,
+    handle_port_conflict,
+    find_port_for_internal_server,
+)
 
 logger = get_logger("app_factory")
 
@@ -265,6 +270,7 @@ async def create_and_run_server(
     )
     print(f"🔌 Port: {server_port}")
 
+
     server_config = {
         "host": host,
         "port": server_port,
@@ -277,30 +283,6 @@ async def create_and_run_server(
         f"🔍 Debug: app_config keys: {list(app_config.keys()) if app_config else 'None'}"
     )
 
-    # Check for SSL config in root section first (higher priority)
-    if app_config and "ssl" in app_config:
-        print(f"🔍 Debug: SSL config found in root: {app_config['ssl']}")
-        print(
-            f"🔍 Debug: SSL enabled: {app_config['ssl'].get('enabled', False)}"
-        )
-        if app_config["ssl"].get("enabled", False):
-            ssl_config = app_config["ssl"]
-            # Add SSL config directly to server_config for Hypercorn
-            server_config["certfile"] = ssl_config.get("cert_file")
-            server_config["keyfile"] = ssl_config.get("key_file")
-            server_config["ca_certs"] = ssl_config.get(
-                "ca_cert_file", ssl_config.get("ca_cert")
-            )
-            # Set verify_client based on verify_client setting
-            verify_client = ssl_config.get("verify_client", False)
-            server_config["verify_client"] = verify_client
-            print(f"🔒 SSL enabled: {ssl_config.get('cert_file', 'N/A')}")
-            print(
-                f"🔒 SSL enabled: cert={ssl_config.get('cert_file')}, key={ssl_config.get('key_file')}"
-            )
-            print(
-                f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}"
-            )
 
     # Check for SSL config in security section (fallback)
     if app_config and "security" in app_config:
@@ -331,28 +313,6 @@ async def create_and_run_server(
                 print(
                     f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}"
                 )
-        print(f"🔍 Debug: SSL config found in root: {app_config['ssl']}")
-        print(
-            f"🔍 Debug: SSL enabled: {app_config['ssl'].get('enabled', False)}"
-        )
-        if app_config["ssl"].get("enabled", False):
-            ssl_config = app_config["ssl"]
-            # Add SSL config directly to server_config for Hypercorn
-            server_config["certfile"] = ssl_config.get("cert_file")
-            server_config["keyfile"] = ssl_config.get("key_file")
-            server_config["ca_certs"] = ssl_config.get(
-                "ca_cert_file", ssl_config.get("ca_cert")
-            )
-            # Set verify_client based on verify_client setting
-            verify_client = ssl_config.get("verify_client", False)
-            server_config["verify_client"] = verify_client
-            print(f"🔒 SSL enabled: {ssl_config.get('cert_file', 'N/A')}")
-            print(
-                f"🔒 SSL enabled: cert={ssl_config.get('cert_file')}, key={ssl_config.get('key_file')}"
-            )
-            print(
-                f"🔒 Server config SSL: certfile={server_config.get('certfile')}, keyfile={server_config.get('keyfile')}, ca_certs={server_config.get('ca_certs')}, verify_mode={server_config.get('verify_mode')}"
-            )
 
     # 6. Start mTLS server if needed
     mtls_server = None
@@ -362,18 +322,21 @@ async def create_and_run_server(
         verify_client = ssl_config.get("verify_client", False)
 
         if verify_client:
-            print("🔐 mTLS enabled - starting separate mTLS server...")
+            print("🔐 mTLS enabled - starting internal mTLS server...")
+            print("   External port: mTLS proxy (hypercorn)")
+            print("   Internal port: mTLS server (http.server)")
             from mcp_proxy_adapter.core.mtls_server import (
                 start_mtls_server_thread,
             )
 
-            # Start mTLS server in separate thread
+            # Start internal mTLS server in separate thread
+            # This server will find available port automatically if needed
             mtls_server = start_mtls_server_thread(app_config, main_app=app)
             if mtls_server:
-                print(f"✅ mTLS server started on port {mtls_server.port}")
+                print(f"✅ Internal mTLS server started on port {mtls_server.port}")
             else:
                 print(
-                    "⚠️  Failed to start mTLS server, continuing with regular HTTPS"
+                    "⚠️  Failed to start internal mTLS server, continuing with regular HTTPS"
                 )
         else:
             print("🔓 mTLS disabled - using regular HTTPS")
@@ -387,6 +350,8 @@ async def create_and_run_server(
         print("   Use Ctrl+C to stop the server")
         print("=" * 60)
 
+        # Port availability is already checked in api/app.py before registration manager starts
+
         # Use hypercorn directly
         import hypercorn.asyncio
         import hypercorn.config
@@ -428,13 +393,21 @@ async def create_and_run_server(
         if ssl_enabled:
             if verify_client:
                 print(
-                    f"🔐 Starting HTTPS server with hypercorn (mTLS on separate port)..."
+                    f"🔐 Starting external mTLS proxy with hypercorn (internal server on port {mtls_server.port if mtls_server else 'N/A'})..."
                 )
             else:
                 print(f"🔐 Starting HTTPS server with hypercorn...")
         else:
             print(f"🌐 Starting HTTP server with hypercorn...")
 
+        # Final port check before starting hypercorn
+        print(f"🔍 Final port check before starting hypercorn: {host}:{server_port}")
+        if not check_port_availability(host, server_port):
+            print(f"❌ CRITICAL: Port {server_port} is occupied during final check")
+            handle_port_conflict(host, server_port)
+            return  # Exit immediately
+        print(f"✅ Final port check passed: {host}:{server_port}")
+
         # Run the server
         # hypercorn.asyncio.serve() should be run with asyncio.run(), not awaited
         # The function is designed to be the main entry point, not a coroutine to await
@@ -442,15 +415,28 @@ async def create_and_run_server(
 
     except KeyboardInterrupt:
         print("\n🛑 Server stopped by user")
-        # Stop mTLS server if running
+        # Stop internal mTLS server if running
         if mtls_server:
-            print("🛑 Stopping mTLS server...")
+            print("🛑 Stopping internal mTLS server...")
             mtls_server.stop()
+    except OSError as e:
+        if e.errno == 98:  # Address already in use
+            print(f"\n❌ Port conflict detected: {e}")
+            handle_port_conflict(host, server_port)
+        else:
+            print(f"\n❌ Failed to start server: {e}")
+            # Stop mTLS server if running
+            if mtls_server:
+                print("🛑 Stopping mTLS server...")
+                mtls_server.stop()
+            import traceback
+            traceback.print_exc()
+            sys.exit(1)
     except Exception as e:
         print(f"\n❌ Failed to start server: {e}")
-        # Stop mTLS server if running
+        # Stop internal mTLS server if running
         if mtls_server:
-            print("🛑 Stopping mTLS server...")
+            print("🛑 Stopping internal mTLS server...")
             mtls_server.stop()
         import traceback
 

mcp_proxy_adapter/core/mtls_server.py

@@ -286,7 +286,11 @@ def start_mtls_server_thread(
         # Get server configuration
         server_config = config.get("server", {})
         host = server_config.get("host", "127.0.0.1")
-        port = ssl_config.get("mtls_port", 8443)  # Different port for mTLS
+        preferred_port = ssl_config.get("mtls_port", 8443)  # Different port for mTLS
+        
+        # For internal servers (mTLS), find available port if preferred is occupied
+        from mcp_proxy_adapter.core.utils import find_port_for_internal_server
+        port = find_port_for_internal_server(host, preferred_port)
 
         # Get certificate paths
         cert_file = ssl_config.get("cert_file", "certs/localhost_server.crt")

mcp_proxy_adapter/core/signal_handler.py

@@ -79,10 +79,12 @@ class SignalHandler:
             except Exception as e:
                 logger.error(f"❌ Shutdown callback failed: {e}")
         
-        # If this is SIGINT (Ctrl+C), we might want to exit immediately after a delay
-        if signum == signal.SIGINT:
-            logger.info("⏰ SIGINT received, will exit in 5 seconds if not stopped gracefully...")
-            threading.Timer(5.0, self._force_exit).start()
+        # Force exit immediately to avoid server hang
+        logger.info("🔄 Force exiting to avoid server hang...")
+        import os
+        # Use os._exit for immediate termination
+        logger.warning("⚠️ Using os._exit for immediate termination...")
+        os._exit(0)
     
     def _force_exit(self):
         """Force exit if graceful shutdown takes too long."""

mcp_proxy_adapter/core/utils.py

@@ -5,6 +5,7 @@ Module with utility functions for the microservice.
 import hashlib
 import json
 import os
+import socket
 import sys
 import time
 import uuid
@@ -138,3 +139,144 @@ def ensure_directory(path: str) -> bool:
     except Exception as e:
         logger.error(f"Error creating directory {path}: {e}")
         return False
+
+
+def check_port_availability(host: str, port: int, timeout: float = 1.0) -> bool:
+    """
+    Checks if a port is available for binding.
+    
+    Args:
+        host: Host address to check
+        port: Port number to check
+        timeout: Connection timeout in seconds
+        
+    Returns:
+        True if port is available, False if port is in use
+    """
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(timeout)
+            result = sock.connect_ex((host, port))
+            return result != 0  # True if connection failed (port is free)
+    except Exception as e:
+        logger.warning(f"Error checking port {port} on {host}: {e}")
+        return True  # Assume port is available if check fails
+
+
+def find_available_port(host: str, start_port: int, max_attempts: int = 100) -> Optional[int]:
+    """
+    Finds an available port starting from the specified port.
+    
+    Args:
+        host: Host address to check
+        start_port: Starting port number
+        max_attempts: Maximum number of ports to check
+        
+    Returns:
+        Available port number or None if no port found
+    """
+    for port in range(start_port, start_port + max_attempts):
+        if check_port_availability(host, port):
+            return port
+    return None
+
+
+def get_port_usage_info(port: int) -> str:
+    """
+    Gets information about what process is using a port.
+    
+    Args:
+        port: Port number to check
+        
+    Returns:
+        String with port usage information
+    """
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["lsof", "-i", f":{port}"], 
+            capture_output=True, 
+            text=True, 
+            timeout=5
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return f"Port {port} is used by:\n{result.stdout.strip()}"
+        else:
+            return f"Port {port} appears to be in use but process info unavailable"
+    except Exception as e:
+        return f"Port {port} is in use (unable to get process info: {e})"
+
+
+def handle_port_conflict(host: str, port: int) -> None:
+    """
+    Handles port conflict with user-friendly error message and suggestions.
+    This is for MAIN server port conflicts - application must exit.
+    
+    Args:
+        host: Host address
+        port: Port number that's in conflict
+    """
+    print(f"❌ ERROR: Port {port} is already in use on {host}")
+    print(f"💡 Suggestions:")
+    print(f"   1. Choose a different port: --port <different_port>")
+    print(f"   2. Stop the conflicting service")
+    print(f"   3. Check what's using the port:")
+    print(f"      lsof -i :{port}")
+    print(f"      netstat -tulpn | grep :{port}")
+    
+    # Try to get more detailed info about port usage
+    usage_info = get_port_usage_info(port)
+    print(f"🔍 Port usage details:")
+    print(f"   {usage_info}")
+    
+    # Try to find an alternative port
+    alt_port = find_available_port(host, port + 1, 10)
+    if alt_port:
+        print(f"💡 Alternative port suggestion: {alt_port}")
+        print(f"   Try: --port {alt_port}")
+    else:
+        print(f"💡 Try ports in range {port + 1}-{port + 20}")
+    
+    print(f"🛑 Application cannot start due to port conflict")
+    sys.exit(1)
+
+
+def find_port_for_internal_server(host: str, preferred_port: int) -> int:
+    """
+    Finds an available port for internal server (mTLS, etc.).
+    If preferred port is occupied, finds any available port.
+    
+    Args:
+        host: Host address
+        preferred_port: Preferred port number
+        
+    Returns:
+        Available port number
+    """
+    # First try the preferred port
+    if check_port_availability(host, preferred_port):
+        print(f"✅ Internal server port {preferred_port} is available")
+        return preferred_port
+    
+    # If preferred port is occupied, find any available port
+    print(f"⚠️  Internal server preferred port {preferred_port} is occupied, searching for alternative...")
+    
+    alt_port = find_available_port(host, preferred_port + 1, 50)
+    if alt_port:
+        print(f"✅ Found alternative port for internal server: {alt_port}")
+        return alt_port
+    
+    # If no port found in range, try from 9000
+    alt_port = find_available_port(host, 9000, 100)
+    if alt_port:
+        print(f"✅ Found alternative port for internal server: {alt_port}")
+        return alt_port
+    
+    # Last resort - try from 10000
+    alt_port = find_available_port(host, 10000, 100)
+    if alt_port:
+        print(f"✅ Found alternative port for internal server: {alt_port}")
+        return alt_port
+    
+    # If still no port found, raise error
+    raise RuntimeError(f"Unable to find available port for internal server on {host}")

mcp_proxy_adapter/examples/basic_framework/main.py

@@ -25,27 +25,26 @@ def main():
     parser.add_argument("--port", type=int, help="Server port")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
     args = parser.parse_args()
-    # Override configuration if specified
-    config_overrides = {}
+    print(f"🚀 Starting Basic Framework Example")
+    print(f"📋 Configuration: {args.config}")
     if args.host:
-        config_overrides["host"] = args.host
+        print(f"🌐 Host override: {args.host}")
     if args.port:
-        config_overrides["port"] = args.port
+        print(f"🔌 Port override: {args.port}")
     if args.debug:
-        config_overrides["debug"] = True
-    print(f"🚀 Starting Basic Framework Example")
-    print(f"📋 Configuration: {args.config}")
+        print(f"🔧 Debug mode: enabled")
     print("=" * 50)
-    # Use the factory method to create and run the server
+    
+    # Note: Host and port overrides should be handled in configuration file
+    # or by modifying the configuration before passing to create_and_run_server
     import asyncio
     asyncio.run(create_and_run_server(
         config_path=args.config,
         title="Basic Framework Example",
         description="Basic MCP Proxy Adapter with minimal configuration",
         version="1.0.0",
-        host=config_overrides.get("host"),
-        port=config_overrides.get("port"),
-        debug=config_overrides.get("debug", False),
+        host=args.host or "0.0.0.0",
+        log_level="debug" if args.debug else "info"
     ))
 
 

mcp_proxy_adapter/examples/full_application/main.py

@@ -93,74 +93,24 @@ class FullApplication:
         self.logger.info("✅ Application created successfully")
 
     def run(self, host: str = None, port: int = None, debug: bool = False):
-        """Run the application using the factory method."""
-        # Override configuration if specified
-        config_overrides = {}
-        if host:
-            config_overrides["host"] = host
-        if port:
-            config_overrides["port"] = port
-        if debug:
-            config_overrides["debug"] = True
+        """Run the application using the factory method with port checking."""
         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)
-        # 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}")
-        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)
-        # 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
+        
+        # Use the factory method to create and run the server with port checking
+        import asyncio
+        asyncio.run(create_and_run_server(
+            config_path=self.config_path,
+            title="Full Application Example",
+            description="Complete MCP Proxy Adapter with all features",
+            version="1.0.0",
+            host=host or "0.0.0.0",
+            log_level="debug" if debug else "info"
+        ))
 
 
 def main():

mcp_proxy_adapter/main.py

@@ -22,6 +22,11 @@ from mcp_proxy_adapter.api.app import create_app
 from mcp_proxy_adapter.config import Config
 from mcp_proxy_adapter.core.config_validator import ConfigValidator
 from mcp_proxy_adapter.core.signal_handler import setup_signal_handling, is_shutdown_requested
+from mcp_proxy_adapter.core.utils import (
+    check_port_availability,
+    handle_port_conflict,
+    find_port_for_internal_server,
+)
 
 
 def main():
@@ -84,6 +89,13 @@ def main():
     host = config.get("server.host", "0.0.0.0")
     port = config.get("server.port", 8000)
 
+    # Check external port availability - this is critical, must exit if occupied
+    print(f"🔍 Checking external server port availability: {host}:{port}")
+    if not check_port_availability(host, port):
+        print(f"❌ CRITICAL: External server port {port} is occupied")
+        handle_port_conflict(host, port)
+    print(f"✅ External server port {port} is available")
+
     # Get protocol and SSL configuration
     protocol = config.get("server.protocol", "http")
     verify_client = config.get("transport.verify_client", False)
@@ -98,6 +110,16 @@ def main():
         hypercorn_port = port + 1000   # internal port
         mtls_proxy_port = port         # external port
         ssl_enabled = True
+        
+        # Check internal port availability (flexible - find alternative if occupied)
+        print(f"🔍 Checking internal server port availability: {hypercorn_host}:{hypercorn_port}")
+        if not check_port_availability(hypercorn_host, hypercorn_port):
+            print(f"⚠️  Internal server preferred port {hypercorn_port} is occupied, searching for alternative...")
+            hypercorn_port = find_port_for_internal_server(hypercorn_host, hypercorn_port)
+            print(f"✅ Internal server will use port: {hypercorn_port}")
+        else:
+            print(f"✅ Internal server port {hypercorn_port} is available")
+        
         print(f"🔐 mTLS Mode: hypercorn on {hypercorn_host}:{hypercorn_port}, mTLS proxy on {host}:{mtls_proxy_port}")
     else:
         # Regular mode: hypercorn on external port (no proxy needed)

mcp_proxy_adapter/version.py

@@ -2,4 +2,4 @@
 Version information for MCP Proxy Adapter.
 """
 
-__version__ = "6.7.2"
+__version__ = "6.8.1"

{mcp_proxy_adapter-6.7.2.dist-info → mcp_proxy_adapter-6.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.7.2
+Version: 6.8.1
 Summary: Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration
 Home-page: https://github.com/maverikod/mcp-proxy-adapter
 Author: Vasiliy Zdanovskiy