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

mcp_proxy_adapter/api/middleware/rate_limit.py

@@ -0,0 +1,152 @@
+"""
+Middleware for rate limiting.
+"""
+
+import time
+from typing import Dict, List, Callable, Awaitable
+from collections import defaultdict
+
+from fastapi import Request, Response
+from starlette.responses import JSONResponse
+
+from mcp_proxy_adapter.core.logging import logger
+from .base import BaseMiddleware
+
+class RateLimitMiddleware(BaseMiddleware):
+    """
+    Middleware for limiting request rate.
+    """
+    
+    def __init__(self, app, rate_limit: int = 100, time_window: int = 60, 
+                 by_ip: bool = True, by_user: bool = True,
+                 public_paths: List[str] = None):
+        """
+        Initializes middleware for rate limiting.
+        
+        Args:
+            app: FastAPI application
+            rate_limit: Maximum number of requests in the specified time period
+            time_window: Time period in seconds
+            by_ip: Limit requests by IP address
+            by_user: Limit requests by user
+            public_paths: List of paths for which rate limiting is not applied
+        """
+        super().__init__(app)
+        self.rate_limit = rate_limit
+        self.time_window = time_window
+        self.by_ip = by_ip
+        self.by_user = by_user
+        self.public_paths = public_paths or [
+            "/docs", 
+            "/redoc", 
+            "/openapi.json", 
+            "/health"
+        ]
+        
+        # Storage for requests by IP
+        self.ip_requests = defaultdict(list)
+        
+        # Storage for requests by user
+        self.user_requests = defaultdict(list)
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Processes request and checks rate limit.
+        
+        Args:
+            request: Request.
+            call_next: Next handler.
+            
+        Returns:
+            Response.
+        """
+        # Check if path is public
+        path = request.url.path
+        if self._is_public_path(path):
+            # If path is public, skip rate limiting
+            return await call_next(request)
+        
+        # Current time
+        current_time = time.time()
+        
+        # Get client IP address
+        client_ip = request.client.host if request.client else "unknown"
+        
+        # Get user from request state (if any)
+        username = getattr(request.state, "username", None)
+        
+        # Check limit by IP
+        if self.by_ip and client_ip != "unknown":
+            # Clean old requests
+            self._clean_old_requests(self.ip_requests[client_ip], current_time)
+            
+            # Check number of requests
+            if len(self.ip_requests[client_ip]) >= self.rate_limit:
+                logger.warning(f"Rate limit exceeded for IP: {client_ip} | Path: {path}")
+                return self._create_error_response("Rate limit exceeded", 429)
+            
+            # Add current request
+            self.ip_requests[client_ip].append(current_time)
+        
+        # Check limit by user
+        if self.by_user and username:
+            # Clean old requests
+            self._clean_old_requests(self.user_requests[username], current_time)
+            
+            # Check number of requests
+            if len(self.user_requests[username]) >= self.rate_limit:
+                logger.warning(f"Rate limit exceeded for user: {username} | Path: {path}")
+                return self._create_error_response("Rate limit exceeded", 429)
+            
+            # Add current request
+            self.user_requests[username].append(current_time)
+        
+        # Call the next middleware or main handler
+        return await call_next(request)
+    
+    def _clean_old_requests(self, requests: List[float], current_time: float) -> None:
+        """
+        Cleans old requests that are outside the time window.
+        
+        Args:
+            requests: List of request timestamps.
+            current_time: Current time.
+        """
+        min_time = current_time - self.time_window
+        while requests and requests[0] < min_time:
+            requests.pop(0)
+    
+    def _is_public_path(self, path: str) -> bool:
+        """
+        Checks if the path is public.
+        
+        Args:
+            path: Path to check.
+            
+        Returns:
+            True if path is public, False otherwise.
+        """
+        return any(path.startswith(public_path) for public_path in self.public_paths)
+    
+    def _create_error_response(self, message: str, status_code: int) -> Response:
+        """
+        Creates error response in JSON-RPC format.
+        
+        Args:
+            message: Error message.
+            status_code: HTTP status code.
+            
+        Returns:
+            JSON response with error.
+        """
+        return JSONResponse(
+            status_code=status_code,
+            content={
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32000,
+                    "message": message
+                },
+                "id": None
+            }
+        ) 

mcp_proxy_adapter/api/schemas.py

@@ -0,0 +1,305 @@
+"""
+Module with API schema definitions.
+"""
+
+from typing import Any, Dict, List, Optional, Union, Literal
+
+from pydantic import BaseModel, Field
+
+
+class ErrorResponse(BaseModel):
+    """
+    Error response model.
+    """
+    code: int = Field(..., description="Error code")
+    message: str = Field(..., description="Error message")
+    details: Optional[Dict[str, Any]] = Field(None, description="Additional error details")
+
+
+class ErrorWrapper(BaseModel):
+    """
+    Wrapper for error response.
+    """
+    error: ErrorResponse
+
+
+class JsonRpcRequest(BaseModel):
+    """
+    JSON-RPC request model.
+    """
+    jsonrpc: Literal["2.0"] = Field("2.0", description="JSON-RPC version")
+    method: str = Field(..., description="Method name")
+    params: Optional[Union[Dict[str, Any], List[Any]]] = Field(None, description="Method parameters")
+    id: Optional[Union[str, int]] = Field(None, description="Request ID")
+
+
+class JsonRpcError(BaseModel):
+    """
+    JSON-RPC error model.
+    """
+    code: int = Field(..., description="Error code")
+    message: str = Field(..., description="Error message")
+    data: Optional[Dict[str, Any]] = Field(None, description="Additional error data")
+
+
+class JsonRpcSuccessResponse(BaseModel):
+    """
+    JSON-RPC success response model.
+    """
+    jsonrpc: Literal["2.0"] = Field("2.0", description="JSON-RPC version")
+    result: Dict[str, Any] = Field(..., description="Method result")
+    id: Optional[Union[str, int]] = Field(None, description="Request ID")
+
+
+class JsonRpcErrorResponse(BaseModel):
+    """
+    JSON-RPC error response model.
+    """
+    jsonrpc: Literal["2.0"] = Field("2.0", description="JSON-RPC version")
+    error: JsonRpcError = Field(..., description="Error information")
+    id: Optional[Union[str, int]] = Field(None, description="Request ID")
+
+
+class CommandResponse(BaseModel):
+    """
+    Command response model.
+    """
+    success: bool = Field(..., description="Command execution success flag")
+    data: Optional[Dict[str, Any]] = Field(None, description="Result data")
+    message: Optional[str] = Field(None, description="Result message")
+    error: Optional[ErrorResponse] = Field(None, description="Error information")
+
+
+class HealthResponse(BaseModel):
+    """
+    Health response model.
+    """
+    status: str = Field(..., description="Server status")
+    version: str = Field(..., description="Server version")
+    uptime: float = Field(..., description="Server uptime in seconds")
+    components: Dict[str, Any] = Field(..., description="Components health")
+
+
+class CommandListResponse(BaseModel):
+    """
+    Command list response model.
+    """
+    commands: Dict[str, Dict[str, Any]] = Field(..., description="Available commands")
+
+
+class CommandRequest(BaseModel):
+    """
+    Command request model for /cmd endpoint.
+    """
+    command: str = Field(..., description="Command name to execute")
+    params: Optional[Dict[str, Any]] = Field({}, description="Command parameters")
+
+
+class CommandSuccessResponse(BaseModel):
+    """
+    Command success response model for /cmd endpoint.
+    """
+    result: Dict[str, Any] = Field(..., description="Command execution result")
+
+
+class CommandErrorResponse(BaseModel):
+    """
+    Command error response model for /cmd endpoint.
+    """
+    error: JsonRpcError = Field(..., description="Error information")
+
+
+class APIToolDescription:
+    """
+    Генератор описаний для инструментов API на основе метаданных команд.
+    
+    Класс предоставляет функциональность для создания подробных и понятных
+    описаний инструментов API, которые помогают пользователям сразу понять
+    как использовать API.
+    """
+    
+    @classmethod
+    def generate_tool_description(cls, name: str, registry) -> Dict[str, Any]:
+        """
+        Генерирует подробное описание инструмента API на основе имени и реестра команд.
+        
+        Args:
+            name: Имя инструмента API
+            registry: Реестр команд
+            
+        Returns:
+            Словарь с полным описанием инструмента
+        """
+        # Получаем все метаданные из реестра команд
+        all_metadata = registry.get_all_metadata()
+        
+        # Базовое описание инструмента
+        description = {
+            "name": name,
+            "description": f"Выполняет команды через JSON-RPC протокол на сервере проекта.",
+            "supported_commands": {},
+            "examples": []
+        }
+        
+        # Добавляем информацию о поддерживаемых командах
+        for cmd_name, metadata in all_metadata.items():
+            command_info = {
+                "summary": metadata["summary"],
+                "description": metadata["description"],
+                "params": {},
+                "required_params": []
+            }
+            
+            # Добавляем информацию о параметрах
+            for param_name, param_info in metadata["params"].items():
+                param_type = param_info.get("type", "any").replace("typing.", "")
+                
+                # Определяем тип параметра для документации
+                simple_type = cls._simplify_type(param_type)
+                
+                command_info["params"][param_name] = {
+                    "type": simple_type,
+                    "description": cls._extract_param_description(metadata["description"], param_name),
+                    "required": param_info.get("required", False)
+                }
+                
+                # Если параметр обязательный, добавляем его в список обязательных
+                if param_info.get("required", False):
+                    command_info["required_params"].append(param_name)
+            
+            description["supported_commands"][cmd_name] = command_info
+            
+            # Добавляем примеры из метаданных команды
+            for example in metadata.get("examples", []):
+                description["examples"].append({
+                    "command": example.get("command", cmd_name),
+                    "params": example.get("params", {}),
+                    "description": example.get("description", f"Пример использования команды {cmd_name}")
+                })
+        
+        return description
+    
+    @classmethod
+    def generate_tool_description_text(cls, name: str, registry) -> str:
+        """
+        Генерирует текстовое описание инструмента API для документации.
+        
+        Args:
+            name: Имя инструмента API
+            registry: Реестр команд
+            
+        Returns:
+            Текстовое описание инструмента в формате markdown
+        """
+        tool_data = cls.generate_tool_description(name, registry)
+        
+        # Формируем заголовок и базовое описание
+        text = f"# Инструмент {tool_data['name']}\n\n"
+        text += f"{tool_data['description']}\n\n"
+        
+        # Список доступных команд
+        text += "## Доступные команды\n\n"
+        for cmd_name, cmd_info in tool_data["supported_commands"].items():
+            text += f"### {cmd_name}\n\n"
+            text += f"{cmd_info['description']}\n\n"
+            
+            # Информация о параметрах
+            if cmd_info["params"]:
+                text += "#### Параметры:\n\n"
+                for param_name, param_info in cmd_info["params"].items():
+                    required_mark = "**обязательный**" if param_info["required"] else "опциональный"
+                    text += f"- `{param_name}` ({param_info['type']}, {required_mark}): {param_info['description']}\n"
+                text += "\n"
+            
+            # Примеры использования
+            cmd_examples = [ex for ex in tool_data["examples"] if ex["command"] == cmd_name]
+            if cmd_examples:
+                text += "#### Примеры:\n\n"
+                for i, example in enumerate(cmd_examples):
+                    text += f"**Пример {i+1}**: {example['description']}\n"
+                    text += "```json\n"
+                    text += "{\n"
+                    text += f'    "command": "{example["command"]}",\n'
+                    if example["params"]:
+                        text += '    "params": {\n'
+                        params_str = []
+                        for p_name, p_value in example["params"].items():
+                            if isinstance(p_value, str):
+                                p_str = f'        "{p_name}": "{p_value}"'
+                            else:
+                                p_str = f'        "{p_name}": {p_value}'
+                            params_str.append(p_str)
+                        text += ",\n".join(params_str)
+                        text += "\n    }\n"
+                    else:
+                        text += '    "params": {}\n'
+                    text += "}\n"
+                    text += "```\n\n"
+        
+        return text
+    
+    @classmethod
+    def _simplify_type(cls, type_str: str) -> str:
+        """
+        Упрощает строковое представление типа для документации.
+        
+        Args:
+            type_str: Строковое представление типа
+            
+        Returns:
+            Упрощенное строковое представление типа
+        """
+        # Удаляем префиксы из строки типа
+        type_str = type_str.replace("<class '", "").replace("'>", "")
+        
+        # Преобразование стандартных типов
+        if "str" in type_str:
+            return "строка"
+        elif "int" in type_str:
+            return "целое число"
+        elif "float" in type_str:
+            return "число"
+        elif "bool" in type_str:
+            return "логическое значение"
+        elif "List" in type_str or "list" in type_str:
+            return "список"
+        elif "Dict" in type_str or "dict" in type_str:
+            return "объект"
+        elif "Optional" in type_str:
+            # Извлекаем тип из Optional[X]
+            inner_type = type_str.split("[")[1].split("]")[0]
+            return cls._simplify_type(inner_type)
+        else:
+            return "значение"
+    
+    @classmethod
+    def _extract_param_description(cls, doc_string: str, param_name: str) -> str:
+        """
+        Извлекает описание параметра из строки документации.
+        
+        Args:
+            doc_string: Строка документации
+            param_name: Имя параметра
+            
+        Returns:
+            Описание параметра или пустая строка, если описание не найдено
+        """
+        # Проверяем, есть ли в документации секция Args или Parameters
+        if "Args:" in doc_string:
+            args_section = doc_string.split("Args:")[1].split("\n\n")[0]
+        elif "Parameters:" in doc_string:
+            args_section = doc_string.split("Parameters:")[1].split("\n\n")[0]
+        else:
+            return ""
+        
+        # Ищем описание параметра
+        for line in args_section.split("\n"):
+            line = line.strip()
+            if line.startswith(param_name + ":") or line.startswith(param_name + " :"):
+                return line.split(":", 1)[1].strip()
+        
+        return ""
+
+
+# Create dictionary mapping command names to their schemas
+command_schemas: Dict[str, Dict[str, Any]] = {}

mcp_proxy_adapter/api/tool_integration.py

@@ -0,0 +1,223 @@
+"""
+Модуль для интеграции метаданных команд с внешними API инструментами.
+
+Этот модуль обеспечивает преобразование метаданных команд микросервиса 
+в форматы, понятные для внешних систем, таких как OpenAPI, JSON-RPC,
+и других API интерфейсов.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+import json
+import logging
+
+from mcp_proxy_adapter.api.schemas import APIToolDescription
+from mcp_proxy_adapter.commands.command_registry import CommandRegistry
+
+logger = logging.getLogger(__name__)
+
+
+class ToolIntegration:
+    """
+    Класс для интеграции метаданных команд с внешними инструментами API.
+    
+    Обеспечивает генерацию описаний инструментов API для различных систем
+    на основе метаданных команд микросервиса.
+    """
+    
+    @classmethod
+    def generate_tool_schema(cls, tool_name: str, registry: CommandRegistry, 
+                             description: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Генерирует схему инструмента API для использования в OpenAPI и других системах.
+        
+        Args:
+            tool_name: Имя инструмента API
+            registry: Реестр команд
+            description: Дополнительное описание инструмента (опционально)
+            
+        Returns:
+            Словарь с описанием инструмента в формате OpenAPI
+        """
+        # Получаем базовое описание инструмента
+        base_description = APIToolDescription.generate_tool_description(tool_name, registry)
+        
+        # Получаем типы параметров
+        parameter_types = cls._extract_parameter_types(base_description["supported_commands"])
+        
+        # Формируем схему инструмента
+        schema = {
+            "name": tool_name,
+            "description": description or base_description["description"],
+            "parameters": {
+                "properties": {
+                    "command": {
+                        "description": "Команда для выполнения",
+                        "type": "string",
+                        "enum": list(base_description["supported_commands"].keys())
+                    },
+                    "params": {
+                        "description": "Параметры команды",
+                        "type": "object",
+                        "additionalProperties": True,
+                        "properties": parameter_types
+                    }
+                },
+                "required": ["command"],
+                "type": "object"
+            }
+        }
+        
+        return schema
+    
+    @classmethod
+    def generate_tool_documentation(cls, tool_name: str, registry: CommandRegistry, 
+                                   format: str = "markdown") -> str:
+        """
+        Генерирует документацию по инструменту API в заданном формате.
+        
+        Args:
+            tool_name: Имя инструмента API
+            registry: Реестр команд
+            format: Формат документации (markdown, html)
+            
+        Returns:
+            Строка с документацией в заданном формате
+        """
+        if format.lower() == "markdown":
+            return APIToolDescription.generate_tool_description_text(tool_name, registry)
+        elif format.lower() == "html":
+            # Преобразуем markdown в HTML (в реальном проекте здесь будет 
+            # использоваться библиотека для конвертации markdown в HTML)
+            markdown = APIToolDescription.generate_tool_description_text(tool_name, registry)
+            # Простая конвертация для примера
+            html = f"<html><body>{markdown.replace('#', '<h1>').replace('\n\n', '</p><p>')}</body></html>"
+            return html
+        else:
+            # По умолчанию возвращаем markdown
+            return APIToolDescription.generate_tool_description_text(tool_name, registry)
+    
+    @classmethod
+    def register_external_tools(cls, registry: CommandRegistry, tool_names: List[str]) -> Dict[str, Dict[str, Any]]:
+        """
+        Регистрирует инструменты API во внешних системах.
+        
+        Args:
+            registry: Реестр команд
+            tool_names: Список имен инструментов API для регистрации
+            
+        Returns:
+            Словарь с результатами регистрации инструментов
+        """
+        results = {}
+        
+        for tool_name in tool_names:
+            try:
+                # Генерируем схему инструмента
+                schema = cls.generate_tool_schema(tool_name, registry)
+                
+                # Здесь будет код для регистрации инструмента во внешней системе
+                # Например, отправка схемы в API регистрации инструментов
+                
+                results[tool_name] = {
+                    "status": "success",
+                    "schema": schema
+                }
+                
+                logger.info(f"Successfully registered tool: {tool_name}")
+            except Exception as e:
+                logger.error(f"Error registering tool {tool_name}: {e}")
+                results[tool_name] = {
+                    "status": "error",
+                    "error": str(e)
+                }
+        
+        return results
+    
+    @classmethod
+    def _extract_parameter_types(cls, commands: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+        """
+        Извлекает типы параметров из описания команд для формирования схемы.
+        
+        Args:
+            commands: Словарь с описанием команд
+            
+        Returns:
+            Словарь с типами параметров для схемы OpenAPI
+        """
+        parameter_types = {}
+        
+        # Формируем словарь типов для всех параметров всех команд
+        for cmd_name, cmd_info in commands.items():
+            for param_name, param_info in cmd_info.get("params", {}).items():
+                param_type = param_info.get("type", "значение")
+                
+                # Преобразуем русские типы в типы JSON Schema
+                if param_type == "строка":
+                    json_type = "string"
+                elif param_type == "целое число":
+                    json_type = "integer"
+                elif param_type == "число":
+                    json_type = "number"
+                elif param_type == "логическое значение":
+                    json_type = "boolean"
+                elif param_type == "список":
+                    json_type = "array"
+                elif param_type == "объект":
+                    json_type = "object"
+                else:
+                    json_type = "string"
+                
+                # Добавляем тип в общий словарь
+                parameter_types[param_name] = {
+                    "type": json_type,
+                    "description": param_info.get("description", "")
+                }
+        
+        return parameter_types
+
+
+def generate_tool_help(tool_name: str, registry: CommandRegistry) -> str:
+    """
+    Генерирует справочную информацию по инструменту API.
+    
+    Args:
+        tool_name: Имя инструмента API
+        registry: Реестр команд
+        
+    Returns:
+        Строка с описанием инструмента и доступных команд
+    """
+    # Получаем метаданные всех команд
+    all_metadata = registry.get_all_metadata()
+    
+    # Формируем текст справки
+    help_text = f"# Инструмент {tool_name}\n\n"
+    help_text += "Позволяет выполнять команды через JSON-RPC протокол.\n\n"
+    help_text += "## Доступные команды:\n\n"
+    
+    # Добавляем информацию о каждой команде
+    for cmd_name, metadata in all_metadata.items():
+        help_text += f"### {cmd_name}\n"
+        help_text += f"{metadata['summary']}\n\n"
+        
+        # Добавляем информацию о параметрах команды
+        if metadata["params"]:
+            help_text += "Параметры:\n"
+            for param_name, param_info in metadata["params"].items():
+                required = "обязательный" if param_info.get("required", False) else "опциональный"
+                help_text += f"- {param_name}: {required}\n"
+            help_text += "\n"
+        
+        # Добавляем пример использования команды
+        if metadata.get("examples"):
+            example = metadata["examples"][0]
+            help_text += "Пример:\n"
+            help_text += "```json\n"
+            help_text += json.dumps(
+                {"command": example.get("command", cmd_name), "params": example.get("params", {})},
+                indent=2,
+                ensure_ascii=False
+            )
+            help_text += "\n```\n\n"
+    
+    return help_text