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

mcp_proxy_adapter/core/errors.py

@@ -2,8 +2,8 @@
 Module for defining errors and exceptions for the microservice.
 """
 
-from typing import Any, Dict, List, Optional, Union
 from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
 
 
 class MicroserviceError(Exception):
@@ -33,20 +33,17 @@ class MicroserviceError(Exception):
         super().__init__(message)
 
     def to_dict(self) -> Dict[str, Any]:
-        """
-        Converts the error to a dictionary for JSON-RPC response.
-
-        Returns:
-            Dictionary with error information.
-        """
-        result = {"code": self.code, "message": self.message}
-
+        """Convert error to dictionary format."""
+        result = {
+            "code": self.code,
+            "message": self.message
+        }
         if self.data:
             result["data"] = self.data
-
         return result
 
 
+
 class ParseError(MicroserviceError):
     """
     Error while parsing JSON request.
@@ -199,23 +196,6 @@ class TimeoutError(MicroserviceError):
         super().__init__(message, code=-32003, data=data)
 
 
-def format_validation_errors(errors: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """
-    Formats validation errors into a standard format.
-
-    Args:
-        errors: List of validation errors.
-
-    Returns:
-        Formatted validation errors.
-    """
-    formatted_errors = {}
-    for error in errors:
-        loc = error.get("loc", [])
-        field = ".".join(str(item) for item in loc)
-        msg = error.get("msg", "Validation error")
-        formatted_errors[field] = msg
-    return formatted_errors
 
 
 @dataclass
@@ -242,21 +222,6 @@ class ConfigError(MicroserviceError):
         super().__init__(message, code=-32001, data={"type": "configuration_error"})
         self.validation_results = validation_results or []
     
-    def get_error_summary(self) -> str:
-        """Get summary of all validation errors."""
-        if not self.validation_results:
-            return self.message
-        
-        error_messages = []
-        for result in self.validation_results:
-            if result.level == "error":
-                location = f"{result.section}.{result.key}" if result.key else result.section
-                error_msg = f"[{location}] {result.message}"
-                if result.suggestion:
-                    error_msg += f" (Suggestion: {result.suggestion})"
-                error_messages.append(error_msg)
-        
-        return "\n".join(error_messages)
 
 
 class MissingConfigKeyError(ConfigError):

mcp_proxy_adapter/core/job_manager.py

@@ -0,0 +1,54 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple in-memory job manager for long-running demo commands.
+Not for production use.
+"""
+
+import asyncio
+import uuid
+from typing import Any, Dict, Optional, Awaitable
+
+
+class JobRecord:
+    def __init__(self, task: asyncio.Task):
+        self.task = task
+        self.status = "running"
+        self.result: Optional[Any] = None
+        self.error: Optional[str] = None
+
+
+_jobs: Dict[str, JobRecord] = {}
+
+
+def enqueue_coroutine(coro: Awaitable[Any]) -> str:
+    job_id = str(uuid.uuid4())
+    task = asyncio.create_task(_run_job(job_id, coro))
+    _jobs[job_id] = JobRecord(task)
+    return job_id
+
+
+async def _run_job(job_id: str, coro):
+    rec = _jobs[job_id]
+    try:
+        rec.result = await coro
+        rec.status = "completed"
+    except Exception as exc:  # noqa: BLE001
+        rec.error = str(exc)
+        rec.status = "failed"
+
+
+def get_job_status(job_id: str) -> Dict[str, Any]:
+    rec = _jobs.get(job_id)
+    if not rec:
+        return {"exists": False}
+    return {
+        "exists": True,
+        "status": rec.status,
+        "done": rec.task.done(),
+        "result": rec.result,
+        "error": rec.error,
+    }
+
+

mcp_proxy_adapter/core/logging.py

@@ -6,10 +6,8 @@ import logging
 import os
 import sys
 import uuid
-from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
-from typing import Dict, Optional, Any
-
-from mcp_proxy_adapter.config import get_config
+from logging.handlers import RotatingFileHandler
+from typing import Optional
 
 
 class CustomFormatter(logging.Formatter):
@@ -47,11 +45,6 @@ class RequestContextFilter(logging.Filter):
         super().__init__()
         self.request_id = request_id
 
-    def filter(self, record):
-        # Add request_id attribute to the record
-        record.request_id = self.request_id or "no-request-id"
-        return True
-
 
 class RequestLogger:
     """
@@ -245,19 +238,6 @@ def _parse_file_size(size_str) -> int:
         return int(size_str)
 
 
-def get_logger(name: str) -> logging.Logger:
-    """
-    Get a get_global_logger() with the specified name.
-
-    Args:
-        name: Logger name.
-
-    Returns:
-        Configured get_global_logger() instance.
-    """
-    return logging.getLogger(name)
-
-
 # Global get_global_logger() for use throughout the application
 # Initialize lazily to avoid import-time errors
 logger = None

mcp_proxy_adapter/core/mtls_asgi.py

@@ -8,9 +8,6 @@ client certificates in mTLS connections.
 import ssl
 import logging
 from typing import Dict, Any, Optional
-from starlette.applications import Starlette
-from starlette.requests import Request
-from starlette.responses import Response
 from starlette.types import ASGIApp, Receive, Send, Scope
 
 logger = logging.getLogger(__name__)
@@ -141,20 +138,3 @@ class MTLSASGIApp:
         await send({"type": "http.response.body", "body": body})
 
 
-def create_mtls_asgi_app(app: ASGIApp, ssl_config: Dict[str, Any]) -> ASGIApp:
-    """
-    Create MTLS-enabled ASGI application.
-
-    Args:
-        app: The underlying ASGI application (FastAPI)
-        ssl_config: SSL configuration for mTLS
-
-    Returns:
-        MTLS-enabled ASGI application
-    """
-    if ssl_config.get("mode") == "mtls" or ssl_config.get("verify_client", False):
-        get_global_logger().info("Creating MTLS-enabled ASGI application")
-        return MTLSASGIApp(app, ssl_config)
-    else:
-        get_global_logger().info("Creating standard ASGI application (no mTLS)")
-        return app

mcp_proxy_adapter/core/mtls_asgi_app.py

@@ -185,15 +185,3 @@ class MTLSASGIApp:
         await send({"type": "http.response.body", "body": body})
 
 
-def create_mtls_asgi_app(app, ssl_config: Dict[str, Any]):
-    """
-    Create MTLS ASGI application wrapper.
-
-    Args:
-        app: The underlying ASGI application
-        ssl_config: SSL configuration dictionary
-
-    Returns:
-        MTLS ASGI app wrapper
-    """
-    return MTLSASGIApp(app, ssl_config)

mcp_proxy_adapter/core/mtls_proxy.py

@@ -12,7 +12,6 @@ import asyncio
 import ssl
 import logging
 from typing import Optional, Dict, Any
-from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
@@ -79,39 +78,7 @@ class MTLSProxy:
             get_global_logger().error(f"❌ Failed to start mTLS proxy: {e}")
             raise
             
-    async def stop(self):
-        """Stop the mTLS proxy server."""
-        if self.server:
-            self.server.close()
-            await self.server.wait_closed()
-            get_global_logger().info("🔐 mTLS Proxy stopped")
             
-    async def _handle_client(self, reader, writer):
-        """Handle client connection."""
-        try:
-            # Get client address
-            client_addr = writer.get_extra_info('peername')
-            get_global_logger().info(f"🔐 mTLS connection from {client_addr}")
-            
-            # Connect to internal server
-            internal_reader, internal_writer = await asyncio.open_connection(
-                self.internal_host, self.internal_port
-            )
-            
-            # Create bidirectional proxy
-            await asyncio.gather(
-                self._proxy_data(reader, internal_writer, "client->server"),
-                self._proxy_data(internal_reader, writer, "server->client")
-            )
-            
-        except Exception as e:
-            get_global_logger().error(f"❌ Error handling client connection: {e}")
-        finally:
-            try:
-                writer.close()
-                await writer.wait_closed()
-            except:
-                pass
                 
     async def _proxy_data(self, reader, writer, direction):
         """Proxy data between reader and writer."""
@@ -132,50 +99,3 @@ class MTLSProxy:
                 pass
 
 
-async def start_mtls_proxy(config: Dict[str, Any]) -> Optional[MTLSProxy]:
-    """
-    Start mTLS proxy based on configuration.
-    
-    Args:
-        config: Application configuration
-        
-    Returns:
-        MTLSProxy instance if started, None otherwise
-    """
-    # Check if mTLS is enabled
-    protocol = config.get("server", {}).get("protocol", "http")
-    verify_client = config.get("transport", {}).get("verify_client", False)
-    
-    # Only start mTLS proxy if mTLS is explicitly enabled
-    if protocol != "mtls" and not verify_client:
-        get_global_logger().info("🌐 Regular mode: no mTLS proxy needed")
-        return None
-        
-    # Get configuration
-    server_config = config.get("server", {})
-    transport_config = config.get("transport", {})
-    
-    external_host = server_config.get("host", "0.0.0.0")
-    external_port = server_config.get("port", 8000)
-    internal_port = external_port + 1000  # Internal port
-    
-    cert_file = transport_config.get("cert_file")
-    key_file = transport_config.get("key_file")
-    ca_cert = transport_config.get("ca_cert")
-    
-    if not cert_file or not key_file:
-        get_global_logger().warning("⚠️  mTLS enabled but certificates not configured")
-        return None
-        
-    # Create and start proxy
-    proxy = MTLSProxy(
-        external_host=external_host,
-        external_port=external_port,
-        internal_port=internal_port,
-        cert_file=cert_file,
-        key_file=key_file,
-        ca_cert=ca_cert
-    )
-    
-    await proxy.start()
-    return proxy

mcp_proxy_adapter/core/mtls_server.py

@@ -24,84 +24,8 @@ class mTLSHandler(BaseHTTPRequestHandler):
         self.main_app = main_app
         super().__init__(*args, **kwargs)
 
-    def log_message(self, format, *args):
-        """Override to use our get_global_logger()."""
-        get_global_logger().info(f"mTLS Server: {format % args}")
 
-    def do_GET(self):
-        """Handle GET requests."""
-        try:
-            # Get client certificate
-            client_cert = None
-            if hasattr(self.connection, "getpeercert"):
-                client_cert = self.connection.getpeercert()
-
-            # Process request through main app if available
-            if self.main_app:
-                # Forward to main FastAPI app
-                response_data = self._forward_to_main_app(
-                    "GET", self.path, client_cert
-                )
-            else:
-                # Simple response
-                response_data = {
-                    "status": "ok",
-                    "message": "mTLS connection successful",
-                    "client_cert": client_cert,
-                    "path": self.path,
-                }
-
-            # Send response
-            self.send_response(200)
-            self.send_header("Content-type", "application/json")
-            self.end_headers()
-            self.wfile.write(json.dumps(response_data).encode())
 
-        except Exception as e:
-            get_global_logger().error(f"Error in mTLS GET handler: {e}")
-            self.send_error(500, str(e))
-
-    def do_POST(self):
-        """Handle POST requests."""
-        try:
-            # Get content length
-            content_length = int(self.headers.get("Content-Length", 0))
-
-            # Read request body
-            post_data = None
-            if content_length > 0:
-                post_data = self.rfile.read(content_length)
-
-            # Get client certificate
-            client_cert = None
-            if hasattr(self.connection, "getpeercert"):
-                client_cert = self.connection.getpeercert()
-
-            # Process request through main app if available
-            if self.main_app:
-                # Forward to main FastAPI app
-                response_data = self._forward_to_main_app(
-                    "POST", self.path, client_cert, post_data
-                )
-            else:
-                # Simple response
-                response_data = {
-                    "status": "ok",
-                    "message": "mTLS POST successful",
-                    "client_cert": client_cert,
-                    "path": self.path,
-                    "data_received": len(post_data) if post_data else 0,
-                }
-
-            # Send response
-            self.send_response(200)
-            self.send_header("Content-type", "application/json")
-            self.end_headers()
-            self.wfile.write(json.dumps(response_data).encode())
-
-        except Exception as e:
-            get_global_logger().error(f"Error in mTLS POST handler: {e}")
-            self.send_error(500, str(e))
 
     def _forward_to_main_app(
         self,
@@ -172,8 +96,6 @@ class mTLSServer:
     def _create_handler(self):
         """Create handler with main app reference."""
 
-        def handler(*args, **kwargs):
-            return mTLSHandler(*args, main_app=self.main_app, **kwargs)
 
         return handler
 
@@ -226,99 +148,7 @@ class mTLSServer:
             get_global_logger().error(f"Failed to start mTLS server: {e}")
             return False
 
-    def _run_server(self):
-        """Run the server (blocking)."""
-        try:
-            get_global_logger().info(
-                f"mTLS Server listening on https://{self.host}:{self.port}"
-            )
-            self.server.serve_forever()
-        except Exception as e:
-            get_global_logger().error(f"mTLS Server error: {e}")
-        finally:
-            self.running = False
-
-    def stop(self):
-        """Stop mTLS server."""
-        if self.server and self.running:
-            try:
-                self.server.shutdown()
-                self.server.server_close()
-                self.running = False
-                get_global_logger().info("✅ mTLS Server stopped")
-            except Exception as e:
-                get_global_logger().error(f"Error stopping mTLS server: {e}")
-
-    def is_running(self) -> bool:
-        """Check if server is running."""
-        return (
-            self.running
-            and self.server_thread
-            and self.server_thread.is_alive()
-        )
-
-
-def start_mtls_server_thread(
-    config: Dict[str, Any], main_app=None
-) -> Optional[mTLSServer]:
-    """
-    Start mTLS server in separate thread.
-
-    Args:
-        config: Configuration dictionary
-        main_app: Main FastAPI application
-
-    Returns:
-        mTLSServer instance or None if failed
-    """
-    try:
-        # Extract SSL configuration
-        ssl_config = config.get("ssl", {})
-
-        # Check if mTLS is enabled
-        verify_client = ssl_config.get("verify_client", False)
-        if not verify_client:
-            get_global_logger().info(
-                "mTLS not enabled (verify_client=False), skipping mTLS server"
-            )
-            return None
-
-        # Get server configuration
-        server_config = config.get("server", {})
-        host = server_config.get("host", "127.0.0.1")
-        preferred_port = ssl_config.get("mtls_port", 8443)  # Different port for mTLS
-        
-        # For internal servers (mTLS), find available port if preferred is occupied
-        from mcp_proxy_adapter.core.utils import find_port_for_internal_server
-        port = find_port_for_internal_server(host, preferred_port)
-
-        # Get certificate paths - all required for mTLS
-        cert_file = ssl_config.get("cert_file")
-        key_file = ssl_config.get("key_file")
-        ca_cert_file = ssl_config.get("ca_cert")
-        
-        if not cert_file or not key_file:
-            raise ValueError(
-                "mTLS server requires SSL certificate configuration. "
-                "Please configure 'ssl.cert_file' and 'ssl.key_file' in your configuration file."
-            )
 
-        # Create and start mTLS server
-        mtls_server = mTLSServer(
-            host=host,
-            port=port,
-            cert_file=cert_file,
-            key_file=key_file,
-            ca_cert_file=ca_cert_file,
-            main_app=main_app,
-        )
-
-        if mtls_server.start():
-            return mtls_server
-        else:
-            get_global_logger().error("Failed to start mTLS server")
-            return None
-
-    except Exception as e:
-        get_global_logger().error(f"Error starting mTLS server thread: {e}")
-        return None
+
+
+