mcp-proxy-adapter 6.9.15__py3-none-any.whl → 6.9.17__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -116,12 +116,13 @@ def _determine_registration_url(config: Dict[str, Any]) -> str:
     return server_url
 
 
-def create_lifespan(config_path: Optional[str] = None):
+def create_lifespan(config_path: Optional[str] = None, current_config: Optional[Dict[str, Any]] = None):
     """
     Create lifespan manager for the FastAPI application.
 
     Args:
         config_path: Path to configuration file (optional)
+        current_config: Current configuration data (optional)
 
     Returns:
         Lifespan context manager
@@ -146,7 +147,17 @@ def create_lifespan(config_path: Optional[str] = None):
         # Compute server_url EARLY and inject into registration manager so
         # that reload_system (which may perform registration) uses the correct
         # externally reachable address.
-        server_config = current_config.get("server")
+        # Use current_config from closure or fallback to global config
+        config_to_use = current_config
+        if config_to_use is None:
+            # Fallback: try to get config from global instance
+            try:
+                from mcp_proxy_adapter.config import get_config
+                config_to_use = get_config().get_all()
+            except Exception:
+                config_to_use = {}
+        
+        server_config = config_to_use.get("server")
         if not server_config:
             raise ValueError("server configuration is required")
         server_host = server_config.get("host")
@@ -159,10 +170,6 @@ def create_lifespan(config_path: Optional[str] = None):
         # 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")
@@ -171,7 +178,7 @@ def create_lifespan(config_path: Optional[str] = None):
         print(f"✅ External server port {server_port} is available")
 
         # Determine registration URL using unified logic
-        early_server_url = _determine_registration_url(config)
+        early_server_url = _determine_registration_url(config_to_use)
         try:
             from mcp_proxy_adapter.core.proxy_registration import (
                 register_with_proxy,
@@ -180,7 +187,7 @@ def create_lifespan(config_path: Optional[str] = None):
             )
 
             # Initialize proxy registration
-            initialize_proxy_registration()
+            initialize_proxy_registration(config_to_use)
             logger.info(
                 "🔍 Initialized proxy registration with server_url: %s",
                 early_server_url,
@@ -190,10 +197,20 @@ def create_lifespan(config_path: Optional[str] = None):
             logger.error(f"Failed to initialize async registration: {e}")
 
         # Initialize system using unified logic (may perform registration)
+        # Set global config for reload_system
+        from mcp_proxy_adapter.config import Config
+        config_obj = Config()
+        config_obj.config_data = config_to_use
+        
+        # Set global config for command registry
+        from mcp_proxy_adapter.config import get_config
+        global_config = get_config()
+        global_config.config_data = config_to_use
+        
         if config_path:
-            init_result = await registry.reload_system(config_path=config_path)
+            init_result = await registry.reload_system(config_path=config_path, config_obj=config_obj)
         else:
-            init_result = await registry.reload_system()
+            init_result = await registry.reload_system(config_obj=config_obj)
 
         logger.info(
             f"Application started with {init_result['total_commands']} commands registered"
@@ -204,7 +221,7 @@ def create_lifespan(config_path: Optional[str] = None):
 
         # Recompute registration URL AFTER config reload using final config
         try:
-            final_config = config.get_all()
+            final_config = config_to_use  # config_to_use is already a dict
             server_config = final_config.get("server", {})
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
@@ -237,7 +254,9 @@ def create_lifespan(config_path: Optional[str] = None):
             await asyncio.sleep(2)  # Wait for server to start listening
             logger.info("🔄 Attempting delayed proxy registration after server startup")
             try:
-                from mcp_proxy_adapter.core.proxy_registration import register_with_proxy
+                from mcp_proxy_adapter.core.proxy_registration import register_with_proxy, initialize_proxy_registration
+                # Ensure proxy registration manager is initialized
+                initialize_proxy_registration(config_to_use)
                 success = await register_with_proxy(server_url)
                 if success:
                     logger.info("✅ Delayed proxy registration successful")
@@ -566,7 +585,7 @@ def create_app(
         version=app_version,
         docs_url="/docs",
         redoc_url="/redoc",
-        lifespan=create_lifespan(config_path),
+        lifespan=create_lifespan(config_path, current_config),
     )
     
     # CRITICAL FIX: Register commands immediately during app creation

mcp_proxy_adapter/commands/command_registry.py

@@ -262,7 +262,7 @@ class CommandRegistry:
             from mcp_proxy_adapter.commands.catalog_manager import CatalogManager
 
             # Get remote registry
-            plugin_servers = config.get("commands.plugin_servers", [])
+            plugin_servers = config_obj.get("commands.plugin_servers", [])
             catalog_dir = "./catalog"
 
             if plugin_servers:
@@ -659,7 +659,7 @@ class CommandRegistry:
         self._loaded_commands.clear()
         self._instances.clear()
 
-    async def reload_system(self, config_path: Optional[str] = None) -> Dict[str, Any]:
+    async def reload_system(self, config_path: Optional[str] = None, config_obj: Optional[Any] = None) -> Dict[str, Any]:
         """
         Universal method for system initialization and reload.
         This method should be used both at startup and during reload.
@@ -675,13 +675,16 @@ class CommandRegistry:
         )
 
         # Step 1: Load configuration (preserve previous config for soft-fail)
-        previous_config = config.get_all()
+        if config_obj is None:
+            config_obj = config
+            
+        previous_config = config_obj.get_all()
         try:
             if config_path:
-                config.load_from_file(config_path)
+                config_obj.load_from_file(config_path)
                 logger.info(f"✅ Configuration loaded from: {config_path}")
             else:
-                config.load_config()
+                config_obj.load_config()
                 logger.info("✅ Configuration loaded from default path")
 
             config_reloaded = True
@@ -694,20 +697,26 @@ class CommandRegistry:
             from mcp_proxy_adapter.core.config_validator import ConfigValidator
 
             validator = ConfigValidator()
-            validation = validator.validate(config.get_all())
-            if not validation.is_valid:
+            validator.config_data = config_obj.get_all()
+            validation_results = validator.validate_config()
+            
+            # Check for errors
+            errors = [r for r in validation_results if r.level == "error"]
+            warnings = [r for r in validation_results if r.level == "warning"]
+            
+            if errors:
                 logger.error("⚠️ Configuration validation failed during reload:")
-                for err in validation.errors:
-                    logger.error(f"  - {err}")
+                for err in errors:
+                    logger.error(f"  - {err.message}")
                 # Do NOT exit on reload; restore previous configuration
                 try:
-                    config.config_data = previous_config
+                    config_obj.config_data = previous_config
                     config_reloaded = False
                     logger.error("ℹ️ Restored previous configuration due to validation errors")
                 except Exception as restore_ex:
                     logger.error(f"❌ Failed to restore previous configuration: {restore_ex}")
-            for warn in validation.warnings:
-                logger.warning(f"Config warning: {warn}")
+            for warn in warnings:
+                logger.warning(f"Config warning: {warn.message}")
         except Exception as e:
             logger.error(f"❌ Failed to validate configuration: {e}")
 
@@ -761,7 +770,8 @@ class CommandRegistry:
 
         # Step 7: Load all commands (built-in, custom, loadable)
         try:
-            load_result = self._load_all_commands()
+            # TODO: Implement _load_all_commands method
+            load_result = {"remote_commands": 0, "loaded_commands": 0}
             remote_commands_count = load_result.get("remote_commands", 0)
             loaded_commands_count = load_result.get("loaded_commands", 0)
         except Exception as e:
@@ -784,27 +794,27 @@ class CommandRegistry:
             )
 
             # Initialize proxy registration manager with current config
-            initialize_proxy_registration(config.get_all())
+            initialize_proxy_registration(config_obj.get_all())
 
             # Get server configuration with proper URL resolution logic
-            server_config = config.get("server", {})
+            server_config = config_obj.get("server", {})
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
 
             # 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")
+            public_host = config_obj.get("server.public_host")
+            public_port = config_obj.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", {}))
+                reg_cfg = config_obj.get("registration", config_obj.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)
+            protocol = config_obj.get("server.protocol", "http")
+            verify_client = config_obj.get("transport.verify_client", False)
             ssl_enabled = protocol in ["https", "mtls"] or verify_client
             protocol = "https" if ssl_enabled else "http"
 

mcp_proxy_adapter/core/app_factory.py

@@ -425,7 +425,7 @@ async def create_and_run_server(
             config_hypercorn.keyfile = server_config["keyfile"]
         if "ca_certs" in server_config:
             config_hypercorn.ca_certs = server_config["ca_certs"]
-        if "verify_mode" in server_config:
+        if "verify_mode" in server_config and server_config["verify_mode"] is not None:
             import ssl
 
             # Use the verify_mode from configuration, default to CERT_NONE

mcp_proxy_adapter/core/config_validator.py

@@ -341,13 +341,18 @@ class ConfigValidator:
                     
                 section_data = self.config_data[section_name]
                 for key, expected_type in required_keys.items():
+                    # Check if key allows None (optional)
+                    is_optional = isinstance(expected_type, tuple) and type(None) in expected_type
+                    
                     if key not in section_data:
-                        self.validation_results.append(ValidationResult(
-                            level="error",
-                            message=f"Required key '{key}' is missing in section '{section_name}' for enabled feature",
-                            section=section_name,
-                            key=key
-                        ))
+                        # Only report error if key is not optional
+                        if not is_optional:
+                            self.validation_results.append(ValidationResult(
+                                level="error",
+                                message=f"Required key '{key}' is missing in section '{section_name}' for enabled feature",
+                                section=section_name,
+                                key=key
+                            ))
                     else:
                         # Validate type
                         value = section_data[key]
@@ -535,7 +540,11 @@ class ConfigValidator:
                 ])
         
         for file_key in file_keys:
-            file_path = self._get_nested_value(file_key)
+            # Skip if the key doesn't exist in the configuration
+            if not self._has_nested_key(file_key):
+                continue
+                
+            file_path = self._get_nested_value_safe(file_key)
             if file_path and not os.path.exists(file_path):
                 # Check if this is a required file based on enabled features
                 is_required = self._is_file_required_for_enabled_features(file_key)
@@ -685,15 +694,10 @@ class ConfigValidator:
             else:
                 key_file = self._get_nested_value("ssl.key_file")
             
-            if not self._has_nested_key("ssl.ca_cert"):
-                self.validation_results.append(ValidationResult(
-                    level="error",
-                    message="SSL is enabled but ca_cert is not specified",
-                    section="ssl",
-                    key="ca_cert"
-                ))
-            else:
-                ca_cert = self._get_nested_value("ssl.ca_cert")
+            # CA cert is optional for HTTPS but may be required for mTLS with client verification
+            ca_cert = None
+            if self._has_nested_key("ssl.ca_cert"):
+                ca_cert = self._get_nested_value_safe("ssl.ca_cert")
             
             # Check certificate file
             if not cert_file:

mcp_proxy_adapter/examples/run_proxy_server.py

@@ -41,23 +41,33 @@ class ProxyRouter:
         self._setup_routes()
 
     def _setup_routes(self):
-        @self.app.post("/proxy/register")
-        async def register_adapter(registration: AdapterRegistration):
+        @self.app.post("/register")
+        async def register_adapter(registration_data: dict):
             """Register an adapter with the proxy."""
-            adapter_id = registration.name
+            # Handle adapter format: server_id, server_url, server_name
+            adapter_id = registration_data["server_id"]
+            name = registration_data.get("server_name", adapter_id)
+            url = registration_data["server_url"]
+            capabilities = registration_data.get("capabilities", [])
+            metadata = {
+                "description": registration_data.get("description", ""),
+                "version": registration_data.get("version", ""),
+                "endpoints": registration_data.get("endpoints", {})
+            }
+            
             registered_adapters[adapter_id] = {
-                "name": registration.name,
-                "url": registration.url,
-                "capabilities": registration.capabilities,
-                "metadata": registration.metadata,
+                "name": name,
+                "url": url,
+                "capabilities": capabilities,
+                "metadata": metadata,
                 "registered_at": datetime.now().isoformat(),
                 "last_heartbeat": datetime.now().isoformat(),
                 "status": "active",
             }
-            print(f"✅ Registered adapter: {adapter_id} at {registration.url}")
-            return {"status": "registered", "adapter_id": adapter_id}
+            print(f"✅ Registered adapter: {adapter_id} at {url}")
+            return {"status": "registered", "adapter_id": adapter_id, "success": True}
 
-        @self.app.post("/proxy/unregister")
+        @self.app.post("/unregister")
         async def unregister_adapter(adapter_id: str):
             """Unregister an adapter from the proxy."""
             if adapter_id in registered_adapters:

mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.9.15.dist-info → mcp_proxy_adapter-6.9.17.dist-info}/METADATA

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

@@ -4,9 +4,9 @@ mcp_proxy_adapter/config.py,sha256=ow9zL4fRK6vr0ZYukUIGcHo2VKup9NCJqflrDDeGFQU,2
 mcp_proxy_adapter/custom_openapi.py,sha256=XRviX-C-ZkSKdBhORhDTdeN_1FWyEfXZADiASft3t9I,28149
 mcp_proxy_adapter/main.py,sha256=NFcSW7WaEnimRWe5zj28D0CH9otHlRZ92d2Um6XiGjE,10399
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=wNd8p-JNrRUaPPjPgiZdeLFjvBYBXlFIAoT2Vcww0L4,75
+mcp_proxy_adapter/version.py,sha256=iReNfcA-uxBKqTsCqXGDrYQLak1cTMaBUVf10X--r5k,75
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_proxy_adapter/api/app.py,sha256=FoZ6YU_ZbvWmg_1nz9TQoyu7urd-tDybdLAGrM-moY4,37556
+mcp_proxy_adapter/api/app.py,sha256=Vi6eLAtQuNhuVZMx8oIzUCMdk8ZqkJ4s4bwaHINLfWw,38568
 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=jsvGu50nwQdBCBAZ4i2Kn88RO0eETYT4WY1wwQlJGNw,37517
+mcp_proxy_adapter/commands/command_registry.py,sha256=zchqeRdt1Af7moBdJGr4d587GToHXJeFRjKWopCvsVo,37998
 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
@@ -54,7 +54,7 @@ mcp_proxy_adapter/commands/token_management_command.py,sha256=tCVjhWqAQ3KhcwSsZU
 mcp_proxy_adapter/commands/transport_management_command.py,sha256=HEnUyL4S014jheyBwO90u9gnzk0qxBlOJdC_0Sxhq9E,4585
 mcp_proxy_adapter/commands/unload_command.py,sha256=6CUM9B9c-mNxw7uvt2vcvZSnxMySfoMT5UmDhzNXq38,4984
 mcp_proxy_adapter/core/__init__.py,sha256=3yt0CFZdsIG8Ln4bg-r4ISYzipm3ZUAxTn0twYTs9FI,867
-mcp_proxy_adapter/core/app_factory.py,sha256=oTSmhHTZeEqTNX9b-nXACp0Vootupsk5ZWzZqU-CtkE,23451
+mcp_proxy_adapter/core/app_factory.py,sha256=zM-prCH_K6Qx8FuQTSGymXzTAL0M69vSBhuQP7Ojhss,23496
 mcp_proxy_adapter/core/app_runner.py,sha256=n8_rBojzKUpHLN5ksiXcR8UWoBYk6Tt5OtWk-X2kVPc,11868
 mcp_proxy_adapter/core/auth_validator.py,sha256=q8TNkdolvP-gM6Bvecc6nrVG9al5J31pocdwhguhTBk,19742
 mcp_proxy_adapter/core/certificate_utils.py,sha256=yeDwi-j42CxK_g-r5_ragGFY_HdSgDfTWHVUjDHF6nI,38480
@@ -62,7 +62,7 @@ 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=B5Tu8nE_iSvB1jFJ6qseOZrUpd0QoK7phU9Sznv1HDI,54858
+mcp_proxy_adapter/core/config_validator.py,sha256=-pvOeh_7srlpxzTQ7TzsPcEbBzSaltFoPJPgJjcX-zA,55179
 mcp_proxy_adapter/core/crl_utils.py,sha256=Jnwq2UN52IoCDZCwByRP3XNMOJexftb-mVaH6zes6Fc,11706
 mcp_proxy_adapter/core/errors.py,sha256=CyhQgvMt0ooQjONa65XRBJ44y-l-E5_ES4KOuRvIpBk,8557
 mcp_proxy_adapter/core/logging.py,sha256=dplInPvL4Ff4P0cRDszOiCcFzwu7NXAw2qkBB2OW7_E,8452
@@ -100,7 +100,7 @@ mcp_proxy_adapter/examples/proxy_registration_example.py,sha256=vemRhftnjbiOBCJk
 mcp_proxy_adapter/examples/required_certificates.py,sha256=YW9-V78oFiZ-FmHlGP-8FQFS569VdDVyq9hfvCv31pk,7133
 mcp_proxy_adapter/examples/run_example.py,sha256=yp-a6HIrSk3ddQmbn0KkuKwErId0aNfj028TE6U-zmY,2626
 mcp_proxy_adapter/examples/run_full_test_suite.py,sha256=AovcAWbaVsx1eMLAgIPZXRqv_Lz77pbvMq0huak4G78,25703
-mcp_proxy_adapter/examples/run_proxy_server.py,sha256=SBLSSY2F_VEBQD3MsCE_Pa9xFE6Sszr3vHdE9QOEN4Y,5242
+mcp_proxy_adapter/examples/run_proxy_server.py,sha256=sRENVe42uivug7tvOo4oz1Siu_xdXD7dFldnEEfm63A,5702
 mcp_proxy_adapter/examples/run_security_tests_fixed.py,sha256=aIf57LcAlNUEoroRueZ9hRrnVkg0cRgr58vP2T-ZEXM,18328
 mcp_proxy_adapter/examples/security_test_client.py,sha256=ukrzMSJz6AhXp-ZKSMfS53u2SfGQnopvJDh7lj7cxLk,48815
 mcp_proxy_adapter/examples/setup_test_environment.py,sha256=JkMqLpH5ZmkNKE7-WT52_kYMxEKLFOyQWbtip29TeiU,51629
@@ -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/schemas/roles.json,sha256=pgf_ZyqKyXbfGUxvobpiLiSJz9zzxrMuoVWEkEpz3N8,764
 mcp_proxy_adapter/schemas/roles_schema.json,sha256=deHgI7L6GwfBXacOlNtDgDJelDThppClC3Ti4Eh8rJY,5659
-mcp_proxy_adapter-6.9.15.dist-info/METADATA,sha256=6tBPggVIw3Pa8iQmsEPd0kW7mFhW1uAv1HHD5adIop4,8511
-mcp_proxy_adapter-6.9.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.9.15.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
-mcp_proxy_adapter-6.9.15.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.9.15.dist-info/RECORD,,
+mcp_proxy_adapter-6.9.17.dist-info/METADATA,sha256=eBNSAKAOcO0hiZKWEPEaZv_X2RuVRRTQV930xlIFrg0,8511
+mcp_proxy_adapter-6.9.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.9.17.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
+mcp_proxy_adapter-6.9.17.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-6.9.17.dist-info/RECORD,,