mcp-proxy-adapter 3.0.0__py3-none-any.whl → 3.0.2__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -0,0 +1,391 @@
+"""
+Module for FastAPI application setup.
+"""
+
+import json
+from typing import Any, Dict, List, Optional, Union
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Body, Depends, HTTPException, Request
+from fastapi.responses import JSONResponse, Response
+from fastapi.middleware.cors import CORSMiddleware
+
+from mcp_proxy_adapter.api.handlers import execute_command, handle_json_rpc, handle_batch_json_rpc, get_server_health, get_commands_list
+from mcp_proxy_adapter.api.middleware import setup_middleware
+from mcp_proxy_adapter.api.schemas import JsonRpcRequest, JsonRpcSuccessResponse, JsonRpcErrorResponse, HealthResponse, CommandListResponse, APIToolDescription
+from mcp_proxy_adapter.api.tools import get_tool_description, execute_tool
+from mcp_proxy_adapter.config import config
+from mcp_proxy_adapter.core.errors import MicroserviceError, NotFoundError
+from mcp_proxy_adapter.core.logging import logger, RequestLogger
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.custom_openapi import custom_openapi
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Lifespan manager for the FastAPI application. Handles startup and shutdown events.
+    """
+    # Startup events
+    from mcp_proxy_adapter.commands.command_registry import registry
+    from mcp_proxy_adapter.commands.help_command import HelpCommand
+    
+    # Register built-in commands (help should be registered first)
+    if not registry.command_exists("help"):
+        registry.register(HelpCommand)
+    
+    # Register other commands
+    registry.discover_commands()
+    
+    logger.info(f"Application started with {len(registry.get_all_commands())} commands registered")
+    
+    yield  # Application is running
+    
+    # Shutdown events
+    logger.info("Application shutting down")
+
+
+def create_app() -> FastAPI:
+    """
+    Creates and configures FastAPI application.
+
+    Returns:
+        Configured FastAPI application.
+    """
+    # Create application
+    app = FastAPI(
+        title="MCP Proxy Adapter",
+        description="JSON-RPC API for interacting with MCP Proxy",
+        version="1.0.0",
+        docs_url="/docs",
+        redoc_url="/redoc",
+        lifespan=lifespan,
+    )
+    
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # In production, specify concrete domains
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Setup middleware using the new middleware package
+    setup_middleware(app)
+    
+    # Use custom OpenAPI schema
+    app.openapi = lambda: custom_openapi(app)
+    
+    # Explicit endpoint for OpenAPI schema
+    @app.get("/openapi.json")
+    async def get_openapi_schema():
+        """
+        Returns optimized OpenAPI schema compatible with MCP-Proxy.
+        """
+        return custom_openapi(app)
+    
+    # JSON-RPC handler
+    @app.post("/api/jsonrpc", response_model=Union[JsonRpcSuccessResponse, JsonRpcErrorResponse, List[Union[JsonRpcSuccessResponse, JsonRpcErrorResponse]]])
+    async def jsonrpc_endpoint(request: Request, request_data: Union[Dict[str, Any], List[Dict[str, Any]]] = Body(...)):
+        """
+        Endpoint for handling JSON-RPC requests.
+        Supports both single and batch requests.
+        """
+        # Get request_id from middleware state
+        request_id = getattr(request.state, "request_id", None)
+        
+        # Create request logger for this endpoint
+        req_logger = RequestLogger(__name__, request_id) if request_id else logger
+        
+        # Check if it's a batch request
+        if isinstance(request_data, list):
+            # Process batch request
+            if len(request_data) == 0:
+                # Empty batch request is invalid
+                req_logger.warning("Invalid Request: Empty batch request")
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32600,
+                            "message": "Invalid Request. Empty batch request"
+                        },
+                        "id": None
+                    }
+                )
+            return await handle_batch_json_rpc(request_data, request)
+        else:
+            # Process single request
+            return await handle_json_rpc(request_data, request_id)
+    
+    # Command execution endpoint (/cmd)
+    @app.post("/cmd")
+    async def cmd_endpoint(request: Request, command_data: Dict[str, Any] = Body(...)):
+        """
+        Universal endpoint for executing commands.
+        Supports two formats:
+        1. CommandRequest:
+        {
+            "command": "command_name",
+            "params": {
+                // Command parameters
+            }
+        }
+        
+        2. JSON-RPC:
+        {
+            "jsonrpc": "2.0",
+            "method": "command_name",
+            "params": {
+                // Command parameters
+            },
+            "id": 123
+        }
+        """
+        # Get request_id from middleware state
+        request_id = getattr(request.state, "request_id", None)
+        
+        # Create request logger for this endpoint
+        req_logger = RequestLogger(__name__, request_id) if request_id else logger
+        
+        try:
+            # Determine request format (CommandRequest or JSON-RPC)
+            if "jsonrpc" in command_data and "method" in command_data:
+                # JSON-RPC format
+                return await handle_json_rpc(command_data, request_id)
+            
+            # CommandRequest format
+            if "command" not in command_data:
+                req_logger.warning("Missing required field 'command'")
+                return JSONResponse(
+                    status_code=200,
+                    content={
+                        "error": {
+                            "code": -32600,
+                            "message": "Отсутствует обязательное поле 'command'"
+                        }
+                    }
+                )
+            
+            command_name = command_data["command"]
+            params = command_data.get("params", {})
+            
+            req_logger.info(f"Executing command via /cmd: {command_name}, params: {params}")
+            
+            # Check if command exists
+            if not registry.command_exists(command_name):
+                req_logger.warning(f"Command '{command_name}' not found")
+                return JSONResponse(
+                    status_code=200,
+                    content={
+                        "error": {
+                            "code": -32601,
+                            "message": f"Команда '{command_name}' не найдена"
+                        }
+                    }
+                )
+            
+            # Execute command
+            try:
+                result = await execute_command(command_name, params, request_id)
+                return {"result": result}
+            except MicroserviceError as e:
+                # Handle command execution errors
+                req_logger.error(f"Error executing command '{command_name}': {str(e)}")
+                return JSONResponse(
+                    status_code=200,
+                    content={
+                        "error": e.to_dict()
+                    }
+                )
+            
+        except json.JSONDecodeError:
+            req_logger.error("JSON decode error")
+            return JSONResponse(
+                status_code=200,
+                content={
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error"
+                    }
+                }
+            )
+        except Exception as e:
+            req_logger.exception(f"Unexpected error: {str(e)}")
+            return JSONResponse(
+                status_code=200,
+                content={
+                    "error": {
+                        "code": -32603,
+                        "message": "Internal error",
+                        "data": {"details": str(e)}
+                    }
+                }
+            )
+    
+    # Direct command call
+    @app.post("/api/command/{command_name}")
+    async def command_endpoint(request: Request, command_name: str, params: Dict[str, Any] = Body(default={})):
+        """
+        Endpoint for direct command call.
+        """
+        # Get request_id from middleware state
+        request_id = getattr(request.state, "request_id", None)
+        
+        try:
+            result = await execute_command(command_name, params, request_id)
+            return result
+        except MicroserviceError as e:
+            return JSONResponse(
+                status_code=e.code,
+                content=e.to_dict()
+            )
+    
+    # Server health check
+    @app.get("/health", operation_id="health_check")
+    async def health_endpoint():
+        """
+        Проверить работоспособность сервиса.
+        
+        Возвращает информацию о состоянии сервиса.
+        """
+        # Получаем базовую информацию о здоровье сервера
+        health_data = await get_server_health()
+        
+        # Возвращаем информацию в формате, соответствующем схеме
+        return JSONResponse(content={
+            "status": "ok",
+            "model": "mcp-proxy-adapter",
+            "version": config.get("version", "1.0.0")
+        })
+    
+    # List of available commands
+    @app.get("/api/commands", response_model=CommandListResponse)
+    async def commands_list_endpoint():
+        """
+        Endpoint for getting list of available commands.
+        """
+        commands = await get_commands_list()
+        return {"commands": commands}
+    
+    # Get command information by name
+    @app.get("/api/commands/{command_name}")
+    async def command_info_endpoint(request: Request, command_name: str):
+        """
+        Endpoint for getting information about a specific command.
+        """
+        # Get request_id from middleware state
+        request_id = getattr(request.state, "request_id", None)
+        
+        # Create request logger for this endpoint
+        req_logger = RequestLogger(__name__, request_id) if request_id else logger
+        
+        try:
+            command_info = registry.get_command_info(command_name)
+            return command_info
+        except NotFoundError as e:
+            req_logger.warning(f"Command '{command_name}' not found")
+            return JSONResponse(
+                status_code=404,
+                content={
+                    "error": {
+                        "code": 404,
+                        "message": f"Command '{command_name}' not found"
+                    }
+                }
+            )
+    
+    # Get API tool description
+    @app.get("/api/tools/{tool_name}")
+    async def tool_description_endpoint(tool_name: str, format: Optional[str] = "json"):
+        """
+        Получить подробное описание инструмента API.
+        
+        Возвращает полное описание инструмента API с доступными командами,
+        их параметрами и примерами использования. Формат возвращаемых данных
+        может быть JSON или Markdown (text).
+        
+        Args:
+            tool_name: Имя инструмента API
+            format: Формат вывода (json, text, markdown, html)
+        """
+        try:
+            description = get_tool_description(tool_name, format)
+            
+            if format.lower() in ["text", "markdown", "html"]:
+                if format.lower() == "html":
+                    return Response(content=description, media_type="text/html")
+                else:
+                    return JSONResponse(
+                        content={"description": description},
+                        media_type="application/json"
+                    )
+            else:
+                return description
+                
+        except NotFoundError as e:
+            logger.warning(f"Tool not found: {tool_name}")
+            return JSONResponse(
+                status_code=404,
+                content={
+                    "error": {
+                        "code": 404,
+                        "message": str(e)
+                    }
+                }
+            )
+        except Exception as e:
+            logger.exception(f"Error generating tool description: {e}")
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "error": {
+                        "code": 500,
+                        "message": f"Error generating tool description: {str(e)}"
+                    }
+                }
+            )
+    
+    # Execute API tool
+    @app.post("/api/tools/{tool_name}")
+    async def execute_tool_endpoint(tool_name: str, params: Dict[str, Any] = Body(...)):
+        """
+        Выполнить инструмент API с указанными параметрами.
+        
+        Args:
+            tool_name: Имя инструмента API
+            params: Параметры инструмента
+        """
+        try:
+            result = await execute_tool(tool_name, **params)
+            return result
+        except NotFoundError as e:
+            logger.warning(f"Tool not found: {tool_name}")
+            return JSONResponse(
+                status_code=404,
+                content={
+                    "error": {
+                        "code": 404,
+                        "message": str(e)
+                    }
+                }
+            )
+        except Exception as e:
+            logger.exception(f"Error executing tool {tool_name}: {e}")
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "error": {
+                        "code": 500,
+                        "message": f"Error executing tool: {str(e)}"
+                    }
+                }
+            )
+    
+    return app
+
+
+# Create global application instance
+app = create_app()

mcp_proxy_adapter/api/handlers.py

@@ -0,0 +1,229 @@
+"""
+Module with API request handlers.
+"""
+
+import json
+import time
+from typing import Any, Dict, List, Optional, Union
+
+from fastapi import HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.errors import (
+    MicroserviceError, NotFoundError, ParseError, InvalidRequestError,
+    MethodNotFoundError, InvalidParamsError, InternalError, CommandError
+)
+from mcp_proxy_adapter.core.logging import logger, RequestLogger, get_logger
+
+
+async def execute_command(command_name: str, params: Dict[str, Any], request_id: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Executes a command with the specified name and parameters.
+
+    Args:
+        command_name: Command name.
+        params: Command parameters.
+        request_id: Optional request identifier for logging context.
+
+    Returns:
+        Command execution result.
+
+    Raises:
+        MethodNotFoundError: If command is not found.
+        MicroserviceError: In case of command execution error.
+    """
+    # Create request logger if request_id is provided
+    log = RequestLogger(__name__, request_id) if request_id else logger
+    
+    try:
+        # Get command class from registry
+        command_class = registry.get_command(command_name)
+        
+        # Execute command
+        start_time = time.time()
+        result = await command_class.run(**params)
+        execution_time = time.time() - start_time
+        
+        log.info(f"Command '{command_name}' executed in {execution_time:.3f} sec")
+        
+        # Return result
+        return result.to_dict()
+    except NotFoundError as e:
+        log.error(f"Command not found: {command_name}")
+        # Преобразуем в MethodNotFoundError для соответствия JSON-RPC
+        raise MethodNotFoundError(f"Method not found: {command_name}")
+    except Exception as e:
+        log.exception(f"Error executing command '{command_name}': {e}")
+        if isinstance(e, MicroserviceError):
+            raise e
+        # Все остальные ошибки оборачиваем в InternalError
+        raise InternalError(f"Error executing command: {str(e)}", data={"original_error": str(e)})
+
+
+async def handle_batch_json_rpc(batch_requests: List[Dict[str, Any]], request: Optional[Request] = None) -> List[Dict[str, Any]]:
+    """
+    Handles batch JSON-RPC requests.
+
+    Args:
+        batch_requests: List of JSON-RPC request data.
+        request: Original FastAPI request object.
+
+    Returns:
+        List of JSON-RPC responses.
+    """
+    responses = []
+    
+    # Get request_id from request state if available
+    request_id = getattr(request.state, "request_id", None) if request else None
+    
+    for request_data in batch_requests:
+        # Process each request in the batch
+        response = await handle_json_rpc(request_data, request_id)
+        responses.append(response)
+    
+    return responses
+
+
+async def handle_json_rpc(request_data: Dict[str, Any], request_id: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Handles JSON-RPC request.
+
+    Args:
+        request_data: JSON-RPC request data.
+        request_id: Optional request identifier for logging context.
+
+    Returns:
+        JSON-RPC response.
+    """
+    # Create request logger if request_id is provided
+    log = RequestLogger(__name__, request_id) if request_id else logger
+    
+    # Check JSON-RPC version
+    if request_data.get("jsonrpc") != "2.0":
+        return _create_error_response(
+            InvalidRequestError("Invalid Request. Expected jsonrpc: 2.0"),
+            request_data.get("id")
+        )
+    
+    # Get method and parameters
+    method = request_data.get("method")
+    params = request_data.get("params", {})
+    json_rpc_id = request_data.get("id")
+    
+    if not method:
+        return _create_error_response(
+            InvalidRequestError("Invalid Request. Method is required"),
+            json_rpc_id
+        )
+    
+    log.info(f"Executing JSON-RPC method: {method}")
+    
+    try:
+        # Execute command
+        result = await execute_command(method, params, request_id)
+        
+        # Form successful response
+        return {
+            "jsonrpc": "2.0",
+            "result": result,
+            "id": json_rpc_id
+        }
+    except MicroserviceError as e:
+        # Method execution error
+        log.error(f"Method execution error: {str(e)}")
+        return _create_error_response(e, json_rpc_id)
+    except Exception as e:
+        # Internal server error
+        log.exception(f"Unhandled error in JSON-RPC handler: {e}")
+        return _create_error_response(
+            InternalError("Internal error", data={"error": str(e)}),
+            json_rpc_id
+        )
+
+
+def _create_error_response(error: MicroserviceError, request_id: Any) -> Dict[str, Any]:
+    """
+    Creates JSON-RPC error response.
+
+    Args:
+        error: Error object.
+        request_id: Request ID from client.
+
+    Returns:
+        JSON-RPC error response dictionary.
+    """
+    return {
+        "jsonrpc": "2.0",
+        "error": error.to_dict(),
+        "id": request_id
+    }
+
+
+async def get_server_health() -> Dict[str, Any]:
+    """
+    Gets server health information.
+
+    Returns:
+        Dictionary with server health information.
+    """
+    import os
+    import platform
+    import sys
+    import psutil
+    from datetime import datetime
+    
+    # Get process start time
+    process = psutil.Process(os.getpid())
+    start_time = datetime.fromtimestamp(process.create_time())
+    uptime_seconds = (datetime.now() - start_time).total_seconds()
+    
+    # Get system information
+    memory_info = process.memory_info()
+    
+    return {
+        "status": "ok",
+        "version": "1.0.0",  # Should be replaced with actual version
+        "uptime": uptime_seconds,
+        "components": {
+            "system": {
+                "python_version": sys.version,
+                "platform": platform.platform(),
+                "cpu_count": os.cpu_count()
+            },
+            "process": {
+                "pid": os.getpid(),
+                "memory_usage_mb": memory_info.rss / (1024 * 1024),
+                "start_time": start_time.isoformat()
+            },
+            "commands": {
+                "registered_count": len(registry.get_all_commands())
+            }
+        }
+    }
+
+
+async def get_commands_list() -> Dict[str, Dict[str, Any]]:
+    """
+    Gets list of available commands.
+
+    Returns:
+        Dictionary with information about available commands.
+    """
+    result = {}
+    
+    # Get all registered commands
+    all_commands = registry.get_all_commands()
+    
+    for command_name, command_class in all_commands.items():
+        # Get schema information for the command
+        schema = command_class.get_schema()
+        
+        # Add to result
+        result[command_name] = {
+            "name": command_name,
+            "schema": schema,
+            "description": schema.get("description", "")
+        }
+    
+    return result

mcp_proxy_adapter/api/middleware/__init__.py

@@ -0,0 +1,49 @@
+"""
+Middleware package for API.
+This package contains middleware components for request processing.
+"""
+
+from fastapi import FastAPI
+
+from mcp_proxy_adapter.core.logging import logger
+from .base import BaseMiddleware
+from .logging import LoggingMiddleware
+from .error_handling import ErrorHandlingMiddleware
+from .auth import AuthMiddleware
+from .rate_limit import RateLimitMiddleware
+from .performance import PerformanceMiddleware
+
+def setup_middleware(app: FastAPI) -> None:
+    """
+    Sets up middleware for application.
+
+    Args:
+        app: FastAPI application instance.
+    """
+    # Add error handling middleware first (last to execute)
+    app.add_middleware(ErrorHandlingMiddleware)
+    
+    # Add logging middleware
+    app.add_middleware(LoggingMiddleware)
+    
+    # Add rate limiting middleware if configured
+    from mcp_proxy_adapter.config import config
+    if config.get("rate_limit_enabled", False):
+        app.add_middleware(
+            RateLimitMiddleware,
+            rate_limit=config.get("rate_limit", 100),
+            time_window=config.get("rate_limit_window", 60)
+        )
+    
+    # Добавляем authentication middleware с явным указанием auth_enabled
+    auth_enabled = config.get("auth_enabled", False)
+    app.add_middleware(
+        AuthMiddleware,
+        api_keys=config.get("api_keys", {}),
+        auth_enabled=auth_enabled
+    )
+
+    # Add performance middleware
+    app.add_middleware(PerformanceMiddleware)
+    
+    logger.info(f"Middleware setup completed. Auth enabled: {auth_enabled}")