mcp-proxy-adapter 6.9.27__py3-none-any.whl → 6.9.29__py3-none-any.whl

mcp_proxy_adapter/api/middleware/error_handling.py

@@ -3,7 +3,7 @@ Middleware for error handling.
 """
 
 import json
-from typing import Callable, Awaitable, Dict, Any, Optional
+from typing import Optional, Any
 
 from fastapi import Request, Response
 from starlette.responses import JSONResponse
@@ -31,132 +31,6 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         """
         super().__init__(app)
 
-    async def dispatch(
-        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
-    ) -> Response:
-        """
-        Processes request and catches errors.
-
-        Args:
-            request: Request.
-            call_next: Next handler.
-
-        Returns:
-            Response.
-        """
-        get_global_logger().debug(f"🔍 ErrorHandlingMiddleware.dispatch START - {request.method} {request.url.path}")
-        try:
-            # Call the next middleware or main handler
-            get_global_logger().debug(f"🔍 ErrorHandlingMiddleware - About to call next handler")
-            response = await call_next(request)
-            get_global_logger().debug(f"🔍 ErrorHandlingMiddleware - Next handler completed with status: {response.status_code}")
-            return response
-
-        except CommandError as e:
-            # Command error
-            request_id = getattr(request.state, "request_id", "unknown")
-            get_global_logger().debug(f"[{request_id}] Command error: {str(e)}")
-
-            # Проверяем, является ли запрос JSON-RPC
-            is_jsonrpc = self._is_json_rpc_request(request)
-
-            # Get JSON-RPC request ID if available
-            request_id_jsonrpc = await self._get_json_rpc_id(request)
-
-            # If request was JSON-RPC
-            if is_jsonrpc:
-                return JSONResponse(
-                    status_code=400,
-                    content={
-                        "jsonrpc": "2.0",
-                        "error": {
-                            "code": e.code,
-                            "message": str(e),
-                            "data": e.data if hasattr(e, "data") and e.data else None,
-                        },
-                        "id": request_id_jsonrpc,
-                    },
-                )
-
-            # Regular API error
-            return JSONResponse(status_code=400, content=e.to_dict())
-
-        except ValidationError as e:
-            # Validation error
-            request_id = getattr(request.state, "request_id", "unknown")
-            get_global_logger().debug(f"[{request_id}] Validation error: {str(e)}")
-
-            # Get JSON-RPC request ID if available
-            request_id_jsonrpc = await self._get_json_rpc_id(request)
-
-            # If request was JSON-RPC
-            if self._is_json_rpc_request(request):
-                return JSONResponse(
-                    status_code=400,
-                    content={
-                        "jsonrpc": "2.0",
-                        "error": {
-                            "code": -32602,
-                            "message": "Invalid params",
-                            "data": e.data if hasattr(e, "data") and e.data else None,
-                        },
-                        "id": request_id_jsonrpc,
-                    },
-                )
-
-            # Regular API error
-            return JSONResponse(status_code=400, content=e.to_dict())
-
-        except MicroserviceError as e:
-            # Other microservice error
-            request_id = getattr(request.state, "request_id", "unknown")
-            get_global_logger().debug(f"[{request_id}] Microservice error: {str(e)}")
-
-            # Get JSON-RPC request ID if available
-            request_id_jsonrpc = await self._get_json_rpc_id(request)
-
-            # If request was JSON-RPC
-            if self._is_json_rpc_request(request):
-                return JSONResponse(
-                    status_code=400,
-                    content={
-                        "jsonrpc": "2.0",
-                        "error": {
-                            "code": -32000,
-                            "message": str(e),
-                            "data": e.data if hasattr(e, "data") and e.data else None,
-                        },
-                        "id": request_id_jsonrpc,
-                    },
-                )
-
-            # Regular API error
-            return JSONResponse(status_code=400, content=e.to_dict())
-
-        except Exception as e:
-            # Unexpected error
-            request_id = getattr(request.state, "request_id", "unknown")
-            get_global_logger().debug(f"[{request_id}] Unexpected error: {str(e)}")
-
-            # Get JSON-RPC request ID if available
-            request_id_jsonrpc = await self._get_json_rpc_id(request)
-
-            # If request was JSON-RPC
-            if self._is_json_rpc_request(request):
-                return JSONResponse(
-                    status_code=500,
-                    content={
-                        "jsonrpc": "2.0",
-                        "error": {"code": -32603, "message": "Internal error"},
-                        "id": request_id_jsonrpc,
-                    },
-                )
-
-            # Regular API error
-            return JSONResponse(
-                status_code=500,
-                content={"error": {"code": 500, "message": "Internal server error"}},
-            )
 
     def _is_json_rpc_request(self, request: Request) -> bool:
         """

mcp_proxy_adapter/api/middleware/factory.py

@@ -125,37 +125,6 @@ class MiddlewareFactory:
             get_global_logger().error(f"Failed to create user info middleware: {e}")
             return None
 
-    def create_all_middleware(self) -> List[BaseMiddleware]:
-        """
-        Create all required middleware components.
-
-        Returns:
-            List of created middleware instances
-        """
-        middleware_list = []
-
-        # Create security middleware (unified)
-        security_middleware = self.create_security_middleware()
-        if security_middleware:
-            middleware_list.append(security_middleware)
-
-        # Create error handling middleware
-        error_middleware = self.create_error_handling_middleware()
-        if error_middleware:
-            middleware_list.append(error_middleware)
-
-        # Create logging middleware
-        logging_middleware = self.create_logging_middleware()
-        if logging_middleware:
-            middleware_list.append(logging_middleware)
-
-        # Create user info middleware
-        user_info_middleware = self.create_user_info_middleware()
-        if user_info_middleware:
-            middleware_list.append(user_info_middleware)
-
-        get_global_logger().info(f"Created {len(middleware_list)} middleware components")
-        return middleware_list
 
     def get_middleware_by_type(
         self, middleware_type: Type[BaseMiddleware]
@@ -174,68 +143,5 @@ class MiddlewareFactory:
                 return middleware
         return None
 
-    def get_security_middleware(self) -> Optional[UnifiedSecurityMiddleware]:
-        """
-        Get unified security middleware instance.
-
-        Returns:
-            UnifiedSecurityMiddleware instance or None if not found
-        """
-        return self.get_middleware_by_type(UnifiedSecurityMiddleware)
-
-    def validate_middleware_config(self) -> bool:
-        """
-        Validate middleware configuration.
-
-        Returns:
-            True if configuration is valid, False otherwise
-        """
-        try:
-            security_config = self.config.get("security", {})
-
-            # Validate security configuration
-            if not SecurityFactory.validate_config(self.config):
-                get_global_logger().error("Security configuration validation failed")
-                return False
-
-            # Validate middleware-specific configurations
-            if security_config.get("enabled", True):
-                # Check required fields for security middleware
-                auth_config = security_config.get("auth", {})
-                if not isinstance(auth_config, dict):
-                    get_global_logger().error("Auth configuration must be a dictionary")
-                    return False
-
-                ssl_config = security_config.get("ssl", {})
-                if not isinstance(ssl_config, dict):
-                    get_global_logger().error("SSL configuration must be a dictionary")
-                    return False
-
-            get_global_logger().info("Middleware configuration validation passed")
-            return True
-
-        except Exception as e:
-            get_global_logger().error(f"Middleware configuration validation failed: {e}")
-            return False
-
-    def get_middleware_info(self) -> Dict[str, Any]:
-        """
-        Get information about created middleware.
-
-        Returns:
-            Dictionary with middleware information
-        """
-        info = {
-            "total_middleware": len(self.middleware_stack),
-            "middleware_types": [],
-            "security_enabled": False,
-        }
-
-        for middleware in self.middleware_stack:
-            middleware_type = type(middleware).__name__
-            info["middleware_types"].append(middleware_type)
 
-            if isinstance(middleware, UnifiedSecurityMiddleware):
-                info["security_enabled"] = True
 
-        return info

mcp_proxy_adapter/api/middleware/logging.py

@@ -29,115 +29,3 @@ class LoggingMiddleware(BaseMiddleware):
         super().__init__(app)
         self.config = config or {}
 
-    async def dispatch(
-        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
-    ) -> Response:
-        """
-        Processes request and logs information about it.
-
-        Args:
-            request: Request.
-            call_next: Next handler.
-
-        Returns:
-            Response.
-        """
-        get_global_logger().debug(f"🔍 LoggingMiddleware.dispatch START - {request.method} {request.url.path}")
-        
-        # Generate unique ID for request
-        request_id = str(uuid.uuid4())
-        request.state.request_id = request_id
-        get_global_logger().debug(f"🔍 LoggingMiddleware - Generated request ID: {request_id}")
-
-        # Create context get_global_logger() for this request
-        req_logger = RequestLogger("mcp_proxy_adapter.api.middleware", request_id)
-
-        # Log request start
-        start_time = time.time()
-
-        # Request information
-        method = request.method
-        url = str(request.url)
-        client_host = request.client.host if request.client else "unknown"
-
-        # Check if this is an OpenAPI schema request (should be logged at DEBUG level)
-        is_openapi_request = "/openapi.json" in url
-
-        if is_openapi_request:
-            req_logger.debug(f"Request started: {method} {url} | Client: {client_host}")
-        else:
-            req_logger.info(f"Request started: {method} {url} | Client: {client_host}")
-
-        # Log request body if not GET or HEAD
-        if method not in ["GET", "HEAD"]:
-            try:
-                body = await request.body()
-                if body:
-                    # Try to parse JSON
-                    try:
-                        body_text = body.decode("utf-8")
-                        # Hide sensitive data (like passwords)
-                        body_json = json.loads(body_text)
-                        if isinstance(body_json, dict) and "params" in body_json:
-                            # Replace sensitive fields with "***"
-                            if isinstance(body_json["params"], dict):
-                                for sensitive_field in [
-                                    "password",
-                                    "token",
-                                    "secret",
-                                    "api_key",
-                                ]:
-                                    if sensitive_field in body_json["params"]:
-                                        body_json["params"][sensitive_field] = "***"
-
-                        req_logger.debug(f"Request body: {json.dumps(body_json)}")
-                    except json.JSONDecodeError:
-                        # If not JSON, log as is
-                        req_logger.debug(f"Request body: {body_text}")
-                    except Exception as e:
-                        req_logger.warning(f"Error logging request body: {str(e)}")
-            except Exception as e:
-                req_logger.warning(f"Error reading request body: {str(e)}")
-
-        # Call the next middleware or main handler
-        try:
-            get_global_logger().debug(f"🔍 LoggingMiddleware - About to call next handler")
-            response = await call_next(request)
-            get_global_logger().debug(f"🔍 LoggingMiddleware - Next handler completed with status: {response.status_code}")
-
-            # Log request completion
-            process_time = time.time() - start_time
-            status_code = response.status_code
-
-            if is_openapi_request:
-                req_logger.debug(
-                    f"Request completed: {method} {url} | Status: {status_code} | "
-                    f"Time: {process_time:.3f}s"
-                )
-            else:
-                req_logger.info(
-                    f"Request completed: {method} {url} | Status: {status_code} | "
-                    f"Time: {process_time:.3f}s"
-                )
-
-            # Add request ID to response headers
-            response.headers["X-Request-ID"] = request_id
-            response.headers["X-Process-Time"] = f"{process_time:.3f}s"
-
-            return response
-        except Exception as e:
-            # Log error
-            process_time = time.time() - start_time
-
-            if is_openapi_request:
-                req_logger.debug(
-                    f"Request failed: {method} {url} | Error: {str(e)} | "
-                    f"Time: {process_time:.3f}s"
-                )
-            else:
-                req_logger.error(
-                    f"Request failed: {method} {url} | Error: {str(e)} | "
-                    f"Time: {process_time:.3f}s"
-                )
-
-            raise

mcp_proxy_adapter/api/middleware/performance.py

@@ -29,41 +29,6 @@ class PerformanceMiddleware(BaseMiddleware):
         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:
-        """
-        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:
         """

mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -9,7 +9,7 @@ from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 
-from mcp_proxy_adapter.core.protocol_manager import get_protocol_manager
+from mcp_proxy_adapter.core.protocol_manager import ProtocolManager
 from mcp_proxy_adapter.core.logging import get_global_logger
 
 
@@ -64,75 +64,9 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
 
         self.app_config = normalized_config
         # Get protocol manager with current configuration
-        self.protocol_manager = get_protocol_manager(normalized_config)
+        self.protocol_manager = ProtocolManager(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"):
-            try:
-                self.app_config = new_config.get_all()
-            except Exception:
-                self.app_config = None
-        elif hasattr(new_config, "keys"):
-            self.app_config = new_config
-        else:
-            self.app_config = None
-        self.protocol_manager = get_protocol_manager(self.app_config)
-        get_global_logger().info("Protocol middleware configuration updated")
-
-    async def dispatch(self, request: Request, call_next: Callable) -> Response:
-        """
-        Process request through protocol middleware.
-
-        Args:
-            request: Incoming request
-            call_next: Next middleware/endpoint function
-
-        Returns:
-            Response object
-        """
-        get_global_logger().debug(f"ProtocolMiddleware processing {request.method} {request.url.path}")
-        
-        try:
-            # Get protocol from request
-            protocol = self._get_request_protocol(request)
-            get_global_logger().debug(f"Detected protocol: {protocol} for {request.method} {request.url.path}")
-
-            # Check if protocol is allowed
-            is_allowed = self.protocol_manager.is_protocol_allowed(protocol)
-            get_global_logger().debug(f"Protocol '{protocol}' allowed: {is_allowed}")
-            
-            if not is_allowed:
-                get_global_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(),
-                    },
-                )
-
-            # Continue processing
-            request.state.protocol = protocol
-            get_global_logger().debug(f"Protocol '{protocol}' added to request state")
-            
-            response = await call_next(request)
-            get_global_logger().debug(f"ProtocolMiddleware completed with status: {response.status_code}")
-            return response
-
-        except Exception as e:
-            get_global_logger().error(f"❌ PROTOCOL STEP ERROR: ProtocolMiddleware ERROR: {str(e)}", exc_info=True)
-            return JSONResponse(
-                status_code=500,
-                content={"error": "Protocol validation error", "message": str(e)},
-            )
 
     def _get_request_protocol(self, request: Request) -> str:
         """
@@ -204,33 +138,3 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
             return "http"
 
 
-def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
-    """
-    Setup protocol middleware for FastAPI application.
-
-    Args:
-        app: FastAPI application
-        app_config: Application configuration dictionary (optional)
-    """
-    # Check if protocol management is enabled
-    if app_config is None:
-        from mcp_proxy_adapter.config import config
-        app_config = config.get_all()
-
-    if hasattr(app_config, "get"):
-        protocols_config = app_config.get("protocols", {})
-        enabled = (
-            protocols_config.get("enabled", True)
-            if hasattr(protocols_config, "get")
-            else True
-        )
-    else:
-        enabled = True
-
-    if enabled:
-        # Create protocol middleware with current configuration
-        middleware = ProtocolMiddleware(app, app_config)
-        app.add_middleware(ProtocolMiddleware, app_config=app_config)
-        get_global_logger().info("Protocol middleware added to application")
-    else:
-        get_global_logger().info("Protocol management is disabled, skipping protocol middleware")

mcp_proxy_adapter/api/middleware/transport_middleware.py

@@ -27,43 +27,6 @@ class TransportMiddleware(BaseHTTPMiddleware):
         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"
-            )
-            get_global_logger().warning(f"Transport not allowed: {transport_type} for {request.url}")
-            return JSONResponse(
-                status_code=403,
-                content={
-                    "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),
-                },
-            )
-
-        # 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:
         """

mcp_proxy_adapter/api/middleware/unified_security.py

@@ -10,17 +10,15 @@ email: vasilyvz@gmail.com
 
 import time
 import logging
-from typing import Dict, Any, Optional, Callable, Awaitable
+from typing import Dict, Any, Callable, Awaitable
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 
 # Direct import from framework
 try:
-    from mcp_security_framework.middleware.fastapi_middleware import (
+    from mcp_security_framework.middleware import (
         FastAPISecurityMiddleware,
     )
-    from mcp_security_framework import SecurityManager
-    from mcp_security_framework.schemas.config import SecurityConfig
 
     SECURITY_FRAMEWORK_AVAILABLE = True
 except ImportError as e:
@@ -31,7 +29,7 @@ except ImportError as e:
     ) from e
 
 from mcp_proxy_adapter.core.logging import get_global_logger
-from mcp_proxy_adapter.core.security_integration import create_security_integration
+# from mcp_proxy_adapter.core.security_integration import create_security_integration
 
 
 class SecurityValidationError(Exception):
@@ -70,12 +68,14 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             security_enabled = security_config.get("enabled", False)
             
             if security_enabled:
-                self.security_integration = create_security_integration(security_config)
+                # self.security_integration = create_security_integration(security_config)
+                self.security_integration = None
                 # Use framework's FastAPI middleware
-                self.framework_middleware = (
-                    self.security_integration.security_manager.create_fastapi_middleware()
-                )
-                get_global_logger().info("Using mcp_security_framework FastAPI middleware")
+                # self.framework_middleware = (
+                #     self.security_integration.security_manager.create_fastapi_middleware()
+                # )
+                self.framework_middleware = None
+                get_global_logger().info("Security disabled - no middleware")
                 # IMPORTANT: Don't replace self.app! This breaks the middleware chain.
                 # Instead, store the framework middleware for use in dispatch method.
                 get_global_logger().info("Framework middleware will be used in dispatch method")