mcp-proxy-adapter 6.3.3__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/api/middleware/performance.py

@@ -11,15 +11,16 @@ from fastapi import Request, Response
 from mcp_proxy_adapter.core.logging import logger
 from .base import BaseMiddleware
 
+
 class PerformanceMiddleware(BaseMiddleware):
     """
     Middleware for measuring performance.
     """
-    
+
     def __init__(self, app):
         """
         Initializes performance middleware.
-        
+
         Args:
             app: FastAPI application.
         """
@@ -27,47 +28,49 @@ class PerformanceMiddleware(BaseMiddleware):
         self.request_times: Dict[str, List[float]] = {}
         self.log_interval = 100  # Log statistics every 100 requests
         self.request_count = 0
-    
-    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+
+    async def dispatch(
+        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
+    ) -> Response:
         """
         Processes request and measures performance.
-        
+
         Args:
             request: Request.
             call_next: Next handler.
-            
+
         Returns:
             Response.
         """
         # Measure processing time
         start_time = time.time()
-        
+
         # Call the next middleware or main handler
         response = await call_next(request)
-        
+
         # Calculate processing time
         process_time = time.time() - start_time
-        
+
         # Save time in statistics
         path = request.url.path
         if path not in self.request_times:
             self.request_times[path] = []
-        
+
         self.request_times[path].append(process_time)
-        
+
         # Logging statistics
         self.request_count += 1
         if self.request_count % self.log_interval == 0:
             self._log_stats()
-        
+
         return response
-    
+
     def _log_stats(self) -> None:
         """
         Logs performance statistics.
         """
         logger.info("Performance statistics:")
-        
+
         for path, times in self.request_times.items():
             if len(times) > 1:
                 avg_time = statistics.mean(times)
@@ -75,9 +78,9 @@ class PerformanceMiddleware(BaseMiddleware):
                 max_time = max(times)
                 # Calculate 95th percentile
                 p95_time = sorted(times)[int(len(times) * 0.95)]
-                
+
                 logger.info(
                     f"Path: {path}, Requests: {len(times)}, "
                     f"Avg: {avg_time:.3f}s, Min: {min_time:.3f}s, "
                     f"Max: {max_time:.3f}s, p95: {p95_time:.3f}s"
-                ) 
+                )

mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -16,11 +16,11 @@ from mcp_proxy_adapter.core.logging import logger
 class ProtocolMiddleware(BaseHTTPMiddleware):
     """
     Middleware for protocol validation.
-    
+
     This middleware checks if the incoming request protocol is allowed
     based on the protocol configuration.
     """
-    
+
     def __init__(self, app, app_config: Optional[Dict[str, Any]] = None):
         """
         Initialize protocol middleware.
@@ -34,48 +34,58 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         normalized_config: Optional[Dict[str, Any]]
         if app_config is None:
             normalized_config = None
-        elif hasattr(app_config, 'get_all'):
+        elif hasattr(app_config, "get_all"):
             try:
                 normalized_config = app_config.get_all()
             except Exception as e:
-                logger.debug(f"ProtocolMiddleware - Error calling get_all(): {e}, type: {type(app_config)}")
+                logger.debug(
+                    f"ProtocolMiddleware - Error calling get_all(): {e}, type: {type(app_config)}"
+                )
                 normalized_config = None
-        elif hasattr(app_config, 'keys'):
+        elif hasattr(app_config, "keys"):
             normalized_config = app_config  # Already dict-like
         else:
-            logger.debug(f"ProtocolMiddleware - app_config is not dict-like, type: {type(app_config)}, value: {repr(app_config)}")
+            logger.debug(
+                f"ProtocolMiddleware - app_config is not dict-like, type: {type(app_config)}, value: {repr(app_config)}"
+            )
             normalized_config = None
 
-        logger.debug(f"ProtocolMiddleware - normalized_config type: {type(normalized_config)}")
+        logger.debug(
+            f"ProtocolMiddleware - normalized_config type: {type(normalized_config)}"
+        )
         if normalized_config:
-            logger.debug(f"ProtocolMiddleware - protocols in config: {'protocols' in normalized_config}")
-            if 'protocols' in normalized_config:
-                logger.debug(f"ProtocolMiddleware - protocols type: {type(normalized_config['protocols'])}")
+            logger.debug(
+                f"ProtocolMiddleware - protocols in config: {'protocols' in normalized_config}"
+            )
+            if "protocols" in normalized_config:
+                logger.debug(
+                    f"ProtocolMiddleware - protocols type: {type(normalized_config['protocols'])}"
+                )
 
         self.app_config = normalized_config
         # Get protocol manager with current configuration
         self.protocol_manager = get_protocol_manager(normalized_config)
-    
+
     def update_config(self, new_config: Dict[str, Any]):
         """
         Update configuration and reload protocol manager.
-        
+
         Args:
             new_config: New configuration dictionary
         """
         # Normalize new config
-        if hasattr(new_config, 'get_all'):
+        if hasattr(new_config, "get_all"):
             try:
                 self.app_config = new_config.get_all()
             except Exception:
                 self.app_config = None
-        elif hasattr(new_config, 'keys'):
+        elif hasattr(new_config, "keys"):
             self.app_config = new_config
         else:
             self.app_config = None
         self.protocol_manager = get_protocol_manager(self.app_config)
         logger.info("Protocol middleware configuration updated")
-    
+
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
         """
         Process request through protocol middleware.
@@ -87,76 +97,79 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Response object
         """
-        logger.debug(f"ProtocolMiddleware.dispatch called for {request.method} {request.url.path}")
+        logger.debug(
+            f"ProtocolMiddleware.dispatch called for {request.method} {request.url.path}"
+        )
         try:
             # Get protocol from request
             protocol = self._get_request_protocol(request)
-            
+
             # Check if protocol is allowed
             if not self.protocol_manager.is_protocol_allowed(protocol):
-                logger.warning(f"Protocol '{protocol}' not allowed for request to {request.url.path}")
+                logger.warning(
+                    f"Protocol '{protocol}' not allowed for request to {request.url.path}"
+                )
                 return JSONResponse(
                     status_code=403,
                     content={
                         "error": "Protocol not allowed",
                         "message": f"Protocol '{protocol}' is not allowed. Allowed protocols: {self.protocol_manager.get_allowed_protocols()}",
-                        "allowed_protocols": self.protocol_manager.get_allowed_protocols()
-                    }
+                        "allowed_protocols": self.protocol_manager.get_allowed_protocols(),
+                    },
                 )
-            
+
             # Continue processing
             response = await call_next(request)
             return response
-            
+
         except Exception as e:
             logger.error(f"Protocol middleware error: {e}")
             return JSONResponse(
                 status_code=500,
-                content={
-                    "error": "Protocol validation error",
-                    "message": str(e)
-                }
+                content={"error": "Protocol validation error", "message": str(e)},
             )
-    
+
     def _get_request_protocol(self, request: Request) -> str:
         """
         Extract protocol from request.
-        
+
         Args:
             request: FastAPI request object
-            
+
         Returns:
             Protocol name (http, https, mtls)
         """
         # Check if request is secure (HTTPS)
         if request.url.scheme:
             scheme = request.url.scheme.lower()
-            
+
             # If HTTPS, check if client certificate is provided (MTLS)
             if scheme == "https":
                 # Check for client certificate in headers or SSL context
-                if hasattr(request, 'scope') and 'ssl' in request.scope:
-                    ssl_context = request.scope.get('ssl')
-                    if ssl_context and hasattr(ssl_context, 'getpeercert'):
+                if hasattr(request, "scope") and "ssl" in request.scope:
+                    ssl_context = request.scope.get("ssl")
+                    if ssl_context and hasattr(ssl_context, "getpeercert"):
                         try:
                             cert = ssl_context.getpeercert()
                             if cert:
                                 return "mtls"
                         except:
                             pass
-                
+
                 # Check for client certificate in headers
-                if request.headers.get("ssl-client-cert") or request.headers.get("x-client-cert"):
+                if request.headers.get("ssl-client-cert") or request.headers.get(
+                    "x-client-cert"
+                ):
                     return "mtls"
-                
+
                 return "https"
-            
+
             return scheme
-        
+
         # Fallback to checking headers
         if request.headers.get("x-forwarded-proto"):
             return request.headers.get("x-forwarded-proto").lower()
-        
+
         # Default to HTTP
         return "http"
 
@@ -174,28 +187,45 @@ def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
     # Check if protocol management is enabled
     if app_config is None:
         from mcp_proxy_adapter.config import config
-        app_config = config.get_all()
-        logger.debug(f"setup_protocol_middleware - loaded from global config, type: {type(app_config)}")
-
-    logger.debug(f"setup_protocol_middleware - final app_config type: {type(app_config)}")
 
-    if hasattr(app_config, 'get'):
-        logger.debug(f"setup_protocol_middleware - app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}")
+        app_config = config.get_all()
+        logger.debug(
+            f"setup_protocol_middleware - loaded from global config, type: {type(app_config)}"
+        )
+
+    logger.debug(
+        f"setup_protocol_middleware - final app_config type: {type(app_config)}"
+    )
+
+    if hasattr(app_config, "get"):
+        logger.debug(
+            f"setup_protocol_middleware - app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}"
+        )
         protocols_config = app_config.get("protocols", {})
-        logger.debug(f"setup_protocol_middleware - protocols_config type: {type(protocols_config)}")
-        enabled = protocols_config.get("enabled", True) if hasattr(protocols_config, 'get') else True
+        logger.debug(
+            f"setup_protocol_middleware - protocols_config type: {type(protocols_config)}"
+        )
+        enabled = (
+            protocols_config.get("enabled", True)
+            if hasattr(protocols_config, "get")
+            else True
+        )
     else:
-        logger.debug(f"setup_protocol_middleware - app_config is not dict-like: {repr(app_config)}")
+        logger.debug(
+            f"setup_protocol_middleware - app_config is not dict-like: {repr(app_config)}"
+        )
         enabled = True
 
     logger.debug(f"setup_protocol_middleware - protocol management enabled: {enabled}")
 
     if enabled:
         # Create protocol middleware with current configuration
-        logger.debug(f"setup_protocol_middleware - creating ProtocolMiddleware with config type: {type(app_config)}")
+        logger.debug(
+            f"setup_protocol_middleware - creating ProtocolMiddleware with config type: {type(app_config)}"
+        )
         middleware = ProtocolMiddleware(app, app_config)
         logger.debug(f"setup_protocol_middleware - adding middleware to app")
         app.add_middleware(ProtocolMiddleware, app_config=app_config)
         logger.info("Protocol middleware added to application")
     else:
-        logger.info("Protocol management is disabled, skipping protocol middleware") 
+        logger.info("Protocol management is disabled, skipping protocol middleware")

mcp_proxy_adapter/api/middleware/transport_middleware.py

@@ -15,36 +15,38 @@ from mcp_proxy_adapter.core.logging import logger
 
 class TransportMiddleware(BaseHTTPMiddleware):
     """Middleware for transport validation."""
-    
+
     def __init__(self, app, transport_manager_instance=None):
         """
         Initialize transport middleware.
-        
+
         Args:
             app: FastAPI application
             transport_manager_instance: Transport manager instance (optional)
         """
         super().__init__(app)
         self.transport_manager = transport_manager_instance or transport_manager
-    
+
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
         """
         Process request through transport middleware.
-        
+
         Args:
             request: Incoming request
             call_next: Next middleware/endpoint
-            
+
         Returns:
             Response from next middleware/endpoint or error response
         """
         # Determine transport type from request
         transport_type = self._get_request_transport_type(request)
-        
+
         # Check if request matches configured transport
         if not self._is_transport_allowed(transport_type):
             configured_type = self.transport_manager.get_transport_type()
-            configured_type_str = configured_type.value if configured_type else "not configured"
+            configured_type_str = (
+                configured_type.value if configured_type else "not configured"
+            )
             logger.warning(f"Transport not allowed: {transport_type} for {request.url}")
             return JSONResponse(
                 status_code=403,
@@ -52,24 +54,24 @@ class TransportMiddleware(BaseHTTPMiddleware):
                     "error": "Transport not allowed",
                     "message": f"Transport '{transport_type}' is not allowed. Configured transport: {configured_type_str}",
                     "configured_transport": configured_type_str,
-                    "request_url": str(request.url)
-                }
+                    "request_url": str(request.url),
+                },
             )
-        
+
         # Add transport info to request state
         request.state.transport_type = transport_type
         request.state.transport_allowed = True
-        
+
         response = await call_next(request)
         return response
-    
+
     def _get_request_transport_type(self, request: Request) -> str:
         """
         Determine transport type from request.
-        
+
         Args:
             request: Incoming request
-            
+
         Returns:
             Transport type string
         """
@@ -79,14 +81,14 @@ class TransportMiddleware(BaseHTTPMiddleware):
                 return "mtls"
             return "https"
         return "http"
-    
+
     def _has_client_certificate(self, request: Request) -> bool:
         """
         Check if request has client certificate.
-        
+
         Args:
             request: Incoming request
-            
+
         Returns:
             True if client certificate is present, False otherwise
         """
@@ -95,22 +97,22 @@ class TransportMiddleware(BaseHTTPMiddleware):
         client_cert_header = request.headers.get("ssl-client-cert")
         if client_cert_header:
             return True
-        
+
         # Check if request has SSL client certificate context
         if hasattr(request, "client") and request.client:
             # In a real implementation, you would check the SSL context
             # For now, we'll assume HTTPS with client cert is MTLS
             return self.transport_manager.is_mtls()
-        
+
         return False
-    
+
     def _is_transport_allowed(self, transport_type: str) -> bool:
         """
         Check if transport type is allowed.
-        
+
         Args:
             transport_type: Transport type to check
-            
+
         Returns:
             True if transport is allowed, False otherwise
         """
@@ -118,5 +120,5 @@ class TransportMiddleware(BaseHTTPMiddleware):
         if not configured_type:
             logger.error("Transport not configured")
             return False
-        
-        return transport_type == configured_type.value 
+
+        return transport_type == configured_type.value