mcp-proxy-adapter 6.3.0__py3-none-any.whl → 6.3.2__py3-none-any.whl

mcp_proxy_adapter/core/proxy_registration.py

@@ -10,15 +10,12 @@ email: vasilyvz@gmail.com
 """
 
 import asyncio
-import json
 import time
 import ssl
 from typing import Dict, Any, Optional, Tuple
 from urllib.parse import urljoin
 
 import aiohttp
-import requests
-from requests.exceptions import RequestException
 
 from mcp_proxy_adapter.core.logging import logger
 from mcp_proxy_adapter.core.client_security import create_client_security_manager
@@ -26,88 +23,113 @@ from mcp_proxy_adapter.core.client_security import create_client_security_manage
 
 class ProxyRegistrationError(Exception):
     """Exception raised when proxy registration fails."""
+
     pass
 
 
 class ProxyRegistrationManager:
     """
     Manager for proxy registration functionality with security framework integration.
-    
+
     Handles automatic registration and unregistration of the server
     with the MCP proxy server using secure authentication methods.
     """
-    
+
     def __init__(self, config: Dict[str, Any]):
         """
         Initialize the proxy registration manager.
-        
+
         Args:
             config: Application configuration
         """
         self.config = config
         # Try both registration and proxy_registration for backward compatibility
-        self.registration_config = config.get("registration", config.get("proxy_registration", {}))
-        
+        self.registration_config = config.get(
+            "registration", config.get("proxy_registration", {})
+        )
+
         # Basic registration settings
-        self.proxy_url = self.registration_config.get("proxy_url", "https://proxy-registry.example.com")
-        self.server_id = self.registration_config.get("server_id", self.registration_config.get("proxy_info", {}).get("name", "mcp_proxy_adapter"))
-        self.server_name = self.registration_config.get("server_name", self.registration_config.get("proxy_info", {}).get("name", "MCP Proxy Adapter"))
-        self.description = self.registration_config.get("description", self.registration_config.get("proxy_info", {}).get("description", "JSON-RPC API for interacting with MCP Proxy"))
-        self.version = self.registration_config.get("version", self.registration_config.get("proxy_info", {}).get("version", "1.0.0"))
-        
+        self.proxy_url = self.registration_config.get(
+            "proxy_url", "https://proxy-registry.example.com"
+        )
+        self.server_id = self.registration_config.get(
+            "server_id",
+            self.registration_config.get("proxy_info", {}).get(
+                "name", "mcp_proxy_adapter"
+            ),
+        )
+        self.server_name = self.registration_config.get(
+            "server_name",
+            self.registration_config.get("proxy_info", {}).get(
+                "name", "MCP Proxy Adapter"
+            ),
+        )
+        self.description = self.registration_config.get(
+            "description",
+            self.registration_config.get("proxy_info", {}).get(
+                "description", "JSON-RPC API for interacting with MCP Proxy"
+            ),
+        )
+        self.version = self.registration_config.get(
+            "version",
+            self.registration_config.get("proxy_info", {}).get("version", "1.0.0"),
+        )
+
         # Heartbeat settings
         heartbeat_config = self.registration_config.get("heartbeat", {})
         self.timeout = heartbeat_config.get("timeout", 30)
         self.retry_attempts = heartbeat_config.get("retry_attempts", 3)
         self.retry_delay = heartbeat_config.get("retry_delay", 60)
         self.heartbeat_interval = heartbeat_config.get("interval", 300)
-        
+
         # Auto registration settings
         self.auto_register = self.registration_config.get("enabled", False)
         self.auto_unregister = True  # Always unregister on shutdown
-        
+
         # Initialize client security manager
         self.client_security = create_client_security_manager(config)
-        
+
         # Registration state
         self.registered = False
         self.server_key: Optional[str] = None
         self.server_url: Optional[str] = None
         self.heartbeat_task: Optional[asyncio.Task] = None
-        
-        logger.info("Proxy registration manager initialized with security framework integration")
-        
+
+        logger.info(
+            "Proxy registration manager initialized with security framework integration"
+        )
+
     def is_enabled(self) -> bool:
         """
         Check if proxy registration is enabled.
-        
+
         Returns:
             True if registration is enabled, False otherwise.
         """
         return self.registration_config.get("enabled", False)
-    
+
     def set_server_url(self, server_url: str) -> None:
         """
         Set the server URL for registration.
-        
+
         Args:
             server_url: The URL where this server is accessible.
         """
         self.server_url = server_url
         logger.info(f"Proxy registration server URL set to: {server_url}")
-    
+
     def _get_auth_headers(self) -> Dict[str, str]:
         """
         Get authentication headers for registration requests.
-        
+
         Returns:
             Dictionary of authentication headers
         """
         if not self.client_security:
             return {"Content-Type": "application/json"}
-        
+
         auth_method = self.registration_config.get("auth_method", "certificate")
-        
+
         if auth_method == "certificate":
             return self.client_security.get_client_auth_headers("certificate")
         elif auth_method == "token":
@@ -117,46 +139,48 @@ class ProxyRegistrationManager:
         elif auth_method == "api_key":
             api_key_config = self.registration_config.get("api_key", {})
             api_key = api_key_config.get("key")
-            return self.client_security.get_client_auth_headers("api_key", api_key=api_key)
+            return self.client_security.get_client_auth_headers(
+                "api_key", api_key=api_key
+            )
         else:
             return {"Content-Type": "application/json"}
-    
+
     def _create_ssl_context(self) -> Optional[ssl.SSLContext]:
         """
         Create SSL context for secure connections.
-        
+
         Returns:
             SSL context or None if SSL not needed
         """
         if not self.client_security:
             return None
-        
+
         try:
             # Check if SSL is enabled for registration
             cert_config = self.registration_config.get("certificate", {})
             if cert_config.get("enabled", False):
                 return self.client_security.create_client_ssl_context()
-            
+
             return None
         except Exception as e:
             logger.error(f"Failed to create SSL context: {e}")
             return None
-    
+
     async def register_server(self) -> bool:
         """
         Register the server with the proxy using secure authentication.
-        
+
         Returns:
             True if registration was successful, False otherwise.
         """
         if not self.is_enabled():
             logger.info("Proxy registration is disabled in configuration")
             return False
-            
+
         if not self.server_url:
             logger.error("Server URL not set, cannot register with proxy")
             return False
-        
+
         # Prepare registration data with proxy info
         proxy_info = self.registration_config.get("proxy_info", {})
         registration_data = {
@@ -166,90 +190,100 @@ class ProxyRegistrationManager:
             "description": self.description,
             "version": self.version,
             "capabilities": proxy_info.get("capabilities", ["jsonrpc", "rest"]),
-            "endpoints": proxy_info.get("endpoints", {
-                "jsonrpc": "/api/jsonrpc",
-                "rest": "/cmd",
-                "health": "/health"
-            })
+            "endpoints": proxy_info.get(
+                "endpoints",
+                {"jsonrpc": "/api/jsonrpc", "rest": "/cmd", "health": "/health"},
+            ),
         }
-        
+
         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):
             try:
-                success, result = await self._make_secure_registration_request(registration_data)
-                
+                success, result = await self._make_secure_registration_request(
+                    registration_data
+                )
+
                 if success:
                     self.registered = True
                     self.server_key = result.get("server_key")
-                    logger.info(f"✅ Successfully registered with proxy. Server key: {self.server_key}")
-                    
+                    logger.info(
+                        f"✅ Successfully registered with proxy. Server key: {self.server_key}"
+                    )
+
                     # Start heartbeat if enabled
-                    if self.registration_config.get("heartbeat", {}).get("enabled", True):
+                    if self.registration_config.get("heartbeat", {}).get(
+                        "enabled", True
+                    ):
                         await self._start_heartbeat()
-                    
+
                     return True
                 else:
                     error_msg = result.get("error", {}).get("message", "Unknown error")
-                    logger.warning(f"❌ Registration attempt {attempt + 1} failed: {error_msg}")
-                    
+                    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}")
-                
+                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")
+
+        logger.error(
+            f"❌ Failed to register with proxy after {self.retry_attempts} attempts"
+        )
         return False
-    
+
     async def unregister_server(self) -> bool:
         """
         Unregister the server from the proxy.
-        
+
         Returns:
             True if unregistration was successful, False otherwise.
         """
         if not self.is_enabled():
             logger.info("Proxy registration is disabled, skipping unregistration")
             return True
-            
+
         if not self.registered or not self.server_key:
             logger.info("Server not registered with proxy, skipping unregistration")
             return True
-        
+
         # Stop heartbeat
         await self._stop_heartbeat()
-        
+
         # Extract copy_number from server_key (format: server_id_copy_number)
         try:
             copy_number = int(self.server_key.split("_")[-1])
         except (ValueError, IndexError):
             copy_number = 1
-        
-        unregistration_data = {
-            "server_id": self.server_id,
-            "copy_number": copy_number
-        }
-        
+
+        unregistration_data = {"server_id": self.server_id, "copy_number": copy_number}
+
         logger.info(f"Attempting to unregister server from proxy at {self.proxy_url}")
         logger.debug(f"Unregistration data: {unregistration_data}")
-        
+
         try:
-            success, result = await self._make_secure_unregistration_request(unregistration_data)
-            
+            success, result = await self._make_secure_unregistration_request(
+                unregistration_data
+            )
+
             if success:
                 unregistered = result.get("unregistered", False)
                 if unregistered:
                     logger.info("✅ Successfully unregistered from proxy")
                 else:
                     logger.warning("⚠️ Server was not found in proxy registry")
-                
+
                 self.registered = False
                 self.server_key = None
                 return True
@@ -257,105 +291,143 @@ class ProxyRegistrationManager:
                 error_msg = result.get("error", {}).get("message", "Unknown error")
                 logger.error(f"❌ Failed to unregister from proxy: {error_msg}")
                 return False
-                
+
         except Exception as e:
             logger.error(f"❌ Unregistration failed with exception: {e}")
             return False
-    
-    async def _make_secure_registration_request(self, data: Dict[str, Any]) -> Tuple[bool, Dict[str, Any]]:
+
+    async def _make_secure_registration_request(
+        self, data: Dict[str, Any]
+    ) -> Tuple[bool, Dict[str, Any]]:
         """
         Make secure registration request to proxy using security framework.
-        
+
         Args:
             data: Registration data.
-            
+
         Returns:
             Tuple of (success, result).
         """
         url = urljoin(self.proxy_url, "/register")
-        
+
         # 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)
-        
+
         try:
             async with aiohttp.ClientSession(connector=connector) as session:
                 async with session.post(
                     url,
                     json=data,
                     headers=headers,
-                    timeout=aiohttp.ClientTimeout(total=self.timeout)
+                    timeout=aiohttp.ClientTimeout(total=self.timeout),
                 ) as response:
                     result = await response.json()
-                    
+
                     # Validate response headers if security framework available
                     if self.client_security:
-                        self.client_security.validate_server_response(dict(response.headers))
-                    
-                    return response.status == 200, result
+                        self.client_security.validate_server_response(
+                            dict(response.headers)
+                        )
+
+                    # Check both HTTP status and JSON success field
+                    if response.status == 200:
+                        success = result.get("success", False)
+                        if not success:
+                            error_info = result.get("error", {})
+                            error_msg = error_info.get("message", "Unknown error")
+                            error_code = error_info.get("code", "UNKNOWN_ERROR")
+                            logger.warning(
+                                f"Registration failed: {error_code} - {error_msg}"
+                            )
+                        return success, result
+                    else:
+                        logger.warning(
+                            f"Registration failed with HTTP status: {response.status}"
+                        )
+                        return False, result
         finally:
             if connector:
                 await connector.close()
-    
-    async def _make_secure_unregistration_request(self, data: Dict[str, Any]) -> Tuple[bool, Dict[str, Any]]:
+
+    async def _make_secure_unregistration_request(
+        self, data: Dict[str, Any]
+    ) -> Tuple[bool, Dict[str, Any]]:
         """
         Make secure unregistration request to proxy using security framework.
-        
+
         Args:
             data: Unregistration data.
-            
+
         Returns:
             Tuple of (success, result).
         """
         url = urljoin(self.proxy_url, "/unregister")
-        
+
         # 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)
-        
+
         try:
             async with aiohttp.ClientSession(connector=connector) as session:
                 async with session.post(
                     url,
                     json=data,
                     headers=headers,
-                    timeout=aiohttp.ClientTimeout(total=self.timeout)
+                    timeout=aiohttp.ClientTimeout(total=self.timeout),
                 ) as response:
                     result = await response.json()
-                    
+
                     # Validate response headers if security framework available
                     if self.client_security:
-                        self.client_security.validate_server_response(dict(response.headers))
-                    
-                    return response.status == 200, result
+                        self.client_security.validate_server_response(
+                            dict(response.headers)
+                        )
+
+                    # Check both HTTP status and JSON success field
+                    if response.status == 200:
+                        success = result.get("success", False)
+                        if not success:
+                            error_info = result.get("error", {})
+                            error_msg = error_info.get("message", "Unknown error")
+                            error_code = error_info.get("code", "UNKNOWN_ERROR")
+                            logger.warning(
+                                f"Unregistration failed: {error_code} - {error_msg}"
+                            )
+                        return success, result
+                    else:
+                        logger.warning(
+                            f"Unregistration failed with HTTP status: {response.status}"
+                        )
+                        return False, result
         finally:
             if connector:
                 await connector.close()
-    
+
     async def _start_heartbeat(self) -> None:
         """Start heartbeat task for keeping registration alive."""
         if self.heartbeat_task and not self.heartbeat_task.done():
             return
-        
+
         self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
         logger.info("Heartbeat task started")
-    
+
     async def _stop_heartbeat(self) -> None:
         """Stop heartbeat task."""
         if self.heartbeat_task and not self.heartbeat_task.done():
@@ -365,65 +437,67 @@ class ProxyRegistrationManager:
             except asyncio.CancelledError:
                 pass
             logger.info("Heartbeat task stopped")
-    
+
     async def _heartbeat_loop(self) -> None:
         """Heartbeat loop to keep registration alive."""
         while self.registered:
             try:
                 await asyncio.sleep(self.heartbeat_interval)
-                
+
                 if not self.registered:
                     break
-                
+
                 # Send heartbeat
                 success = await self._send_heartbeat()
                 if not success:
                     logger.warning("Heartbeat failed, attempting to re-register")
                     await self.register_server()
-                    
+
             except asyncio.CancelledError:
                 break
             except Exception as e:
                 logger.error(f"Heartbeat error: {e}")
-    
+
     async def _send_heartbeat(self) -> bool:
         """Send heartbeat to proxy server."""
         if not self.server_key:
             return False
-        
+
         heartbeat_data = {
             "server_id": self.server_id,
             "server_key": self.server_key,
-            "timestamp": int(time.time())
+            "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)
-        
+
         try:
             async with aiohttp.ClientSession(connector=connector) as session:
                 async with session.post(
                     url,
                     json=heartbeat_data,
                     headers=headers,
-                    timeout=aiohttp.ClientTimeout(total=self.timeout)
+                    timeout=aiohttp.ClientTimeout(total=self.timeout),
                 ) as response:
                     if response.status == 200:
                         logger.debug("Heartbeat sent successfully")
                         return True
                     else:
-                        logger.warning(f"Heartbeat failed with status: {response.status}")
+                        logger.warning(
+                            f"Heartbeat failed with status: {response.status}"
+                        )
                         return False
         except Exception as e:
             logger.error(f"Heartbeat error: {e}")
@@ -431,11 +505,11 @@ class ProxyRegistrationManager:
         finally:
             if connector:
                 await connector.close()
-    
+
     def get_registration_status(self) -> Dict[str, Any]:
         """
         Get current registration status.
-        
+
         Returns:
             Dictionary with registration status information.
         """
@@ -446,21 +520,22 @@ class ProxyRegistrationManager:
             "server_url": self.server_url,
             "proxy_url": self.proxy_url,
             "server_id": self.server_id,
-            "heartbeat_active": self.heartbeat_task is not None and not self.heartbeat_task.done()
+            "heartbeat_active": self.heartbeat_task is not None
+            and not self.heartbeat_task.done(),
         }
-        
+
         # Add security information if available
         if self.client_security:
             status["security_enabled"] = True
             status["ssl_enabled"] = self.client_security.is_ssl_enabled()
             status["auth_methods"] = self.client_security.get_supported_auth_methods()
-            
+
             cert_info = self.client_security.get_client_certificate_info()
             if cert_info:
                 status["client_certificate"] = cert_info
         else:
             status["security_enabled"] = False
-        
+
         return status
 
 
@@ -471,7 +546,7 @@ proxy_registration_manager: Optional[ProxyRegistrationManager] = None
 def initialize_proxy_registration(config: Dict[str, Any]) -> None:
     """
     Initialize global proxy registration manager.
-    
+
     Args:
         config: Application configuration
     """
@@ -482,17 +557,17 @@ def initialize_proxy_registration(config: Dict[str, Any]) -> None:
 async def register_with_proxy(server_url: str) -> bool:
     """
     Register the server with the proxy.
-    
+
     Args:
         server_url: The URL where this server is accessible.
-        
+
     Returns:
         True if registration was successful, False otherwise.
     """
     if not proxy_registration_manager:
         logger.error("Proxy registration manager not initialized")
         return False
-    
+
     proxy_registration_manager.set_server_url(server_url)
     return await proxy_registration_manager.register_server()
 
@@ -500,25 +575,25 @@ async def register_with_proxy(server_url: str) -> bool:
 async def unregister_from_proxy() -> bool:
     """
     Unregister the server from the proxy.
-    
+
     Returns:
         True if unregistration was successful, False otherwise.
     """
     if not proxy_registration_manager:
         logger.error("Proxy registration manager not initialized")
         return False
-    
+
     return await proxy_registration_manager.unregister_server()
 
 
 def get_proxy_registration_status() -> Dict[str, Any]:
     """
     Get current proxy registration status.
-    
+
     Returns:
         Dictionary with registration status information.
     """
     if not proxy_registration_manager:
         return {"error": "Proxy registration manager not initialized"}
-    
-    return proxy_registration_manager.get_registration_status() 
+
+    return proxy_registration_manager.get_registration_status()

mcp_proxy_adapter/utils/config_generator.py

@@ -10,6 +10,7 @@ email: vasilyvz@gmail.com
 
 import json
 import logging
+import uuid
 from pathlib import Path
 from typing import Dict, Any, Optional
 
@@ -32,6 +33,7 @@ class ConfigGenerator:
     def _get_template_config(self) -> Dict[str, Any]:
         """Get template configuration with all available options."""
         return {
+            "uuid": str(uuid.uuid4()),
             "server": {
                 "host": "0.0.0.0",
                 "port": 8000,
@@ -878,6 +880,7 @@ class ConfigGenerator:
     def _get_comments_for_type(self, config_type: str) -> Dict[str, str]:
         """Get comments for configuration sections."""
         base_comments = {
+            "uuid": "Unique service identifier (UUID4) - REQUIRED for service identification",
             "server": "Server configuration for FastAPI application",
             "ssl": "SSL/TLS configuration for secure connections",
             "security": "Security framework configuration (mcp_security_framework)",

mcp_proxy_adapter/version.py

@@ -2,5 +2,5 @@
 Version information for MCP Proxy Adapter.
 """
 
-__version__ = "6.3.0"
+__version__ = "6.3.2"
 

{mcp_proxy_adapter-6.3.0.dist-info → mcp_proxy_adapter-6.3.2.dist-info}/METADATA

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

@@ -4,7 +4,7 @@ mcp_proxy_adapter/config.py,sha256=_VpJrmdK6NS27ABgoEABvMcgUHxCjd1D1H-HUzx3-hY,2
 mcp_proxy_adapter/custom_openapi.py,sha256=jYUrCy8C1mShh3sjKj-JkzSMLAvxDLTvtzSJFj5HUNg,15023
 mcp_proxy_adapter/main.py,sha256=Q5WxLVbQ5y9cdpcriFvIuILaxFyPyyxyxQ4OeU3xaYY,3193
 mcp_proxy_adapter/openapi.py,sha256=36vOEbJjGnVZR6hUhl6mHCD29HYOEFKo2bL0JdGSm-4,13952
-mcp_proxy_adapter/version.py,sha256=cLE5eMWL3J6hNIyPXsLiTIJi4BsSVpfAngjwGMVZ1mQ,75
+mcp_proxy_adapter/version.py,sha256=A0-RO2zxRJWT7MAmVnv81okgNGwsizc4BPyzwLzaT-w,75
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_proxy_adapter/api/app.py,sha256=khl4kaI4mJ6dNbfAK7hR97Ek-eWC9NBeuXHr6GVbLoU,28911
 mcp_proxy_adapter/api/handlers.py,sha256=DcZT7MVBV33q-0EJ0iFqxE0VgBkFt6d_SqoRkntwyvc,8477
@@ -69,7 +69,7 @@ mcp_proxy_adapter/core/mtls_asgi.py,sha256=X2lAj3wk3L85amRCp_-10sqvZa5wJf_diXhwr
 mcp_proxy_adapter/core/mtls_asgi_app.py,sha256=VeolP08TTaqYU5fGeaZexj6EBWBDugoVrEGXzJW4PuM,6406
 mcp_proxy_adapter/core/protocol_manager.py,sha256=ISFRXjUuK4Q3uMbVB8-O_ozQSsDEH0PQA_HAKGeUrrw,14763
 mcp_proxy_adapter/core/proxy_client.py,sha256=n44T5iBS29y6E2lQLGKpOQxPYVrxIl98OAs6mMuhEsM,22916
-mcp_proxy_adapter/core/proxy_registration.py,sha256=Mmh-hWVJKkADLP8361Nx_SGFp9JRwtWnQtjuOhGx5Ss,19785
+mcp_proxy_adapter/core/proxy_registration.py,sha256=CCxzKwkGMLjooX6aTdeBCvad4T29nnhGBQ90FcG38f0,21278
 mcp_proxy_adapter/core/role_utils.py,sha256=wMoTVz3gF5fM7jozNMwsEwPkp1tui26M-t_KH1Oz8gs,12880
 mcp_proxy_adapter/core/security_adapter.py,sha256=wZ3OH1WzhUdpN8N8CrGJSFFVNi474DqdazIqQ1T8PN4,13343
 mcp_proxy_adapter/core/security_factory.py,sha256=4r7qvBq30XfosGD_b1ZHyNVLN8rOQ3NAKuaCOCEK8jA,8262
@@ -134,10 +134,10 @@ mcp_proxy_adapter/examples/scripts/create_certificates_simple.py,sha256=xkIvUYl6
 mcp_proxy_adapter/examples/scripts/generate_certificates_and_tokens.py,sha256=J0qHm_BMY8RYqfuwf7V7xKsHcsRJx8E7x-8JxmW5sPw,15988
 mcp_proxy_adapter/schemas/base_schema.json,sha256=v9G9cGMd4dRhCZsOQ_FMqOi5VFyVbI6Cf3fyIvOT9dc,2881
 mcp_proxy_adapter/schemas/openapi_schema.json,sha256=C3yLkwmDsvnLW9B5gnKKdBGl4zxkeU-rEmjTrNVsQU0,8405
-mcp_proxy_adapter/utils/config_generator.py,sha256=0CnUuz4WMBtHY-FNB7MNS1eV6lsu_S_lpMmhefNvlEw,46502
-mcp_proxy_adapter-6.3.0.dist-info/licenses/LICENSE,sha256=6KdtUcTwmTRbJrAmYjVn7e6S-V42ubeDJ-AiVEzZ510,1075
-mcp_proxy_adapter-6.3.0.dist-info/METADATA,sha256=JgFm83RdMmT727lE7gpIwsvdQhL6xdK9EW0M5vBVFmU,22347
-mcp_proxy_adapter-6.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.3.0.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
-mcp_proxy_adapter-6.3.0.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.3.0.dist-info/RECORD,,
+mcp_proxy_adapter/utils/config_generator.py,sha256=HuNqUgV-aoJ6A1LfX_EGJAVsj-tbaOcV2H6jw6TjfmY,46648
+mcp_proxy_adapter-6.3.2.dist-info/licenses/LICENSE,sha256=6KdtUcTwmTRbJrAmYjVn7e6S-V42ubeDJ-AiVEzZ510,1075
+mcp_proxy_adapter-6.3.2.dist-info/METADATA,sha256=x487vHH_rG-nAcWPh8pfh6ZHteSfTpF_gu3H3BZMRxk,22347
+mcp_proxy_adapter-6.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.3.2.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
+mcp_proxy_adapter-6.3.2.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-6.3.2.dist-info/RECORD,,