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

mcp_proxy_adapter/examples/test_framework_complete.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Complete framework testing with real MCP servers.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import json
+import subprocess
+import time
+import requests
+import ssl
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class FrameworkTester:
+    """Complete framework testing with real MCP servers."""
+    
+    def __init__(self):
+        self.project_root = Path(__file__).parent.parent.parent
+        self.configs_dir = self.project_root / "configs"
+        self.examples_dir = Path(__file__).parent
+        self.test_results = []
+        self.server_processes = []
+        
+    async def test_all_protocols(self):
+        """Test all protocols with real MCP server registration."""
+        logger.info("🧪 Starting Complete Framework Testing")
+        logger.info("=" * 60)
+        
+        # Test configurations
+        test_configs = [
+            ("http.json", "HTTP", 20000),
+            ("https.json", "HTTPS", 20003), 
+            ("mtls.json", "mTLS", 20006)
+        ]
+        
+        for config_file, protocol, port in test_configs:
+            logger.info(f"\n🔧 Testing {protocol} (port {port})")
+            logger.info("-" * 40)
+            
+            try:
+                # Start proxy adapter server
+                proxy_process = await self._start_proxy_server(config_file, port)
+                if not proxy_process:
+                    continue
+                
+                # Wait for server to start
+                await asyncio.sleep(2)
+                
+                # Test server registration
+                await self._test_server_registration(protocol, port)
+                
+                # Test MCP communication
+                await self._test_mcp_communication(protocol, port)
+                
+                # Test security features
+                await self._test_security_features(protocol, port)
+                
+                # Stop server
+                proxy_process.terminate()
+                await asyncio.sleep(1)
+                
+                logger.info(f"✅ {protocol} testing completed successfully")
+                
+            except Exception as e:
+                logger.error(f"❌ {protocol} testing failed: {e}")
+                self.test_results.append({
+                    "protocol": protocol,
+                    "status": "failed",
+                    "error": str(e)
+                })
+        
+        # Print summary
+        self._print_summary()
+    
+    async def _start_proxy_server(self, config_file: str, port: int) -> Optional[subprocess.Popen]:
+        """Start proxy adapter server."""
+        config_path = self.configs_dir / config_file
+        
+        if not config_path.exists():
+            logger.error(f"❌ Config file not found: {config_path}")
+            return None
+        
+        logger.info(f"🚀 Starting proxy server with {config_file}")
+        
+        try:
+            # Start server in background
+            process = subprocess.Popen([
+                "python", str(self.examples_dir / "main.py"),
+                "--config", str(config_path)
+            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            self.server_processes.append(process)
+            return process
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to start server: {e}")
+            return None
+    
+    async def _test_server_registration(self, protocol: str, port: int):
+        """Test MCP server registration."""
+        logger.info(f"📝 Testing server registration for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test registration endpoint
+        registration_data = {
+            "server_id": "test-mcp-server",
+            "server_url": "stdio://test-server",
+            "server_name": "Test MCP Server",
+            "description": "Test server for framework validation"
+        }
+        
+        try:
+            # Create SSL context for HTTPS/mTLS
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.post(
+                f"{base_url}/register",
+                json=registration_data,
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                logger.info("✅ Server registration successful")
+            else:
+                logger.warning(f"⚠️ Registration returned status {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"❌ Registration failed: {e}")
+            raise
+    
+    async def _test_mcp_communication(self, protocol: str, port: int):
+        """Test MCP communication through proxy."""
+        logger.info(f"🔗 Testing MCP communication for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test MCP JSON-RPC call
+        mcp_request = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "tools/list",
+            "params": {}
+        }
+        
+        try:
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.post(
+                f"{base_url}/mcp",
+                json=mcp_request,
+                headers={"Content-Type": "application/json"},
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if "result" in result:
+                    logger.info("✅ MCP communication successful")
+                else:
+                    logger.warning(f"⚠️ MCP response: {result}")
+            else:
+                logger.warning(f"⚠️ MCP call returned status {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"❌ MCP communication failed: {e}")
+            raise
+    
+    async def _test_security_features(self, protocol: str, port: int):
+        """Test security features."""
+        logger.info(f"🔒 Testing security features for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test without authentication
+        try:
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.get(
+                f"{base_url}/health",
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                logger.info("✅ Health check successful")
+            else:
+                logger.warning(f"⚠️ Health check returned status {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"❌ Security test failed: {e}")
+            raise
+    
+    def _print_summary(self):
+        """Print test summary."""
+        logger.info("\n" + "=" * 60)
+        logger.info("📊 FRAMEWORK TESTING SUMMARY")
+        logger.info("=" * 60)
+        
+        total_tests = len(self.test_results)
+        successful_tests = len([r for r in self.test_results if r["status"] == "success"])
+        
+        logger.info(f"Total tests: {total_tests}")
+        logger.info(f"Successful: {successful_tests}")
+        logger.info(f"Failed: {total_tests - successful_tests}")
+        
+        if total_tests > 0:
+            success_rate = (successful_tests / total_tests) * 100
+            logger.info(f"Success rate: {success_rate:.1f}%")
+            
+            if success_rate == 100:
+                logger.info("🎉 All tests passed! Framework is working correctly.")
+            elif success_rate >= 80:
+                logger.info("✅ Most tests passed. Framework is mostly functional.")
+            else:
+                logger.info("⚠️ Many tests failed. Framework needs attention.")
+        
+        logger.info("=" * 60)
+    
+    async def cleanup(self):
+        """Cleanup server processes."""
+        logger.info("🧹 Cleaning up server processes...")
+        
+        for process in self.server_processes:
+            try:
+                if process.poll() is None:  # Process is still running
+                    process.terminate()
+                    process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+            except Exception as e:
+                logger.warning(f"Warning: Failed to cleanup process: {e}")
+        
+        self.server_processes.clear()
+
+async def main():
+    """Main testing function."""
+    tester = FrameworkTester()
+    
+    try:
+        await tester.test_all_protocols()
+    finally:
+        await tester.cleanup()
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_proxy_adapter/examples/test_mcp_server.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Test MCP Server for framework validation.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import json
+import logging
+from typing import Any, Dict, List, Optional
+from mcp import types
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestMCPServer:
+    """Test MCP Server for framework validation."""
+    
+    def __init__(self):
+        self.server = Server("test-mcp-server")
+        self._setup_handlers()
+    
+    def _setup_handlers(self):
+        """Setup MCP server handlers."""
+        
+        @self.server.list_tools()
+        async def list_tools() -> List[types.Tool]:
+            """List available tools."""
+            return [
+                types.Tool(
+                    name="echo",
+                    description="Echo back the input message",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "message": {
+                                "type": "string",
+                                "description": "Message to echo back"
+                            }
+                        },
+                        "required": ["message"]
+                    }
+                ),
+                types.Tool(
+                    name="add",
+                    description="Add two numbers",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "a": {
+                                "type": "number",
+                                "description": "First number"
+                            },
+                            "b": {
+                                "type": "number", 
+                                "description": "Second number"
+                            }
+                        },
+                        "required": ["a", "b"]
+                    }
+                ),
+                types.Tool(
+                    name="get_info",
+                    description="Get server information",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {}
+                    }
+                )
+            ]
+        
+        @self.server.call_tool()
+        async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextContent]:
+            """Handle tool calls."""
+            logger.info(f"Tool called: {name} with args: {arguments}")
+            
+            if name == "echo":
+                message = arguments.get("message", "")
+                return [types.TextContent(type="text", text=f"Echo: {message}")]
+            
+            elif name == "add":
+                a = arguments.get("a", 0)
+                b = arguments.get("b", 0)
+                result = a + b
+                return [types.TextContent(type="text", text=f"Result: {a} + {b} = {result}")]
+            
+            elif name == "get_info":
+                info = {
+                    "server_name": "test-mcp-server",
+                    "version": "1.0.0",
+                    "status": "running",
+                    "tools_count": 3
+                }
+                return [types.TextContent(type="text", text=json.dumps(info, indent=2))]
+            
+            else:
+                return [types.TextContent(type="text", text=f"Unknown tool: {name}")]
+        
+        @self.server.list_resources()
+        async def list_resources() -> List[types.Resource]:
+            """List available resources."""
+            return [
+                types.Resource(
+                    uri="test://config",
+                    name="Server Configuration",
+                    description="Current server configuration",
+                    mimeType="application/json"
+                ),
+                types.Resource(
+                    uri="test://status",
+                    name="Server Status", 
+                    description="Current server status",
+                    mimeType="application/json"
+                )
+            ]
+        
+        @self.server.read_resource()
+        async def read_resource(uri: str) -> str:
+            """Read resource content."""
+            if uri == "test://config":
+                config = {
+                    "server_name": "test-mcp-server",
+                    "port": 3001,
+                    "protocol": "stdio",
+                    "features": ["tools", "resources"]
+                }
+                return json.dumps(config, indent=2)
+            
+            elif uri == "test://status":
+                status = {
+                    "status": "running",
+                    "uptime": "0s",
+                    "requests_handled": 0,
+                    "last_request": None
+                }
+                return json.dumps(status, indent=2)
+            
+            else:
+                raise ValueError(f"Unknown resource: {uri}")
+        
+        @self.server.list_prompts()
+        async def list_prompts() -> List[types.Prompt]:
+            """List available prompts."""
+            return [
+                types.Prompt(
+                    name="greeting",
+                    description="Generate a greeting message",
+                    arguments=[
+                        types.PromptArgument(
+                            name="name",
+                            description="Name to greet",
+                            required=True
+                        )
+                    ]
+                )
+            ]
+        
+        @self.server.get_prompt()
+        async def get_prompt(name: str, arguments: Dict[str, str]) -> List[types.TextContent]:
+            """Get prompt content."""
+            if name == "greeting":
+                user_name = arguments.get("name", "User")
+                greeting = f"Hello, {user_name}! Welcome to the test MCP server."
+                return [types.TextContent(type="text", text=greeting)]
+            
+            else:
+                raise ValueError(f"Unknown prompt: {name}")
+
+async def main():
+    """Main server function."""
+    logger.info("Starting Test MCP Server...")
+    
+    server_instance = TestMCPServer()
+    
+    async with stdio_server() as (read_stream, write_stream):
+        await server_instance.server.run(
+            read_stream,
+            write_stream,
+            server_instance.server.create_initialization_options()
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_proxy_adapter/main.py

@@ -61,30 +61,23 @@ def main():
 
     # Get protocol and SSL configuration
     protocol = config.get("server.protocol", "http")
-    ssl_enabled = protocol in ["https", "mtls"]
+    verify_client = config.get("transport.verify_client", False)
+    chk_hostname = config.get("transport.chk_hostname", False)
+    
+    # SSL enabled if protocol is HTTPS or mTLS (verify_client=True)
+    ssl_enabled = protocol in ["https", "mtls"] or verify_client
     
     # SSL configuration based on protocol
     ssl_cert_file = None
     ssl_key_file = None
     ssl_ca_cert = None
-    verify_client = False
     
     if ssl_enabled:
-        # Configure SSL based on protocol
-        if protocol == "https":
-            # HTTPS - server SSL only
-            ssl_cert_file = "../../certs/server.crt"
-            ssl_key_file = "../../certs/server.key"
-            ssl_ca_cert = "../../certs/localhost_server.crt"
-            verify_client = False
-
-        elif protocol == "mtls":
-            # mTLS - server SSL + client certificate verification
-            # Use server.crt and server.key for server, and localhost_server.crt as CA
-            ssl_cert_file = "../../certs/server.crt"
-            ssl_key_file = "../../certs/server.key"
-            ssl_ca_cert = "../../certs/localhost_server.crt"
-            verify_client = False  # Disable client cert verification for testing
+        # Configure SSL certificates - use 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")
 
     print("🔍 Debug config:")
     print(f"   protocol: {protocol}")
@@ -116,7 +109,7 @@ def main():
             "key_file": ssl_key_file,
             "ca_cert": ssl_ca_cert,
             "verify_client": verify_client,
-            "chk_hostname": config.get("transport.ssl.chk_hostname", True)
+            "chk_hostname": chk_hostname
         }
         
         hypercorn_ssl = ServerConfigAdapter.convert_ssl_config_for_engine(ssl_config, "hypercorn")

mcp_proxy_adapter/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.6.0
+Version: 6.6.3
 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.0.dist-info → mcp_proxy_adapter-6.6.3.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=NmwYJPfnAFWmGsOlyYkMDfuqA-SeduuvTSjZKJbzbKc,20424
+mcp_proxy_adapter/config.py,sha256=sYyqmWGCWSiFy4q0zdlkJKxz2IbNIbjCfEhqxdVvjbI,20157
 mcp_proxy_adapter/custom_openapi.py,sha256=XRviX-C-ZkSKdBhORhDTdeN_1FWyEfXZADiASft3t9I,28149
-mcp_proxy_adapter/main.py,sha256=I9fYgMD8_RNYuSHn-paeTSr9coAuVlEkfLaWeYbZors,5724
+mcp_proxy_adapter/main.py,sha256=E3K2vDnnZ44ODdSWDqAdaIG-55NIyYbcpxNGEQLQlPg,5461
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=3wn4ixEY89A5pJaACrT6Pg-UKLFQTHKOi6F0jL-TyDo,74
+mcp_proxy_adapter/version.py,sha256=2s9mmkrnxOAjp6hsHf5RXfk463sH55FUntKrzYuyXJY,74
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_proxy_adapter/api/app.py,sha256=cxjavhNTtaYg2ea-UeHSDnKh8edKVNQ2NbXUDYbufFU,34183
+mcp_proxy_adapter/api/app.py,sha256=chGxUMfWQXqn4wRC7Ar4X9uMF7JxI5EmQNVPEr0TQZI,34573
 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
@@ -75,7 +75,7 @@ mcp_proxy_adapter/core/role_utils.py,sha256=YwRenGoXI5YrHVbFjKFAH2DJs2miyqhcr9LW
 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
 mcp_proxy_adapter/core/security_integration.py,sha256=-5I4i9so_yMjc-zuGO-7zzIsMXemLvrch1q8WFVbIfg,14167
-mcp_proxy_adapter/core/server_adapter.py,sha256=-Tta9BzFCNO2TtdNmA8rd6ubzSGKiIoICpit_fczg1c,9748
+mcp_proxy_adapter/core/server_adapter.py,sha256=jz8ztIfe82N5DE3XHRYpD6CwNcJy7ksh0l8l-towHBE,9755
 mcp_proxy_adapter/core/server_engine.py,sha256=qmxdkBv-YsQsvxVVQ-_xiAyDshxtnrKBquPJoUjo2fw,9471
 mcp_proxy_adapter/core/settings.py,sha256=D6cF4R_5gJ0XFGxzXUIzeqe-_muu6HL561TAei9wwZ0,10521
 mcp_proxy_adapter/core/ssl_utils.py,sha256=Rjl79d5LdhDzxiMtaIRd9OFh0hTeRANItYFXk-7c5pA,9498
@@ -85,31 +85,30 @@ mcp_proxy_adapter/core/utils.py,sha256=wBdDYBDWQ6zbwrnl9tykHjo0FjJVsLT_x8Bjk1lZX
 mcp_proxy_adapter/examples/__init__.py,sha256=k1F-EotAFbJ3JvK_rNgiH4bUztmxIWtYn0AfbAZ1ZGs,450
 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/config_builder.py,sha256=kd3-donlGuDgZwJYsy_rjzrydBg_A1GaaJuJ8jj4VDc,9696
-mcp_proxy_adapter/examples/config_builder_simple.py,sha256=qTG3tIIu8eUW8gb06snaWHOTp0BFRRim38VqKrP2Ezo,9109
+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_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
 mcp_proxy_adapter/examples/debug_role_chain.py,sha256=GLVXC2fJUwP8UJnXHchd1t-H53cjWLJI3RqTPrKmaak,8750
 mcp_proxy_adapter/examples/demo_client.py,sha256=en2Rtb70B1sQmhL-vdQ4PDpKNNl_mfll2YCFT_jFCAg,10191
-mcp_proxy_adapter/examples/generate_all_certificates.py,sha256=lLP5RKmJwpSyprvrxQXFt_xcN4aiUzlIxk5WVdXx2Fk,19024
-mcp_proxy_adapter/examples/generate_certificates_bugfix.py,sha256=LskoIezj67PZqqrB8WgCO9bFPqPLRuNwUAt8I3bDT4o,15768
-mcp_proxy_adapter/examples/generate_certificates_cli.py,sha256=jb5bdNhoODL6qTWBdx4bNR9BVKo_lbzfWK91u5XuWXA,16986
-mcp_proxy_adapter/examples/generate_certificates_fixed.py,sha256=6zJj9xdEuwj-ZO2clMoB7pNj5hW4IgwK-qsLPzuq8VQ,12566
-mcp_proxy_adapter/examples/generate_certificates_framework.py,sha256=TGLyy4AJNI0w-Dd2FUQyX2sOXt05o_q4zkjoapzG1Wc,15017
-mcp_proxy_adapter/examples/generate_certificates_openssl.py,sha256=5V4B8Ys_-FZsDh-CH7BNf1XXkMtpidkm4iecY0XCFuE,16891
+mcp_proxy_adapter/examples/generate_certificates.py,sha256=cIfTHBziGiOTy9vldAmaULD6bXBpl2a5KfB8MLIRSww,16391
+mcp_proxy_adapter/examples/generate_config.py,sha256=hkjfCY7OdgMcqAJZH6I3JSKWI1VB64IEyT7RaokTb48,11461
 mcp_proxy_adapter/examples/proxy_registration_example.py,sha256=vemRhftnjbiOBCJkmtDGqlWQ8syTG0a8755GCOnaQsg,12503
 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=Zd7SINqi4UdiwDWaZrerh4e35XTqAUVApulEYtZx39M,25613
+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_security_tests_fixed.py,sha256=aIf57LcAlNUEoroRueZ9hRrnVkg0cRgr58vP2T-ZEXM,18328
-mcp_proxy_adapter/examples/security_test_client.py,sha256=HL0AhmmHZ9SHlUx6aJ32jTHJonjKmGil74ifLbsGkZA,48660
+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
 mcp_proxy_adapter/examples/simple_protocol_test.py,sha256=BzFUZvK9Fih3aG4IFLQTZPyPe_s6YjpZfB6uZmQ76rw,3969
+mcp_proxy_adapter/examples/test_chk_hostname_automated.py,sha256=nN0FEevzP6UP3q40zq4lw_GiT050FYomu7rWFPOMF2U,7002
 mcp_proxy_adapter/examples/test_config.py,sha256=ekEoUZe9q484vU_0IxOVhQdNMVJXG3IpmQpP--VmuDI,6491
 mcp_proxy_adapter/examples/test_config_builder.py,sha256=SAcWIC54vzO0mrb1L9xZKK2IhNkZuSx7_cMEkC1Lm60,21607
 mcp_proxy_adapter/examples/test_examples.py,sha256=CYlVatdHUVC_rwv4NsvxFG3GXiKIyxPDUH43BOJHjrU,12330
+mcp_proxy_adapter/examples/test_framework_complete.py,sha256=9EvJL9hgjYddzGTavjp7M7xlcO8SJvDvbobOHDxRHs8,9622
+mcp_proxy_adapter/examples/test_mcp_server.py,sha256=K4wol6H7gfviYuc8ygH4vhzc8mWsf-0xHyG6OJNaecU,6585
 mcp_proxy_adapter/examples/test_protocol_examples.py,sha256=yCZzZrJ9ICXMkF1bAMozpin2QeTMI653bggPAZTRAUE,12138
 mcp_proxy_adapter/examples/universal_client.py,sha256=n1-cBPOiCipA86Zcc_mI_jMywDMZS1p3u5JT3AqTsrQ,27577
 mcp_proxy_adapter/examples/update_config_certificates.py,sha256=ObGF5oNQ9OStryUvFDXxrN-olRMKdSOrl5KSwARF7EY,4608
@@ -131,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.0.dist-info/METADATA,sha256=WSvtaCv_mkqE20kqYWmmJSt_UkCUqmKi4w7vVSLweeo,8510
-mcp_proxy_adapter-6.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.6.0.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
-mcp_proxy_adapter-6.6.0.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.6.0.dist-info/RECORD,,
+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,,