mcp-proxy-adapter 6.6.3__py3-none-any.whl → 6.6.4__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -65,11 +65,8 @@ def create_lifespan(config_path: Optional[str] = None):
             initialize_proxy_registration,
         )
 
-        # Initialize proxy registration manager early
-        try:
-            initialize_proxy_registration(config.get_all())
-        except Exception as e:
-            logger.error(f"Failed to initialize proxy registration: {e}")
+        # Proxy registration manager will be initialized in registry.reload_system()
+        # after all commands are loaded to ensure complete command schema
 
         # Compute server_url EARLY and inject into registration manager so
         # that reload_system (which may perform registration) uses the correct
@@ -124,11 +121,7 @@ def create_lifespan(config_path: Optional[str] = None):
         )
         logger.info(f"System initialization result: {init_result}")
 
-        # Initialize proxy registration manager with current config
-        try:
-            initialize_proxy_registration(config.get_all())
-        except Exception as e:
-            logger.error(f"Failed to initialize proxy registration: {e}")
+        # Proxy registration manager is already initialized in registry.reload_system()
 
         # Recompute registration URL AFTER config reload using final config
         try:
@@ -141,11 +134,11 @@ def create_lifespan(config_path: Optional[str] = None):
             public_host = reg_cfg.get("public_host")
             public_port = reg_cfg.get("public_port")
 
-            security_config = final_config.get("security", {})
-            ssl_cfg = security_config.get("ssl", {})
-            if not ssl_cfg.get("enabled", False):
-                ssl_cfg = final_config.get("ssl", {})
-            protocol = "https" if ssl_cfg.get("enabled", False) else "http"
+            # Determine protocol using the new configuration structure
+            protocol_cfg = final_config.get("server", {}).get("protocol", "http")
+            verify_client_cfg = final_config.get("transport", {}).get("verify_client", False)
+            ssl_enabled_final = protocol_cfg in ["https", "mtls"] or verify_client_cfg
+            protocol = "https" if ssl_enabled_final else "http"
 
             import os
             docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
@@ -184,19 +177,26 @@ def create_lifespan(config_path: Optional[str] = None):
             logger.error(f"Failed to recompute registration URL: {e}")
             server_url = early_server_url
 
-        # Attempt proxy registration in background with small delay
-        async def _delayed_register():
+        # Proxy registration is now handled in registry.reload_system() 
+        # after all commands are loaded, ensuring complete command schema
+        logger.info("ℹ️ Proxy registration will be handled after command loading completes")
+        
+        # Add delayed registration task to allow server to fully start
+        async def delayed_registration():
+            """Delayed registration to ensure server is fully started."""
+            await asyncio.sleep(2)  # Wait for server to start listening
+            logger.info("🔄 Attempting delayed proxy registration after server startup")
             try:
-                await asyncio.sleep(0.5)
+                from mcp_proxy_adapter.core.proxy_registration import register_with_proxy
                 success = await register_with_proxy(server_url)
                 if success:
-                    logger.info("✅ Proxy registration completed successfully")
+                    logger.info("✅ Delayed proxy registration successful")
                 else:
-                    logger.info("ℹ️ Proxy registration is disabled or failed")
+                    logger.warning("⚠️ Delayed proxy registration failed")
             except Exception as e:
-                logger.error(f"Proxy registration failed: {e}")
-
-        asyncio.create_task(_delayed_register())
+                logger.error(f"❌ Delayed proxy registration error: {e}")
+        
+        asyncio.create_task(delayed_registration())
 
         yield  # Application is running
 
@@ -237,16 +237,20 @@ def create_ssl_context(
         return None
 
     # Get certificate paths from configuration
-    cert_file = current_config.get("ssl", {}).get("cert_file")
-    key_file = current_config.get("ssl", {}).get("key_file")
+    cert_file = current_config.get("transport", {}).get("cert_file")
+    key_file = current_config.get("transport", {}).get("key_file")
+    ca_cert = current_config.get("transport", {}).get("ca_cert")
     
-    # If not found in ssl section, use default paths
-    if not cert_file:
+    # Convert relative paths to absolute paths
+    if cert_file and not Path(cert_file).is_absolute():
+        project_root = Path(__file__).parent.parent.parent
+        cert_file = str(project_root / cert_file)
+    if key_file and not Path(key_file).is_absolute():
         project_root = Path(__file__).parent.parent.parent
-        cert_file = str(project_root / "certs" / "server.crt")
-    if not key_file:
+        key_file = str(project_root / key_file)
+    if ca_cert and not Path(ca_cert).is_absolute():
         project_root = Path(__file__).parent.parent.parent
-        key_file = str(project_root / "certs" / "server.key")
+        ca_cert = str(project_root / ca_cert)
 
     if not cert_file or not key_file:
         logger.warning("SSL enabled but certificate or key file not specified")
@@ -257,15 +261,15 @@ def create_ssl_context(
         ssl_context = SSLUtils.create_ssl_context(
             cert_file=cert_file,
             key_file=key_file,
-            ca_cert=ssl_config.get("ca_cert"),
-            verify_client=ssl_config.get("verify_client", False),
-            cipher_suites=ssl_config.get("cipher_suites", []),
-            min_tls_version=ssl_config.get("min_tls_version", "1.2"),
-            max_tls_version=ssl_config.get("max_tls_version", "1.3"),
+            ca_cert=ca_cert,
+            verify_client=current_config.get("transport", {}).get("verify_client", False),
+            cipher_suites=[],
+            min_tls_version="1.2",
+            max_tls_version="1.3",
         )
 
         logger.info(
-            f"SSL context created successfully for mode: {ssl_config.get('mode', 'https_only')}"
+            f"SSL context created successfully for mode: https_only"
         )
         return ssl_context
 

mcp_proxy_adapter/commands/command_registry.py

@@ -786,23 +786,37 @@ class CommandRegistry:
             # Initialize proxy registration manager with current config
             initialize_proxy_registration(config.get_all())
 
-            # Get server configuration
+            # Get server configuration with proper URL resolution logic
             server_config = config.get("server", {})
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
 
-            # Determine server URL based on SSL configuration
-            ssl_config = config.get("ssl", {})
-            if ssl_config.get("enabled", False):
-                protocol = "https"
-            else:
-                protocol = "http"
-
-            # Use localhost for external access if host is 0.0.0.0
-            if server_host == "0.0.0.0":
-                server_host = "localhost"
-
-            server_url = f"{protocol}://{server_host}:{server_port}"
+            # Get registration configuration for public host/port overrides
+            # First check server config, then registration config
+            public_host = config.get("server.public_host")
+            public_port = config.get("server.public_port")
+            
+            # Fallback to registration config if not found in server
+            if not public_host or not public_port:
+                reg_cfg = config.get("registration", config.get("proxy_registration", {}))
+                public_host = public_host or reg_cfg.get("public_host")
+                public_port = public_port or reg_cfg.get("public_port")
+
+            # Determine protocol based on new configuration structure
+            protocol = config.get("server.protocol", "http")
+            verify_client = config.get("transport.verify_client", False)
+            ssl_enabled = protocol in ["https", "mtls"] or verify_client
+            protocol = "https" if ssl_enabled else "http"
+
+            # Resolve host and port (same logic as in app.py)
+            import os
+            docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+            resolved_host = public_host or (docker_host_addr if server_host == "0.0.0.0" else server_host)
+            resolved_port = public_port or server_port
+
+            server_url = f"{protocol}://{resolved_host}:{resolved_port}"
+            
+            logger.info(f"🔍 Proxy registration URL resolved: {server_url}")
 
             # Attempt proxy registration
             proxy_registration_success = await register_with_proxy(server_url)

mcp_proxy_adapter/config.py

@@ -84,7 +84,7 @@ class Config:
             "transport": {
                 "type": "http",
                 "port": None,
-                "verify_client": False,
+                    "verify_client": False,
                 "chk_hostname": False,  # Default to False for HTTP
             },
             "proxy_registration": {

mcp_proxy_adapter/core/proxy_registration.py

@@ -13,6 +13,7 @@ email: vasilyvz@gmail.com
 import asyncio
 import time
 import ssl
+import traceback
 from typing import Dict, Any, Optional, Tuple
 from pathlib import Path
 from urllib.parse import urljoin
@@ -248,10 +249,15 @@ class ProxyRegistrationManager:
         """
         logger.debug("_create_ssl_context called")
         
-        # Check if we're in HTTP mode - if so, don't create SSL context
-        server_config = self.config.get("server", {})
-        if server_config.get("protocol", "http").lower() == "http":
-            logger.debug("HTTP mode detected, skipping SSL context creation")
+        # Decide SSL strictly by proxy URL scheme: use SSL only for https proxy URLs
+        try:
+            from urllib.parse import urlparse as _urlparse
+            scheme = _urlparse(self.proxy_url).scheme if self.proxy_url else "http"
+            if scheme.lower() != "https":
+                logger.debug("Proxy URL is HTTP, skipping SSL context creation for registration")
+                return None
+        except Exception:
+            logger.debug("Failed to parse proxy_url, assuming HTTP and skipping SSL context")
             return None
             
         if not self.client_security:
@@ -440,7 +446,11 @@ class ProxyRegistrationManager:
 
                 if success:
                     self.registered = True
-                    self.server_key = result.get("server_key")
+                    # Safely extract server_key from result
+                    if isinstance(result, dict):
+                        self.server_key = result.get("server_key")
+                    else:
+                        self.server_key = None
                     logger.info(
                         f"✅ Successfully registered with proxy. Server key: {self.server_key}"
                     )
@@ -455,8 +465,65 @@ class ProxyRegistrationManager:
                 else:
                     # Be robust if result is not a dict
                     error_msg = None
+                    logger.error(f"DEBUG: result type = {type(result)}, result = {result}")
                     if isinstance(result, dict):
-                        error_msg = result.get("error", {}).get("message", "Unknown error")
+                        logger.error(f"DEBUG: result is dict, getting error field")
+                        error_field = result.get("error", {})
+                        logger.error(f"DEBUG: error_field type = {type(error_field)}, error_field = {error_field}")
+                        if isinstance(error_field, dict):
+                            error_msg = error_field.get("message", "Unknown error")
+                        elif isinstance(error_field, str):
+                            error_msg = error_field
+                        else:
+                            error_msg = str(error_field)
+
+                        # Auto-recovery: already registered case → force unregistration then retry once
+                        error_code = result.get("error_code") or (result.get("error", {}).get("code") if isinstance(result.get("error"), dict) else None)
+                        already_registered = False
+                        existing_server_key = None
+                        # Prefer structured detail if provided
+                        if isinstance(result.get("details"), dict):
+                            existing_server_key = result.get("details", {}).get("existing_server_key")
+                        # Fallback: parse from error message text
+                        if not existing_server_key and isinstance(error_msg, str) and "already registered as" in error_msg:
+                            try:
+                                # Expecting: "... already registered as <server_id>_<copy_number>"
+                                tail = error_msg.split("already registered as", 1)[1].strip()
+                                existing_server_key = tail.split()[0]
+                            except Exception:
+                                existing_server_key = None
+
+                        if (error_code in ("DUPLICATE_SERVER_URL", "REGISTRATION_ERROR") or already_registered) and existing_server_key:
+                            try:
+                                logger.info(f"Attempting auto-unregistration of existing instance: {existing_server_key}")
+                                # Build unregistration payload using parsed server_key
+                                try:
+                                    copy_number = int(existing_server_key.split("_")[-1])
+                                except Exception:
+                                    copy_number = 1
+                                unregistration_data = {"server_id": self.server_id, "copy_number": copy_number}
+                                # Reuse secure unregistration request directly
+                                unreg_success, _unreg_result = await self._make_secure_unregistration_request(unregistration_data)
+                                if unreg_success:
+                                    logger.info("Auto-unregistration succeeded, retrying registration once...")
+                                    # Retry registration once immediately
+                                    retry_success, retry_result = await self._make_secure_registration_request(registration_data)
+                                    if retry_success:
+                                        self.registered = True
+                                        if isinstance(retry_result, dict):
+                                            self.server_key = retry_result.get("server_key")
+                                        else:
+                                            self.server_key = None
+                                        logger.info(f"✅ Successfully registered after auto-unregistration. Server key: {self.server_key}")
+                                        if self.registration_config.get("heartbeat", {}).get("enabled", True):
+                                            await self._start_heartbeat()
+                                        return True
+                                    else:
+                                        logger.warning(f"Retry registration failed after auto-unregistration: {retry_result}")
+                                else:
+                                    logger.warning(f"Auto-unregistration failed: {_unreg_result}")
+                            except Exception as _auto_e:
+                                logger.warning(f"Auto-unregistration/registration flow error: {_auto_e}")
                     else:
                         error_msg = str(result)
                     logger.warning(
@@ -467,6 +534,7 @@ class ProxyRegistrationManager:
                 logger.error(
                     f"❌ Registration attempt {attempt + 1} failed with exception: {e}"
                 )
+                logger.error(f"Full traceback: {traceback.format_exc()}")
 
         logger.error(
             f"❌ Failed to register with proxy after {self.retry_attempts} attempts"
@@ -562,8 +630,10 @@ class ProxyRegistrationManager:
                 ) as response:
                     try:
                         result = await response.json()
-                    except Exception:
+                        logger.debug(f"Response JSON parsed successfully: {type(result)} - {result}")
+                    except Exception as e:
                         text_body = await response.text()
+                        logger.debug(f"JSON parsing failed: {e}, text_body: {text_body}")
                         result = {"success": False, "error": {"code": "NON_JSON_RESPONSE", "message": text_body}}
 
                     # Validate response headers if security framework available
@@ -604,6 +674,9 @@ class ProxyRegistrationManager:
                         logger.warning(
                             f"Registration failed with HTTP status: {response.status}"
                         )
+                        # Ensure result is a dict for consistent error handling
+                        if isinstance(result, str):
+                            result = {"success": False, "error": {"code": "HTTP_ERROR", "message": result}}
                         return False, result
         finally:
             if connector:

mcp_proxy_adapter/examples/config_builder.py

@@ -76,7 +76,7 @@ class ConfigBuilder:
             },
             "transport": {
                 "type": "http",
-                "port": None,
+                        "port": None,
                 "verify_client": False,
                 "chk_hostname": False
             }
@@ -231,7 +231,7 @@ class ConfigFactory:
                 .set_auth(AuthMethod.TOKEN)
                 .set_server(port=port)
                 .build())
-    
+
     @staticmethod
     def create_mtls_token_roles_config(port: int = 8008) -> Dict[str, Any]:
         """Create mTLS with token and roles configuration."""

mcp_proxy_adapter/main.py

@@ -73,11 +73,19 @@ def main():
     ssl_ca_cert = None
     
     if ssl_enabled:
-        # Configure SSL certificates - use absolute paths
+        # Configure SSL certificates from configuration
+        ssl_cert_file = config.get("transport.cert_file")
+        ssl_key_file = config.get("transport.key_file")
+        ssl_ca_cert = config.get("transport.ca_cert")
+        
+        # Convert relative paths to absolute paths
         project_root = Path(__file__).parent.parent
-        ssl_cert_file = str(project_root / "certs" / "server_cert.pem")
-        ssl_key_file = str(project_root / "keys" / "server_key.pem")
-        ssl_ca_cert = str(project_root / "certs" / "localhost_server.crt")
+        if ssl_cert_file and not Path(ssl_cert_file).is_absolute():
+            ssl_cert_file = str(project_root / ssl_cert_file)
+        if ssl_key_file and not Path(ssl_key_file).is_absolute():
+            ssl_key_file = str(project_root / ssl_key_file)
+        if ssl_ca_cert and not Path(ssl_ca_cert).is_absolute():
+            ssl_ca_cert = str(project_root / ssl_ca_cert)
 
     print("🔍 Debug config:")
     print(f"   protocol: {protocol}")

mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.6.3.dist-info → mcp_proxy_adapter-6.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.6.3
+Version: 6.6.4
 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.6.3.dist-info → mcp_proxy_adapter-6.6.4.dist-info}/RECORD

@@ -1,12 +1,12 @@
 mcp_proxy_adapter/__init__.py,sha256=iH0EBBsRj_cfZJpAIsgN_8tTdfefhnl6uUKHjLHhWDQ,1037
 mcp_proxy_adapter/__main__.py,sha256=sq3tANRuTd18euamt0Bmn1sJeAyzXENZ5VvsMwbrDFA,579
-mcp_proxy_adapter/config.py,sha256=sYyqmWGCWSiFy4q0zdlkJKxz2IbNIbjCfEhqxdVvjbI,20157
+mcp_proxy_adapter/config.py,sha256=QpoPaUKcWJ-eu6HYphhIZmkc2M-p1JgpLFAgolf_l5s,20161
 mcp_proxy_adapter/custom_openapi.py,sha256=XRviX-C-ZkSKdBhORhDTdeN_1FWyEfXZADiASft3t9I,28149
-mcp_proxy_adapter/main.py,sha256=E3K2vDnnZ44ODdSWDqAdaIG-55NIyYbcpxNGEQLQlPg,5461
+mcp_proxy_adapter/main.py,sha256=eXIRMLgDgCox9p2WDcOS9D6tiZjcFit8ePbFCfGbs3Q,5849
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=2s9mmkrnxOAjp6hsHf5RXfk463sH55FUntKrzYuyXJY,74
+mcp_proxy_adapter/version.py,sha256=iHKhx47r6lqg0YU6oEtF4CqcNCHws1gitETKpsxxgRs,74
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_proxy_adapter/api/app.py,sha256=chGxUMfWQXqn4wRC7Ar4X9uMF7JxI5EmQNVPEr0TQZI,34573
+mcp_proxy_adapter/api/app.py,sha256=c6QgiKBYC4YlPW-a8ZnsQ05CJqjtGEMfEnbvdp19ylE,35148
 mcp_proxy_adapter/api/handlers.py,sha256=X-hcMNVeTAu4yVkKJEChEsj2bFptUS6sLNN-Wysjkow,10011
 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=RFGZw-0A29P6ZQMZ2qi5wQe3K89hCNOqRTdhtYYDGDg,36498
+mcp_proxy_adapter/commands/command_registry.py,sha256=jsvGu50nwQdBCBAZ4i2Kn88RO0eETYT4WY1wwQlJGNw,37517
 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=lXgtrhCiQhy9Y-QpU_RWRg2d0VYy5msoNQPUjPOcOc8,8245
@@ -70,7 +70,7 @@ mcp_proxy_adapter/core/mtls_asgi_app.py,sha256=DT_fTUH1RkvBa3ThbyCyNb-XUHyCb4Dqa
 mcp_proxy_adapter/core/mtls_server.py,sha256=_hj6QWuExKX2LRohYvjPGFC2qTutS7ObegpEc09QijM,10117
 mcp_proxy_adapter/core/protocol_manager.py,sha256=iaXWsfm1XSfemz5QQBesMluc4cwf-LtuZVi9bm1uj28,14680
 mcp_proxy_adapter/core/proxy_client.py,sha256=CB6KBhV3vH2GU5nZ27VZ_xlNbYTAU_tnYFrkuK5He58,6094
-mcp_proxy_adapter/core/proxy_registration.py,sha256=m58w9iQd5zwXFIpuaDRXKPQ3fhQDBJPkD4w7m742ciY,35200
+mcp_proxy_adapter/core/proxy_registration.py,sha256=QKjRDbrKRVDcsZl66CRdmr-IoymJjF9cbyp6CLSW090,40504
 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
@@ -86,7 +86,7 @@ mcp_proxy_adapter/examples/__init__.py,sha256=k1F-EotAFbJ3JvK_rNgiH4bUztmxIWtYn0
 mcp_proxy_adapter/examples/bugfix_certificate_config.py,sha256=YGBE_SI6wYZUJLWl7-fP1OWXiSH4mHJAZHApgQWvG7s,10529
 mcp_proxy_adapter/examples/cert_manager_bugfix.py,sha256=UWUwItjqHqSnOMHocsz40_3deoZE8-vdROLW9y2fEns,7259
 mcp_proxy_adapter/examples/check_config.py,sha256=oDP3cymq76TqEpPztPihH-_sBktiEb2cG0MdVrY1Sj8,14104
-mcp_proxy_adapter/examples/config_builder.py,sha256=eIn_kxoM_Q7oNrqV2lpn4a_jrJrJxfhCfpFHdzibHvs,9648
+mcp_proxy_adapter/examples/config_builder.py,sha256=Bd4Opggi9Nut4yQ5Mo_qETMcWRTls3BwwnNZd33Mvjs,9652
 mcp_proxy_adapter/examples/config_cli.py,sha256=ZhVG6XEpTFe5-MzELByVsUh0AD4bHPBZeoXnGWbqifs,11059
 mcp_proxy_adapter/examples/create_test_configs.py,sha256=9TrvLa4-bWLPu0SB1JXwWuCsjj-4Vz3yAdowcHtCSSA,8228
 mcp_proxy_adapter/examples/debug_request_state.py,sha256=Z3Gy2-fWtu7KIV9OkzGDLVz7TpL_h9V_99ica40uQBU,4489
@@ -130,8 +130,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/schemas/roles.json,sha256=pgf_ZyqKyXbfGUxvobpiLiSJz9zzxrMuoVWEkEpz3N8,764
 mcp_proxy_adapter/schemas/roles_schema.json,sha256=deHgI7L6GwfBXacOlNtDgDJelDThppClC3Ti4Eh8rJY,5659
-mcp_proxy_adapter-6.6.3.dist-info/METADATA,sha256=lLweBJ6i0eno3-C5RYfQCTuzycn0Q0k0NJSwCxFl0m4,8510
-mcp_proxy_adapter-6.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.6.3.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
-mcp_proxy_adapter-6.6.3.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.6.3.dist-info/RECORD,,
+mcp_proxy_adapter-6.6.4.dist-info/METADATA,sha256=EEJhXaGOOOhiN-esLAqkguvXi_XGuyEDexIW1WqXSE0,8510
+mcp_proxy_adapter-6.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.6.4.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
+mcp_proxy_adapter-6.6.4.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-6.6.4.dist-info/RECORD,,