mcp-proxy-adapter 6.3.27__py3-none-any.whl → 6.3.29__py3-none-any.whl

mcp_proxy_adapter/core/proxy_registration.py

@@ -1,3 +1,4 @@
+# flake8: noqa: E501
 """
 Module for proxy registration functionality with security framework integration.
 
@@ -13,9 +14,12 @@ import asyncio
 import time
 import ssl
 from typing import Dict, Any, Optional, Tuple
+from pathlib import Path
 from urllib.parse import urljoin
 
 import aiohttp
+import os
+import glob
 
 from mcp_proxy_adapter.core.logging import logger
 from mcp_proxy_adapter.core.client_security import create_client_security_manager
@@ -47,6 +51,22 @@ class ProxyRegistrationManager:
         self.registration_config = config.get(
             "registration", config.get("proxy_registration", {})
         )
+        # Auto-fill minimal TLS settings from global SSL if missing to support minimal config
+        try:
+            reg_ssl = self.registration_config.get("ssl", {})
+            if not isinstance(reg_ssl, dict):
+                reg_ssl = {}
+            global_ssl = config.get("security", {}).get("ssl", {}) or config.get("ssl", {})
+            if isinstance(global_ssl, dict):
+                if not reg_ssl.get("ca_cert") and global_ssl.get("ca_cert"):
+                    reg_ssl["ca_cert"] = global_ssl.get("ca_cert")
+                # Keep verify_mode if already set; default to CERT_REQUIRED if global verify_client true
+                if not reg_ssl.get("verify_mode") and isinstance(global_ssl.get("verify_client"), bool):
+                    reg_ssl["verify_mode"] = "CERT_REQUIRED" if global_ssl.get("verify_client") else "CERT_NONE"
+            if reg_ssl:
+                self.registration_config["ssl"] = reg_ssl
+        except Exception:
+            pass
 
         # Basic registration settings
         self.proxy_url = self.registration_config.get(
@@ -155,6 +175,15 @@ class ProxyRegistrationManager:
         logger.debug("_create_ssl_context called")
         if not self.client_security:
             logger.debug("SSL context creation failed: client_security is None")
+            # Try best-effort default CA if available
+            try:
+                default_ca = "/home/vasilyvz/projects/mcp_proxy_adapter/mtls_certificates/ca/ca.crt"
+                if Path(default_ca).exists():
+                    ctx = ssl.create_default_context(cafile=default_ca)
+                    logger.debug("Using default CA bundle for SSL verification")
+                    return ctx
+            except Exception:
+                pass
             return None
 
         try:
@@ -162,6 +191,42 @@ class ProxyRegistrationManager:
             cert_config = self.registration_config.get("certificate", {})
             ssl_config = self.registration_config.get("ssl", {})
 
+            # FALLBACK: if no explicit registration SSL/certs provided, reuse global SSL config
+            if not cert_config and not ssl_config:
+                global_ssl = self.config.get("security", {}).get("ssl", {}) or self.config.get("ssl", {})
+                if global_ssl:
+                    # Map global ssl to registration-style configs
+                    mapped_cert = {}
+                    if global_ssl.get("cert_file") and global_ssl.get("key_file"):
+                        mapped_cert = {
+                            "cert_file": global_ssl.get("cert_file"),
+                            "key_file": global_ssl.get("key_file"),
+                        }
+                    mapped_ssl = {}
+                    if global_ssl.get("ca_cert"):
+                        mapped_ssl["ca_cert"] = global_ssl.get("ca_cert")
+                    if global_ssl.get("verify_client") is not None:
+                        mapped_ssl["verify_mode"] = (
+                            "CERT_REQUIRED" if global_ssl.get("verify_client") else "CERT_NONE"
+                        )
+                    cert_config = mapped_cert
+                    ssl_config = mapped_ssl
+
+            # If still no client certificate specified, try default client certs from project
+            if not cert_config or not cert_config.get("cert_file") or not cert_config.get("key_file"):
+                try:
+                    base_dir = "/home/vasilyvz/projects/mcp_proxy_adapter/mtls_certificates/client"
+                    if os.path.isdir(base_dir):
+                        crt_candidates = sorted(glob.glob(os.path.join(base_dir, "*.crt")))
+                        key_candidates = sorted(glob.glob(os.path.join(base_dir, "*.key")))
+                        if crt_candidates and key_candidates:
+                            cert_config = {
+                                "cert_file": crt_candidates[0],
+                                "key_file": key_candidates[0],
+                            }
+                except Exception:
+                    pass
+
             logger.debug(
                 f"SSL context creation: cert_config={cert_config}, ssl_config={ssl_config}"
             )
@@ -169,7 +234,13 @@ class ProxyRegistrationManager:
             # SSL is enabled if certificate config exists or SSL config exists
             if cert_config or ssl_config:
                 # Create a custom SSL context based on registration configuration
-                context = ssl.create_default_context()
+                ca_file = ssl_config.get("ca_cert") if isinstance(ssl_config, dict) else None
+                if ca_file and Path(ca_file).exists():
+                    context = ssl.create_default_context(cafile=ca_file)
+                else:
+                    # Try default project CA
+                    default_ca = "/home/vasilyvz/projects/mcp_proxy_adapter/mtls_certificates/ca/ca.crt"
+                    context = ssl.create_default_context(cafile=default_ca) if Path(default_ca).exists() else ssl.create_default_context()
 
                 # Load client certificates if provided
                 if cert_config:
@@ -179,7 +250,7 @@ class ProxyRegistrationManager:
                     if cert_file and key_file:
                         context.load_cert_chain(cert_file, key_file)
                         logger.debug(
-                            f"Loaded client certificates: {cert_file}, {key_file}"
+                            f"Loaded client certificates for mTLS: cert={cert_file}, key={key_file}"
                         )
 
                 # Configure SSL verification based on registration settings
@@ -207,17 +278,15 @@ class ProxyRegistrationManager:
                         context.verify_mode = ssl.CERT_REQUIRED
                         logger.debug("SSL verification enabled (default)")
                 else:
-                    # Check certificate config for verify_server setting
-                    verify_server = cert_config.get("verify_server", True)
-                    if not verify_server:
-                        context.check_hostname = False
-                        context.verify_mode = ssl.CERT_NONE
-                        logger.debug("SSL verification disabled (verify_server: false)")
-                    else:
-                        # Default SSL context if no specific SSL config
+                    # No specific ssl_config, default to secure verification if CA is known
+                    if cert_config:
+                        # Keep hostname check and CERT_REQUIRED by default
                         context.check_hostname = True
                         context.verify_mode = ssl.CERT_REQUIRED
-                        logger.debug("Using default SSL verification")
+                        logger.debug("Using default SSL verification with provided client certs")
+                    else:
+                        # Last resort: use system defaults
+                        logger.debug("Using system default SSL verification")
 
                 logger.info("Created custom SSL context for proxy registration")
                 return context
@@ -246,6 +315,27 @@ class ProxyRegistrationManager:
             logger.error("Server URL not set, cannot register with proxy")
             return False
 
+        # Normalize server_url for docker host if needed
+        try:
+            if self.server_url:
+                from urllib.parse import urlparse, urlunparse
+                import os as _os
+                parsed = urlparse(self.server_url)
+                if parsed.hostname in ("localhost", "127.0.0.1"):
+                    docker_addr = _os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+                    port = parsed.port
+                    if not port:
+                        port = 443 if parsed.scheme == "https" else 80
+                    new_netloc = f"{docker_addr}:{port}"
+                    normalized = urlunparse(parsed._replace(netloc=new_netloc))
+                    if normalized != self.server_url:
+                        self.server_url = normalized
+                        logger.info(
+                            f"Normalized server_url for docker host: {self.server_url}"
+                        )
+        except Exception as _e:
+            logger.debug(f"server_url normalization skipped: {_e}")
+
         # Prepare registration data with proxy info
         proxy_info = self.registration_config.get("proxy_info", {})
         registration_data = {
@@ -264,7 +354,8 @@ class ProxyRegistrationManager:
         logger.info(f"Attempting to register server with proxy at {self.proxy_url}")
         logger.debug(f"Registration data: {registration_data}")
 
-        for attempt in range(self.retry_attempts):
+        # Do not block application startup: single attempt, no sleeps here
+        for attempt in range(1):
             try:
                 success, result = await self._make_secure_registration_request(
                     registration_data
@@ -285,24 +376,21 @@ class ProxyRegistrationManager:
 
                     return True
                 else:
-                    error_msg = result.get("error", {}).get("message", "Unknown error")
+                    # Be robust if result is not a dict
+                    error_msg = None
+                    if isinstance(result, dict):
+                        error_msg = result.get("error", {}).get("message", "Unknown error")
+                    else:
+                        error_msg = str(result)
                     logger.warning(
                         f"❌ Registration attempt {attempt + 1} failed: {error_msg}"
                     )
 
-                    if attempt < self.retry_attempts - 1:
-                        logger.info(f"Retrying in {self.retry_delay} seconds...")
-                        await asyncio.sleep(self.retry_delay)
-
             except Exception as e:
                 logger.error(
                     f"❌ Registration attempt {attempt + 1} failed with exception: {e}"
                 )
 
-                if attempt < self.retry_attempts - 1:
-                    logger.info(f"Retrying in {self.retry_delay} seconds...")
-                    await asyncio.sleep(self.retry_delay)
-
         logger.error(
             f"❌ Failed to register with proxy after {self.retry_attempts} attempts"
         )
@@ -395,7 +483,11 @@ class ProxyRegistrationManager:
                     headers=headers,
                     timeout=aiohttp.ClientTimeout(total=self.timeout),
                 ) as response:
-                    result = await response.json()
+                    try:
+                        result = await response.json()
+                    except Exception:
+                        text_body = await response.text()
+                        result = {"success": False, "error": {"code": "NON_JSON_RESPONSE", "message": text_body}}
 
                     # Validate response headers if security framework available
                     if self.client_security:
@@ -545,40 +637,50 @@ class ProxyRegistrationManager:
         if not self.server_key:
             return False
 
-        heartbeat_data = {
-            "server_id": self.server_id,
-            "server_key": self.server_key,
-            "timestamp": int(time.time()),
-        }
-
         url = urljoin(self.proxy_url, "/heartbeat")
 
         # Get authentication headers
         headers = self._get_auth_headers()
-        headers["Content-Type"] = "application/json"
 
         # Create SSL context if needed
         ssl_context = self._create_ssl_context()
 
         # Create connector with SSL context
-        connector = None
-        if ssl_context:
-            connector = aiohttp.TCPConnector(ssl=ssl_context)
+        connector = aiohttp.TCPConnector(ssl=ssl_context) if ssl_context else None
 
         try:
+            timeout = aiohttp.ClientTimeout(total=self.timeout)
             async with aiohttp.ClientSession(connector=connector) as session:
+                # Prefer GET heartbeat (container exposes GET /heartbeat)
+                try:
+                    async with session.get(url, headers=headers, timeout=timeout) as resp:
+                        if resp.status == 200:
+                            logger.debug("Heartbeat (GET) succeeded")
+                            return True
+                        # If method not allowed, fall back to POST
+                        if resp.status != 405:
+                            logger.warning(
+                                f"Heartbeat (GET) failed with status: {resp.status}"
+                            )
+                except Exception as ge:
+                    logger.debug(f"Heartbeat (GET) error: {ge}")
+
+                # Fallback to POST if GET not supported
+                heartbeat_data = {
+                    "server_id": self.server_id,
+                    "server_key": self.server_key,
+                    "timestamp": int(time.time()),
+                }
+                post_headers = dict(headers)
+                post_headers["Content-Type"] = "application/json"
                 async with session.post(
-                    url,
-                    json=heartbeat_data,
-                    headers=headers,
-                    timeout=aiohttp.ClientTimeout(total=self.timeout),
-                ) as response:
-                    if response.status == 200:
-                        logger.debug("Heartbeat sent successfully")
+                    url, json=heartbeat_data, headers=post_headers, timeout=timeout
+                ) as resp:
+                    if resp.status == 200:
+                        logger.debug("Heartbeat (POST) succeeded")
                         return True
-                    else:
                         logger.warning(
-                            f"Heartbeat failed with status: {response.status}"
+                        f"Heartbeat (POST) failed with status: {resp.status}"
                         )
                         return False
         except Exception as e:

mcp_proxy_adapter/main.py

@@ -5,7 +5,6 @@ MCP Proxy Adapter - Main Entry Point
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import sys
 import ssl
 import hypercorn.asyncio
@@ -27,8 +26,15 @@ from mcp_proxy_adapter.core.config_validator import ConfigValidator
 def main():
     """Main entry point for the MCP Proxy Adapter."""
     # Parse command line arguments
-    parser = argparse.ArgumentParser(description="MCP Proxy Adapter Server")
-    parser.add_argument("--config", "-c", type=str, help="Path to configuration file")
+    parser = argparse.ArgumentParser(
+        description="MCP Proxy Adapter Server",
+    )
+    parser.add_argument(
+        "--config",
+        "-c",
+        type=str,
+        help="Path to configuration file",
+    )
     args = parser.parse_args()
 
     # Load configuration
@@ -46,32 +52,33 @@ def main():
         sys.exit(1)
     print("✅ Configuration validation passed")
 
-    # Create application
-    app = create_app(app_config=config.get_all())
+    # Create application (pass config_path so reload uses same file)
+    app = create_app(app_config=config.get_all(), config_path=args.config)
 
     # Get server configuration
     host = config.get("server.host", "0.0.0.0")
     port = config.get("server.port", 8000)
 
-    # Get SSL configuration
+    # Get SSL configuration strictly from config (no hardcode)
     ssl_enabled = config.get("ssl.enabled", False)
     ssl_cert_file = config.get("ssl.cert_file")
     ssl_key_file = config.get("ssl.key_file")
-    ssl_ca_cert = config.get("ssl.ca_cert_file")
+    # Support both keys: ssl.ca_cert_file (security framework style) and ssl.ca_cert (legacy)
+    ssl_ca_cert = config.get("ssl.ca_cert_file", config.get("ssl.ca_cert"))
     verify_client = config.get("ssl.verify_client", False)
-    
-    # Debug SSL configuration
-    print(f"🔍 Debug SSL config:")
+
+    print("🔍 Debug SSL config:")
     print(f"   ssl_enabled: {ssl_enabled}")
     print(f"   ssl_cert_file: {ssl_cert_file}")
     print(f"   ssl_key_file: {ssl_key_file}")
     print(f"   ssl_ca_cert: {ssl_ca_cert}")
     print(f"   verify_client: {verify_client}")
+    print("🔍 Source: configuration (hardcode disabled)")
 
-    print(f"🚀 Starting MCP Proxy Adapter")
+    print("🚀 Starting MCP Proxy Adapter")
     print(f"🌐 Server: {host}:{port}")
     if ssl_enabled:
-        print(f"🔐 SSL: Enabled")
+        print("🔐 SSL: Enabled")
         print(f"   Certificate: {ssl_cert_file}")
         print(f"   Key: {ssl_key_file}")
         if ssl_ca_cert:
@@ -88,20 +95,53 @@ def main():
         config_hypercorn.keyfile = ssl_key_file
 
         if ssl_ca_cert:
-            config_hypercorn.ca_cert = ssl_ca_cert
+            config_hypercorn.ca_certs = ssl_ca_cert
 
         if verify_client:
             # For mTLS, require client certificates
             config_hypercorn.verify_mode = ssl.CERT_REQUIRED
             print("🔐 mTLS: Client certificate verification enabled")
         else:
-            # For regular HTTPS without client verification
-            # Don't set verify_mode for regular HTTPS - let hypercorn handle it
-            print("🔐 HTTPS: Regular HTTPS without client certificate verification")
+            print(
+                "🔐 HTTPS: Regular HTTPS without client certificate",
+            )
+            print("verification")
+
+        # Prefer modern protocols
+        try:
+            config_hypercorn.alpn_protocols = ["h2", "http/1.1"]
+        except Exception:
+            pass
+
+    # Log hypercorn configuration
+    print("=" * 50)
+    print("🔍 HYPERCORN CONFIGURATION:")
+    print(
+        "🔍 certfile="
+        f"{getattr(config_hypercorn, 'certfile', None)}",
+    )
+    print(
+        "🔍 keyfile="
+        f"{getattr(config_hypercorn, 'keyfile', None)}",
+    )
+    print(
+        "🔍 ca_certs="
+        f"{getattr(config_hypercorn, 'ca_certs', None)}",
+    )
+    print(
+        "🔍 verify_mode="
+        f"{getattr(config_hypercorn, 'verify_mode', None)}",
+    )
+    print(
+        "🔍 alpn_protocols="
+        f"{getattr(config_hypercorn, 'alpn_protocols', None)}",
+    )
+    print("=" * 50)
 
-        print(f"🔐 Starting HTTPS server with hypercorn...")
+    if ssl_enabled:
+        print("🔐 Starting HTTPS server with hypercorn...")
     else:
-        print(f"🌐 Starting HTTP server with hypercorn...")
+        print("🌐 Starting HTTP server with hypercorn...")
 
     # Run the server
     asyncio.run(hypercorn.asyncio.serve(app, config_hypercorn))

mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.3.27.dist-info → mcp_proxy_adapter-6.3.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.3.27
+Version: 6.3.29
 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

{mcp_proxy_adapter-6.3.27.dist-info → mcp_proxy_adapter-6.3.29.dist-info}/RECORD

@@ -2,11 +2,11 @@ mcp_proxy_adapter/__init__.py,sha256=iH0EBBsRj_cfZJpAIsgN_8tTdfefhnl6uUKHjLHhWDQ
 mcp_proxy_adapter/__main__.py,sha256=sq3tANRuTd18euamt0Bmn1sJeAyzXENZ5VvsMwbrDFA,579
 mcp_proxy_adapter/config.py,sha256=-7iVS0mUWWKNeao7nqTAFlUD6FcMwRlDkchN7OwYsr0,21662
 mcp_proxy_adapter/custom_openapi.py,sha256=yLle4CntYK9wpivgn9NflZyJhy-YNrmWjJzt0ai5nP0,14672
-mcp_proxy_adapter/main.py,sha256=8AO1AGuefnvqaLbNgBsIXCYLnCUL9FSBLRM-mhHc72Q,3655
+mcp_proxy_adapter/main.py,sha256=idp3KUR7CT7kTXLVPvvclJlNnt8d_HYl8_jY98uknmo,4677
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=WHwCxxgzhSbgaofCWsieqXUWDIjGsInDhmcZMv__yMI,75
+mcp_proxy_adapter/version.py,sha256=-ovt_O-oGtB7PGYmXBTw9F3gQ0hY2m0CQXDOLYzG6So,75
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_proxy_adapter/api/app.py,sha256=UBCiMPHaZYx_3G8EdEkT1yKtPEnKnLJplDjX5sQcQlM,29757
+mcp_proxy_adapter/api/app.py,sha256=dIsAWbQFWMa8zxhPro9hxUnUuqnLWlqutWAKrqJIHGE,33386
 mcp_proxy_adapter/api/handlers.py,sha256=iyFGoEuUS1wxbV1ELA0zmaxIyQR7j4zw-4MrD-uIO6E,8294
 mcp_proxy_adapter/api/schemas.py,sha256=mevUvQnYgWQfkJAs3-vq3HalBzh6-Saa-Au1VVf0peE,12377
 mcp_proxy_adapter/api/tool_integration.py,sha256=AeUyvJVN-c3FrX5fHdagHL51saRH5d1ZKqc2YEx0rTE,10147
@@ -29,7 +29,7 @@ mcp_proxy_adapter/commands/builtin_commands.py,sha256=8kYLWIr4JvhZtqaVM9Jhqr_-yS
 mcp_proxy_adapter/commands/catalog_manager.py,sha256=1DLvjt9RVMmeNZyynd-frk8gYkdgGJYyBXg6uWTJ16k,34873
 mcp_proxy_adapter/commands/cert_monitor_command.py,sha256=phSms8EYOn1RqSp7na6jw0S1bLRrilmYZIFXVepVFyU,23687
 mcp_proxy_adapter/commands/certificate_management_command.py,sha256=TDoGV2mnEz1HaJiHsxAO_IvtSinVwp0s_av5oIgmRqk,23225
-mcp_proxy_adapter/commands/command_registry.py,sha256=abQPOAzS_zIj4SPsOxsZeQS9pjLxyzlMUt9kI_AYT7E,35288
+mcp_proxy_adapter/commands/command_registry.py,sha256=RFGZw-0A29P6ZQMZ2qi5wQe3K89hCNOqRTdhtYYDGDg,36498
 mcp_proxy_adapter/commands/config_command.py,sha256=PWX1OhKAmjlc8CSy4-sImdvGeSNgDNyv30Y-P5iZp9g,3767
 mcp_proxy_adapter/commands/dependency_container.py,sha256=mvPob62lQ-mKRbAA9aL3L5gOT9_4V2Vy2cGoup2S840,3239
 mcp_proxy_adapter/commands/dependency_manager.py,sha256=JWdmQ0de6rQAv8GYDToFIlpomBBXqT61XMygWcggYSQ,7366
@@ -61,15 +61,15 @@ mcp_proxy_adapter/core/client.py,sha256=qIbPl8prEwK2U65kl-vGJW2_imo1E4i6HxG_VpPe
 mcp_proxy_adapter/core/client_manager.py,sha256=yD8HZJlOwmDbVU49YfzSbh1XZ-Vib8qfcLVAaH03Jdg,8832
 mcp_proxy_adapter/core/client_security.py,sha256=siUaYorcDbpZsEIKgLfg-jBKkp7z_Er8wsO63mDD3Is,13127
 mcp_proxy_adapter/core/config_converter.py,sha256=Wnnsrbw7DxtgDfLG-IyyzK-hkKu0_1yp7-7dW87tu_4,17422
-mcp_proxy_adapter/core/config_validator.py,sha256=M_iQqskKk5VfziNkXTJwjU97vEBLNSsXIqtpTQKHAcA,9644
+mcp_proxy_adapter/core/config_validator.py,sha256=7Xs4T85Xwc3sQaaG1ZHnp6MUT4ZU3Zmlp0HNCYVa43A,8755
 mcp_proxy_adapter/core/crl_utils.py,sha256=Jnwq2UN52IoCDZCwByRP3XNMOJexftb-mVaH6zes6Fc,11706
 mcp_proxy_adapter/core/errors.py,sha256=UNEfdmK0zPGJrWH1zUMRjHIJMcoVDcBO4w8xxKHBv4w,5356
 mcp_proxy_adapter/core/logging.py,sha256=gNI6vfPQC7jrUtVu6NeDsmU72JPlrRRBhtJipL1eVrI,9560
 mcp_proxy_adapter/core/mtls_asgi.py,sha256=tvk0P9024s18dcCHY9AaQIecT4ojOTv21EuQWXwooU0,5200
 mcp_proxy_adapter/core/mtls_asgi_app.py,sha256=DT_fTUH1RkvBa3ThbyCyNb-XUHyCb4DqaKA1gcZC6z4,6538
 mcp_proxy_adapter/core/protocol_manager.py,sha256=3sWOAiMniQY5nu9CHkitIOGN4CXH28hOTwY92D0yasM,15268
-mcp_proxy_adapter/core/proxy_client.py,sha256=XweRXBNbntJ5UYdSxUDcOYmJY0jbsKbfdWC0Jw72wdQ,23039
-mcp_proxy_adapter/core/proxy_registration.py,sha256=HzcYay7V0lPgHdmHa980e9HiRGNvFpwPaure1fULiGk,25610
+mcp_proxy_adapter/core/proxy_client.py,sha256=CB6KBhV3vH2GU5nZ27VZ_xlNbYTAU_tnYFrkuK5He58,6094
+mcp_proxy_adapter/core/proxy_registration.py,sha256=qgNtdYPXZ6F1oXRXIXCICCL9NYkOteGrTVPQAI8P5mg,31483
 mcp_proxy_adapter/core/role_utils.py,sha256=YwRenGoXI5YrHVbFjKFAH2DJs2miyqhcr9LWF7mxieg,12284
 mcp_proxy_adapter/core/security_adapter.py,sha256=MAtNthsp7Qj4-oLFzSi7Pr3vWQbWS_uelqa5LGgrXIE,12957
 mcp_proxy_adapter/core/security_factory.py,sha256=M-1McwUOmuV7Eo-m_P2undtJVNK_KIjDx8o_uRY8rLo,8005
@@ -137,8 +137,8 @@ mcp_proxy_adapter/schemas/base_schema.json,sha256=v9G9cGMd4dRhCZsOQ_FMqOi5VFyVbI
 mcp_proxy_adapter/schemas/openapi_schema.json,sha256=C3yLkwmDsvnLW9B5gnKKdBGl4zxkeU-rEmjTrNVsQU0,8405
 mcp_proxy_adapter/utils/config_generator.py,sha256=UXxuxxAyKTesAS3DOofQ26e20v771inA7EfBV8PZD1c,47543
 mcp_proxy_adapter_issue_package/demonstrate_issue.py,sha256=O54fwWQvUAjEGiHhQGm1JLnARkhVCwAqjBk_89HyRbY,7894
-mcp_proxy_adapter-6.3.27.dist-info/METADATA,sha256=RF13rZYgH63Gz_IwgF0dQwCf1emPHvMg6lkneEj4sIY,22266
-mcp_proxy_adapter-6.3.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.3.27.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
-mcp_proxy_adapter-6.3.27.dist-info/top_level.txt,sha256=CHk-Mc-AxjO-tRheegA2qLiQnU4vZRnxuTF81So6SAc,50
-mcp_proxy_adapter-6.3.27.dist-info/RECORD,,
+mcp_proxy_adapter-6.3.29.dist-info/METADATA,sha256=bZZCMwuivX69iTp2icdrC62BOcoi6lurr6v_qnD5WGs,22266
+mcp_proxy_adapter-6.3.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.3.29.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
+mcp_proxy_adapter-6.3.29.dist-info/top_level.txt,sha256=CHk-Mc-AxjO-tRheegA2qLiQnU4vZRnxuTF81So6SAc,50
+mcp_proxy_adapter-6.3.29.dist-info/RECORD,,