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

mcp_proxy_adapter/api/middleware/user_info_middleware.py

@@ -130,121 +130,3 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
         else:
             get_global_logger().info("ℹ️ User info middleware initialized with mcp_security_framework (fallback enabled)")
 
-    async def dispatch(
-        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
-    ) -> Response:
-        """
-        Process request and set user info in request.state.
-
-        Args:
-            request: Request object
-            call_next: Next handler
-
-        Returns:
-            Response object
-        """
-        get_global_logger().debug(f"🔍 UserInfoMiddleware.dispatch START - {request.method} {request.url.path}")
-        get_global_logger().debug(f"🔍 UserInfoMiddleware - Headers: {dict(request.headers)}")
-        get_global_logger().debug(f"🔍 UserInfoMiddleware - AuthManager available: {self.auth_manager is not None}")
-        get_global_logger().debug(f"🔍 UserInfoMiddleware - Security available: {self._security_available}")
-        
-        # Extract API key from headers
-        api_key = request.headers.get("X-API-Key")
-        get_global_logger().debug(f"🔍 UserInfoMiddleware - API Key: {api_key[:8] + '...' if api_key else 'None'}")
-        if api_key:
-            if self.auth_manager and self._security_available:
-                try:
-                    # Use mcp_security_framework AuthManager
-                    auth_result = self.auth_manager.authenticate_api_key(api_key)
-
-                    if auth_result.is_valid:
-                        # Set user info from AuthManager result
-                        request.state.user = {
-                            "id": api_key,
-                            "role": (
-                                auth_result.roles[0] if auth_result.roles else "guest"
-                            ),
-                            "roles": auth_result.roles or ["guest"],
-                            "permissions": getattr(
-                                auth_result, "permissions", ["read"]
-                            ),
-                        }
-                        get_global_logger().debug(
-                            f"✅ Authenticated user with "
-                            f"mcp_security_framework: "
-                            f"{request.state.user}"
-                        )
-                    else:
-                        # Authentication failed
-                        request.state.user = {
-                            "id": None,
-                            "role": "guest",
-                            "roles": ["guest"],
-                            "permissions": ["read"],
-                        }
-                        get_global_logger().debug(
-                            f"❌ Authentication failed for API key: "
-                            f"{api_key[:8]}..."
-                        )
-                except Exception as e:
-                    get_global_logger().warning(
-                        f"⚠️ AuthManager error: {e}, " f"falling back to basic auth"
-                    )
-                    self._security_available = False
-
-            if not self._security_available:
-                # Fallback to basic API key handling
-                api_keys_dict = getattr(self, "api_keys", {})
-                # Find role by API key value (not key)
-                user_role = None
-                for role, key_value in api_keys_dict.items():
-                    if key_value == api_key:
-                        user_role = role
-                        break
-                
-                if user_role:
-                    # Get permissions for this role from roles file if available
-                    role_permissions = ["read"]  # default permissions
-                    if (
-                        hasattr(self, "roles_config")
-                        and self.roles_config
-                        and user_role in self.roles_config
-                    ):
-                        role_permissions = self.roles_config[user_role].get(
-                            "permissions", ["read"]
-                        )
-
-                    # Set user info in request.state
-                    request.state.user = {
-                        "id": api_key,
-                        "role": user_role,
-                        "roles": [user_role],
-                        "permissions": role_permissions,
-                    }
-                    get_global_logger().debug(
-                        f"✅ User authenticated with API key: "
-                        f"{api_key[:8]}..."
-                    )
-                else:
-                    # API key not found
-                    request.state.user = {
-                        "id": None,
-                        "role": "guest",
-                        "roles": ["guest"],
-                        "permissions": ["read"],
-                    }
-                    get_global_logger().debug(f"❌ API key not found: {api_key[:8]}...")
-        else:
-            # No API key provided - guest access
-            request.state.user = {
-                "id": None,
-                "role": "guest",
-                "roles": ["guest"],
-                "permissions": ["read"],
-            }
-            get_global_logger().debug("ℹ️ No API key provided, using guest access")
-
-        get_global_logger().debug(f"🔍 UserInfoMiddleware - About to call next handler")
-        response = await call_next(request)
-        get_global_logger().debug(f"🔍 UserInfoMiddleware - Next handler completed with status: {response.status_code}")
-        return response

mcp_proxy_adapter/api/openapi/__init__.py

@@ -0,0 +1,21 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+OpenAPI schema generation package for MCP Proxy Adapter.
+"""
+
+from .openapi_generator import CustomOpenAPIGenerator
+from .schema_loader import SchemaLoader
+from .command_integration import CommandIntegrator
+from .openapi_registry import OpenAPIRegistry
+from .custom_openapi import custom_openapi, custom_openapi_with_fallback
+
+__all__ = [
+    "CustomOpenAPIGenerator",
+    "SchemaLoader",
+    "CommandIntegrator",
+    "OpenAPIRegistry",
+    "custom_openapi",
+    "custom_openapi_with_fallback",
+]

mcp_proxy_adapter/api/openapi/command_integration.py

@@ -0,0 +1,105 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command integration utilities for OpenAPI generation.
+"""
+
+from typing import Dict, Any, Type
+
+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 CommandIntegrator:
+    """Integrator for adding commands to OpenAPI schema."""
+
+    def __init__(self):
+        """Initialize command integrator."""
+        self.logger = get_global_logger()
+
+
+    def _create_params_schema(self, cmd_class: Type[Command]) -> Dict[str, Any]:
+        """
+        Create a schema for command parameters.
+
+        Args:
+            cmd_class: The command class to create schema for.
+
+        Returns:
+            Dict containing the parameter schema.
+        """
+        try:
+            # Get the command schema
+            schema = cmd_class.get_schema()
+            
+            if not schema or "properties" not in schema:
+                return {"type": "object", "properties": {}}
+
+            # Convert to OpenAPI format
+            openapi_schema = {
+                "type": "object",
+                "properties": {},
+                "required": schema.get("required", [])
+            }
+
+            # Convert properties
+            for prop_name, prop_schema in schema["properties"].items():
+                openapi_schema["properties"][prop_name] = self._convert_property_schema(prop_schema)
+
+            return openapi_schema
+
+        except Exception as e:
+            self.logger.warning(f"Failed to create params schema for {cmd_class.__name__}: {e}")
+            return {"type": "object", "properties": {}}
+
+    def _convert_property_schema(self, prop_schema: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Convert property schema to OpenAPI format.
+
+        Args:
+            prop_schema: Property schema to convert.
+
+        Returns:
+            OpenAPI property schema.
+        """
+        openapi_prop = {}
+
+        # Handle type
+        if "type" in prop_schema:
+            openapi_prop["type"] = prop_schema["type"]
+
+        # Handle description
+        if "description" in prop_schema:
+            openapi_prop["description"] = prop_schema["description"]
+
+        # Handle default
+        if "default" in prop_schema:
+            openapi_prop["default"] = prop_schema["default"]
+
+        # Handle enum
+        if "enum" in prop_schema:
+            openapi_prop["enum"] = prop_schema["enum"]
+
+        # Handle minimum/maximum
+        if "minimum" in prop_schema:
+            openapi_prop["minimum"] = prop_schema["minimum"]
+        if "maximum" in prop_schema:
+            openapi_prop["maximum"] = prop_schema["maximum"]
+
+        # Handle minLength/maxLength
+        if "minLength" in prop_schema:
+            openapi_prop["minLength"] = prop_schema["minLength"]
+        if "maxLength" in prop_schema:
+            openapi_prop["maxLength"] = prop_schema["maxLength"]
+
+        # Handle pattern
+        if "pattern" in prop_schema:
+            openapi_prop["pattern"] = prop_schema["pattern"]
+
+        # Handle items for arrays
+        if "items" in prop_schema:
+            openapi_prop["items"] = self._convert_property_schema(prop_schema["items"])
+
+        return openapi_prop

mcp_proxy_adapter/api/openapi/openapi_generator.py

@@ -0,0 +1,40 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main OpenAPI generator for MCP Proxy Adapter.
+"""
+
+from copy import deepcopy
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .schema_loader import SchemaLoader
+from .command_integration import CommandIntegrator
+
+
+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.logger = get_global_logger()
+        self.schema_loader = SchemaLoader()
+        self.command_integrator = CommandIntegrator()
+        self.base_schema = self.schema_loader.load_base_schema()
+

mcp_proxy_adapter/api/openapi/openapi_registry.py

@@ -0,0 +1,62 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Registry for OpenAPI generators.
+"""
+
+from typing import Dict, Callable, Optional, List
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class OpenAPIRegistry:
+    """Registry for OpenAPI generators."""
+
+    def __init__(self):
+        """Initialize OpenAPI registry."""
+        self.logger = get_global_logger()
+        self._generators: Dict[str, Callable] = {}
+
+    def register_generator(self, name: str, generator: Callable) -> None:
+        """
+        Register an OpenAPI generator.
+
+        Args:
+            name: Generator name
+            generator: Generator function
+        """
+        self._generators[name] = generator
+        self.logger.debug(f"Registered OpenAPI generator: {name}")
+
+    def get_generator(self, name: str) -> Optional[Callable]:
+        """
+        Get an OpenAPI generator by name.
+
+        Args:
+            name: Generator name
+
+        Returns:
+            Generator function or None if not found
+        """
+        return self._generators.get(name)
+
+    def list_generators(self) -> List[str]:
+        """
+        List all registered generators.
+
+        Returns:
+            List of generator names
+        """
+        return list(self._generators.keys())
+
+
+
+# Global registry instance
+_registry = OpenAPIRegistry()
+
+
+
+
+
+

mcp_proxy_adapter/api/openapi/schema_loader.py

@@ -0,0 +1,116 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Schema loading utilities for OpenAPI generation.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class SchemaLoader:
+    """Loader for OpenAPI base schemas."""
+
+    def __init__(self):
+        """Initialize schema loader."""
+        self.logger = get_global_logger()
+        self.base_schema_path = (
+            Path(__file__).parent.parent.parent / "schemas" / "openapi_schema.json"
+        )
+
+
+    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" }
+                                            ]
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            "components": {
+                "schemas": {
+                    "CommandRequest": {
+                        "type": "object",
+                        "properties": {
+                            "command": {"type": "string"},
+                            "params": {"type": "object"}
+                        },
+                        "required": ["command"]
+                    },
+                    "CommandResponse": {
+                        "type": "object",
+                        "properties": {
+                            "success": {"type": "boolean"},
+                            "data": {"type": "object"},
+                            "error": {"type": "string"}
+                        }
+                    },
+                    "JsonRpcRequest": {
+                        "type": "object",
+                        "properties": {
+                            "jsonrpc": {"type": "string", "enum": ["2.0"]},
+                            "method": {"type": "string"},
+                            "params": {"type": "object"},
+                            "id": {"type": "string"}
+                        },
+                        "required": ["jsonrpc", "method", "id"]
+                    },
+                    "JsonRpcResponse": {
+                        "type": "object",
+                        "properties": {
+                            "jsonrpc": {"type": "string", "enum": ["2.0"]},
+                            "result": {"type": "object"},
+                            "error": {"type": "object"},
+                            "id": {"type": "string"}
+                        }
+                    }
+                }
+            }
+        }

mcp_proxy_adapter/api/schemas.py

@@ -202,67 +202,6 @@ class APIToolDescription:
         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:

mcp_proxy_adapter/api/tool_integration.py

@@ -6,7 +6,6 @@
 и других API интерфейсов.
 """
 
-from typing import Any, Dict, List, Optional, Union
 import json
 import logging
 
@@ -79,72 +78,8 @@ class ToolIntegration:
         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
-            )
-            # Простая конвертация для примера
-            body = markdown.replace("#", "<h1>").replace("\n\n", "</p><p>")
-            html = f"<html><body>{body}</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}
-
-                get_global_logger().info(f"Successfully registered tool: {tool_name}")
-            except Exception as e:
-                get_global_logger().debug(f"Error registering tool {tool_name}: {e}")
-                results[tool_name] = {"status": "error", "error": str(e)}
-
-        return results
 
     @classmethod
     def _extract_parameter_types(
@@ -194,55 +129,3 @@ class ToolIntegration:
         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