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

mcp_proxy_adapter/custom_openapi.py

@@ -1,677 +1,58 @@
 """
 Custom OpenAPI schema generator for MCP Microservice compatible with MCP-Proxy.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
 """
 
-import json
-from copy import deepcopy
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Type, Callable
 
 from fastapi import FastAPI
-from fastapi.openapi.utils import get_openapi
-
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.core.logging import get_global_logger
-
-
-class CustomOpenAPIGenerator:
-    """
-    Custom OpenAPI schema generator for compatibility with MCP-Proxy.
-
-    EN:
-    This generator creates an OpenAPI schema that matches the format expected by MCP-Proxy,
-    enabling dynamic command loading and proper tool representation in AI models.
-    Allows overriding title, description, and version for schema customization.
-
-    RU:
-    Кастомный генератор схемы OpenAPI для совместимости с MCP-Proxy.
-    Позволяет создавать схему OpenAPI в формате, ожидаемом MCP-Proxy,
-    с возможностью динамической подгрузки команд и корректного отображения инструментов для AI-моделей.
-    Поддерживает переопределение title, description и version для кастомизации схемы.
-    """
-
-    def __init__(self):
-        """Initialize the generator."""
-        self.base_schema_path = (
-            Path(__file__).parent / "schemas" / "openapi_schema.json"
-        )
-        self.base_schema = self._load_base_schema()
-
-    def _load_base_schema(self) -> Dict[str, Any]:
-        """
-        Load the base OpenAPI schema from file.
-
-        Returns:
-            Dict containing the base OpenAPI schema.
-        """
-        try:
-            with open(self.base_schema_path, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except FileNotFoundError:
-            get_global_logger().warning(f"Base schema file not found at {self.base_schema_path}, using fallback schema")
-            return self._get_fallback_schema()
-
-    def _get_fallback_schema(self) -> Dict[str, Any]:
-        """
-        Get a fallback OpenAPI schema when the base schema file is not available.
-
-        Returns:
-            Dict containing a basic OpenAPI schema.
-        """
-        return {
-            "openapi": "3.0.2",
-            "info": {
-                "title": "MCP Microservice API",
-                "description": "API для выполнения команд микросервиса",
-                "version": "1.0.0"
-            },
-            "paths": {
-                "/cmd": {
-                    "post": {
-                        "summary": "Execute Command",
-                        "description": "Executes a command via JSON-RPC protocol.",
-                        "operationId": "execute_command",
-                        "requestBody": {
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "oneOf": [
-                                            { "$ref": "#/components/schemas/CommandRequest" },
-                                            { "$ref": "#/components/schemas/JsonRpcRequest" }
-                                        ]
-                                    }
-                                }
-                            },
-                            "required": True
-                        },
-                        "responses": {
-                            "200": {
-                                "description": "Successful Response",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {
-                                            "oneOf": [
-                                                { "$ref": "#/components/schemas/CommandResponse" },
-                                                { "$ref": "#/components/schemas/JsonRpcResponse" }
-                                            ]
-                                        }
-                                    }
-                                }
-                            },
-                            "422": {
-                                "description": "Validation Error",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {
-                                            "$ref": "#/components/schemas/HTTPValidationError"
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                },
-                "/health": {
-                    "get": {
-                        "summary": "Проверить работоспособность сервиса",
-                        "description": "Возвращает информацию о состоянии сервиса",
-                        "operationId": "health_check",
-                        "responses": {
-                            "200": {
-                                "description": "Информация о состоянии сервиса",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {
-                                            "$ref": "#/components/schemas/HealthResponse"
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                },
-                "/openapi.json": {
-                    "get": {
-                        "summary": "Get Openapi Schema",
-                        "description": "Returns OpenAPI schema.",
-                        "operationId": "get_openapi_schema_openapi_json_get",
-                        "responses": {
-                            "200": {
-                                "description": "Successful Response",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {}
-                                    }
-                                }
-                            }
-                        }
-                    }
-                },
-                "/api/commands": {
-                    "get": {
-                        "summary": "Get Commands",
-                        "description": "Returns list of available commands with their descriptions.",
-                        "operationId": "get_commands_api_commands_get",
-                        "responses": {
-                            "200": {
-                                "description": "Successful Response",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {}
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            },
-            "components": {
-                "schemas": {
-                    "CommandRequest": {
-                        "title": "CommandRequest",
-                        "description": "Запрос на выполнение команды",
-                        "type": "object",
-                        "required": ["command"],
-                        "properties": {
-                            "command": {
-                                "title": "Command",
-                                "description": "Команда для выполнения",
-                                "type": "string"
-                            },
-                            "params": {
-                                "title": "Parameters",
-                                "description": "Параметры команды, зависят от типа команды",
-                                "type": "object",
-                                "additionalProperties": True
-                            }
-                        }
-                    },
-                    "CommandResponse": {
-                        "title": "CommandResponse",
-                        "description": "Ответ на выполнение команды",
-                        "type": "object",
-                        "required": ["result"],
-                        "properties": {
-                            "result": {
-                                "title": "Result",
-                                "description": "Результат выполнения команды"
-                            }
-                        }
-                    },
-                    "JsonRpcRequest": {
-                        "properties": {
-                            "jsonrpc": {
-                                "type": "string",
-                                "title": "Jsonrpc",
-                                "description": "JSON-RPC version",
-                                "default": "2.0"
-                            },
-                            "method": {
-                                "type": "string",
-                                "title": "Method",
-                                "description": "Method name to call"
-                            },
-                            "params": {
-                                "additionalProperties": True,
-                                "type": "object",
-                                "title": "Params",
-                                "description": "Method parameters",
-                                "default": {}
-                            },
-                            "id": {
-                                "anyOf": [
-                                    {"type": "string"},
-                                    {"type": "integer"},
-                                    {"type": "null"}
-                                ],
-                                "title": "Id",
-                                "description": "Request identifier"
-                            }
-                        },
-                        "type": "object",
-                        "required": ["method"],
-                        "title": "JsonRpcRequest",
-                        "description": "Base model for JSON-RPC requests."
-                    },
-                    "JsonRpcResponse": {
-                        "properties": {
-                            "jsonrpc": {
-                                "type": "string",
-                                "title": "Jsonrpc",
-                                "description": "JSON-RPC version",
-                                "default": "2.0"
-                            },
-                            "result": {
-                                "anyOf": [
-                                    {},
-                                    {"type": "null"}
-                                ],
-                                "title": "Result",
-                                "description": "Method execution result"
-                            },
-                            "error": {
-                                "anyOf": [
-                                    {
-                                        "additionalProperties": True,
-                                        "type": "object"
-                                    },
-                                    {"type": "null"}
-                                ],
-                                "title": "Error",
-                                "description": "Error information"
-                            },
-                            "id": {
-                                "anyOf": [
-                                    {"type": "string"},
-                                    {"type": "integer"},
-                                    {"type": "null"}
-                                ],
-                                "title": "Id",
-                                "description": "Request identifier"
-                            }
-                        },
-                        "type": "object",
-                        "title": "JsonRpcResponse",
-                        "description": "Base model for JSON-RPC responses."
-                    },
-                    "HealthResponse": {
-                        "title": "HealthResponse",
-                        "description": "Информация о состоянии сервиса",
-                        "type": "object",
-                        "required": ["status", "model", "version"],
-                        "properties": {
-                            "status": {
-                                "title": "Status",
-                                "description": "Статус сервиса (ok/error)",
-                                "type": "string"
-                            },
-                            "model": {
-                                "title": "Model",
-                                "description": "Текущая активная модель",
-                                "type": "string"
-                            },
-                            "version": {
-                                "title": "Version",
-                                "description": "Версия сервиса",
-                                "type": "string"
-                            }
-                        }
-                    },
-                    "HTTPValidationError": {
-                        "properties": {
-                            "detail": {
-                                "items": {
-                                    "$ref": "#/components/schemas/ValidationError"
-                                },
-                                "type": "array",
-                                "title": "Detail"
-                            }
-                        },
-                        "type": "object",
-                        "title": "HTTPValidationError"
-                    },
-                    "ValidationError": {
-                        "properties": {
-                            "loc": {
-                                "items": {
-                                    "anyOf": [
-                                        {"type": "string"},
-                                        {"type": "integer"}
-                                    ]
-                                },
-                                "type": "array",
-                                "title": "Location"
-                            },
-                            "msg": {
-                                "type": "string",
-                                "title": "Message"
-                            },
-                            "type": {
-                                "type": "string",
-                                "title": "Error Type"
-                            }
-                        },
-                        "type": "object",
-                        "required": ["loc", "msg", "type"],
-                        "title": "ValidationError"
-                    }
-                }
-            }
-        }
-
-    def _add_commands_to_schema(self, schema: Dict[str, Any]) -> None:
-        """
-        Add all registered commands to the OpenAPI schema.
-
-        Args:
-            schema: The OpenAPI schema to update.
-        """
-        # Get all commands from the registry
-        commands = registry.get_all_commands()
-
-        # Ensure CommandRequest exists in schemas
-        if "CommandRequest" not in schema["components"]["schemas"]:
-            schema["components"]["schemas"]["CommandRequest"] = {
-                "properties": {
-                    "command": {"type": "string", "enum": []},
-                    "params": {"type": "object", "oneOf": []},
-                }
-            }
-
-        # Add command names to the CommandRequest enum
-        schema["components"]["schemas"]["CommandRequest"]["properties"]["command"][
-            "enum"
-        ] = [cmd for cmd in commands.keys()]
-
-        # Add command parameters to oneOf
-        params_refs = []
-
-        for name, cmd_class in commands.items():
-            # Create schema for command parameters
-            param_schema_name = f"{name.capitalize()}Params"
-            schema["components"]["schemas"][param_schema_name] = (
-                self._create_params_schema(cmd_class)
-            )
-
-            # Add to oneOf
-            params_refs.append({"$ref": f"#/components/schemas/{param_schema_name}"})
-
-        # Add null option for commands without parameters
-        params_refs.append({"type": "null"})
-
-        # Set oneOf for params
-        schema["components"]["schemas"]["CommandRequest"]["properties"]["params"][
-            "oneOf"
-        ] = params_refs
-
-    def _create_params_schema(self, cmd_class: Type[Command]) -> Dict[str, Any]:
-        """
-        Create a schema for command parameters.
-
-        Args:
-            cmd_class: The command class.
-
-        Returns:
-            Dict containing the parameter schema.
-        """
-        try:
-            # Get command schema
-            cmd_schema = cmd_class.get_schema()
-
-            # Add title and description
-            cmd_schema["title"] = f"Parameters for {cmd_class.name}"
-            cmd_schema["description"] = f"Parameters for the {cmd_class.name} command"
-
-            return cmd_schema
-        except Exception as e:
-            # Return default schema if command schema generation fails
-            get_global_logger().warning(f"Failed to get schema for command {cmd_class.name}: {e}")
-            return {
-                "type": "object",
-                "title": f"Parameters for {cmd_class.name}",
-                "description": f"Parameters for the {cmd_class.name} command (schema generation failed)",
-                "properties": {},
-                "additionalProperties": True,
-            }
-
-    def generate(
-        self,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        version: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """
-        EN:
-        Generate the complete OpenAPI schema compatible with MCP-Proxy.
-        Optionally override title, description, and version.
-
-        RU:
-        Генерирует полную схему OpenAPI, совместимую с MCP-Proxy.
-        Позволяет опционально переопределить title, description и version.
-
-        Args:
-            title: Custom title for the schema / Кастомный заголовок схемы
-            description: Custom description for the schema / Кастомное описание схемы
-            version: Custom version for the schema / Кастомная версия схемы
-
-        Returns:
-            Dict containing the complete OpenAPI schema / Словарь с полной схемой OpenAPI
-        """
-        # Deep copy the base schema to avoid modifying it
-        schema = deepcopy(self.base_schema)
-
-        # Optionally override info fields
-        if title:
-            schema["info"]["title"] = title
-
-        # Get all commands for help information
-        commands = registry.get_all_commands()
-        command_names = list(commands.keys())
-
-        # Create help examples
-        help_examples = {
-            "without_params": {"jsonrpc": "2.0", "method": "help", "id": 1},
-            "with_params": {
-                "jsonrpc": "2.0",
-                "method": "help",
-                "params": {
-                    "command": command_names[0] if command_names else "example_command"
-                },
-                "id": 1,
-            },
-        }
-
-        # Enhance description with help format and commands list for OpenAPI docs
-        base_description = description or schema["info"]["description"]
-        # В тестах ожидается точное совпадение с исходным описанием
-        if "title" in schema["info"] and schema["info"]["title"] == "Custom Title":
-            # Для теста оставляем описание без изменений
-            enhanced_description = base_description
-        else:
-            # Для обычного использования добавляем информацию о командах и справке
-            commands_str = ", ".join(command_names)
-            help_command_simple = '{"jsonrpc": "2.0", "method": "help", "id": 1}'
-            help_command_with_param = (
-                '{"jsonrpc": "2.0", "method": "help", "params": {"command": "'
-            )
-            if command_names:
-                help_command_with_param += command_names[0]
-            else:
-                help_command_with_param += "example_command"
-            help_command_with_param += '"}, "id": 1}'
-
-            enhanced_description = (
-                base_description
-                + "\n\n## Available commands:\n"
-                + commands_str
-                + "\n\n## Getting help\n\n"
-                + "Without parameters (list of all commands):\n"
-                + "```json\n"
-                + help_command_simple
-                + "\n```\n\n"
-                + "With parameters (information about a specific command):\n"
-                + "```json\n"
-                + help_command_with_param
-                + "\n```\n"
-            )
-
-        # Set enhanced description for OpenAPI docs
-        schema["info"]["description"] = enhanced_description
-
-        # Update tool description visible in MCP-Proxy
-        if "components" not in schema:
-            schema["components"] = {}
-        if "schemas" not in schema["components"]:
-            schema["components"]["schemas"] = {}
+from typing import Dict, Any
 
-        # Create ToolDescription if it doesn't exist
-        if "ToolDescription" not in schema["components"]["schemas"]:
-            schema["components"]["schemas"]["ToolDescription"] = {
-                "type": "object",
-                "title": "Tool Description",
-                "description": "Description of the microservice tool",
-                "properties": {
-                    "name": {"type": "string", "description": "Name of the tool"},
-                    "description": {
-                        "type": "string",
-                        "description": "Description of the tool",
-                    },
-                    "version": {"type": "string", "description": "Tool version"},
-                },
-                "required": ["name", "description"],
-            }
-
-        # Update tool description content
-        tool_desc = schema["components"]["schemas"]["ToolDescription"]
-
-        # Add help format and commands information to the tool description
-        tool_desc_text = "Tool for executing microservice commands.\n\n"
-        tool_desc_text += "## Available commands:\n"
-        tool_desc_text += ", ".join(command_names)
-        tool_desc_text += "\n\n## Getting help:\n"
-        tool_desc_text += "- Without parameters (list of all commands): \n"
-        tool_desc_text += '  {"jsonrpc": "2.0", "method": "help", "id": 1}\n'
-        tool_desc_text += "  \n"
-        tool_desc_text += "- With parameters (information about a specific command): \n"
-        tool_desc_text += '  {"jsonrpc": "2.0", "method": "help", "params": {"command": "command_name"}, "id": 1}\n'
-
-        tool_desc["properties"]["description"]["description"] = tool_desc_text
-
-        # Add help examples as a new property
-        tool_desc["properties"]["help_examples"] = {
-            "type": "object",
-            "description": "Examples of using the help command",
-            "properties": {
-                "without_params": {
-                    "type": "object",
-                    "description": "Get a list of all commands",
-                },
-                "with_params": {
-                    "type": "object",
-                    "description": "Get information about a specific command",
-                },
-            },
-            "example": help_examples,
-        }
-
-        # Add available commands as a new property
-        tool_desc["properties"]["available_commands"] = {
-            "type": "array",
-            "description": "List of available commands",
-            "items": {"type": "string"},
-            "example": command_names,
-        }
-
-        if version:
-            schema["info"]["version"] = version
-
-        # Add commands to schema
-        self._add_commands_to_schema(schema)
-
-        get_global_logger().debug(
-            f"Generated OpenAPI schema with {len(registry.get_all_commands())} commands"
-        )
-
-        return schema
+# from mcp_proxy_adapter.api.openapi import (
+#     CustomOpenAPIGenerator,
+#     register_openapi_generator,
+#     get_openapi_generator,
+#     list_openapi_generators,
+# )
 
 
 def custom_openapi(app: FastAPI) -> Dict[str, Any]:
     """
-    EN:
-    Create a custom OpenAPI schema for the FastAPI application.
-    Passes app's title, description, and version to the generator.
-
-    RU:
-    Создаёт кастомную OpenAPI-схему для FastAPI-приложения.
-    Передаёт параметры title, description и version из приложения в генератор схемы.
+    Generate custom OpenAPI schema for the application.
 
     Args:
-        app: The FastAPI application / FastAPI-приложение
+        app: FastAPI application instance
 
     Returns:
-        Dict containing the custom OpenAPI schema / Словарь с кастомной OpenAPI-схемой
+        Generated OpenAPI schema
     """
     generator = CustomOpenAPIGenerator()
-    openapi_schema = generator.generate(
-        title=getattr(app, "title", None),
-        description=getattr(app, "description", None),
-        version=getattr(app, "version", None),
-    )
-
-    # Cache the schema
-    app.openapi_schema = openapi_schema
-
-    return openapi_schema
-
-
-# Registry for custom OpenAPI generators
-_openapi_generators: Dict[str, Callable] = {}
-
-
-def register_openapi_generator(
-    name: str, generator_func: Callable[[FastAPI], Dict[str, Any]]
-) -> None:
-    """
-    Register a custom OpenAPI generator.
-
-    Args:
-        name: Generator name.
-        generator_func: Function that generates OpenAPI schema.
-    """
-    _openapi_generators[name] = generator_func
-    get_global_logger().info(f"Registered custom OpenAPI generator: {name}")
-
-
-def get_openapi_generator(name: str) -> Optional[Callable[[FastAPI], Dict[str, Any]]]:
-    """
-    Get a custom OpenAPI generator by name.
-
-    Args:
-        name: Generator name.
-
-    Returns:
-        Generator function or None if not found.
-    """
-    return _openapi_generators.get(name)
-
-
-def list_openapi_generators() -> List[str]:
-    """
-    Get list of registered OpenAPI generators.
-
-    Returns:
-        List of generator names.
-    """
-    return list(_openapi_generators.keys())
+    return generator.generate(app)
 
 
 def custom_openapi_with_fallback(app: FastAPI) -> Dict[str, Any]:
     """
-    EN:
-    Create a custom OpenAPI schema for the FastAPI application.
-    Checks for custom generators first, then falls back to default generator.
-    Passes app's title, description, and version to the generator.
-
-    RU:
-    Создаёт кастомную OpenAPI-схему для FastAPI-приложения.
-    Сначала проверяет наличие кастомных генераторов, затем использует встроенный генератор.
-    Передаёт параметры title, description и version из приложения в генератор схемы.
+    Generate custom OpenAPI schema with fallback to default generator.
 
     Args:
-        app: The FastAPI application / FastAPI-приложение
+        app: FastAPI application instance
 
     Returns:
-        Dict containing the custom OpenAPI schema / Словарь с кастомной OpenAPI-схемой
-    """
-    # Check if there are any custom generators
-    if _openapi_generators:
-        # Use the first registered generator
-        generator_name = list(_openapi_generators.keys())[0]
-        generator_func = _openapi_generators[generator_name]
-        get_global_logger().debug(f"Using custom OpenAPI generator: {generator_name}")
-        return generator_func(app)
-
-    # Fall back to default generator
-    get_global_logger().debug("Using default OpenAPI generator")
-    return custom_openapi(app)
+        Generated OpenAPI schema
+    """
+    try:
+        return custom_openapi(app)
+    except Exception as e:
+        from mcp_proxy_adapter.core.logging import get_global_logger
+        logger = get_global_logger()
+        logger.warning(f"Custom OpenAPI generation failed, using fallback: {e}")
+        
+        # Fallback to default FastAPI OpenAPI generator
+        from fastapi.openapi.utils import get_openapi
+        return get_openapi(
+            title=app.title,
+            version=app.version,
+            description=app.description,
+            routes=app.routes,
+        )