mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/core/utils.py

@@ -34,7 +34,9 @@ def get_timestamp() -> int:
     return int(time.time() * 1000)
 
 
-def format_datetime(dt: Optional[datetime] = None, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ") -> str:
+def format_datetime(
+    dt: Optional[datetime] = None, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ"
+) -> str:
     """
     Formats date and time as string.
 
@@ -113,7 +115,7 @@ def calculate_hash(data: Union[str, bytes], algorithm: str = "sha256") -> str:
     """
     if isinstance(data, str):
         data = data.encode("utf-8")
-    
+
     hash_obj = hashlib.new(algorithm)
     hash_obj.update(data)
     return hash_obj.hexdigest()

mcp_proxy_adapter/custom_openapi.py

@@ -1,6 +1,7 @@
 """
 Custom OpenAPI schema generator for MCP Microservice compatible with MCP-Proxy.
 """
+
 import json
 from copy import deepcopy
 from pathlib import Path
@@ -17,7 +18,7 @@ from mcp_proxy_adapter.core.logging import 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.
@@ -29,81 +30,87 @@ class CustomOpenAPIGenerator:
     с возможностью динамической подгрузки команд и корректного отображения инструментов для AI-моделей.
     Поддерживает переопределение title, description и version для кастомизации схемы.
     """
-    
+
     def __init__(self):
         """Initialize the generator."""
-        self.base_schema_path = Path(__file__).parent / "schemas" / "openapi_schema.json"
+        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.
         """
         with open(self.base_schema_path, "r", encoding="utf-8") as f:
             return json.load(f)
-    
+
     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": []}
+                    "params": {"type": "object", "oneOf": []},
                 }
             }
-        
+
         # Add command names to the CommandRequest enum
-        schema["components"]["schemas"]["CommandRequest"]["properties"]["command"]["enum"] = [
-            cmd for cmd in commands.keys()
-        ]
-        
+        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)
-            
+            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
-    
+        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
@@ -113,10 +120,15 @@ class CustomOpenAPIGenerator:
                 "title": f"Parameters for {cmd_class.name}",
                 "description": f"Parameters for the {cmd_class.name} command (schema generation failed)",
                 "properties": {},
-                "additionalProperties": True
+                "additionalProperties": True,
             }
-        
-    def generate(self, title: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None) -> Dict[str, Any]:
+
+    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.
@@ -125,12 +137,12 @@ class CustomOpenAPIGenerator:
         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
         """
@@ -140,26 +152,24 @@ class CustomOpenAPIGenerator:
         # 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
-            },
+            "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
-            }
+                "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"]
         # В тестах ожидается точное совпадение с исходным описанием
@@ -170,37 +180,39 @@ class CustomOpenAPIGenerator:
             # Для обычного использования добавляем информацию о командах и справке
             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": "'
+            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"
+                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"] = {}
-            
+
         # Create ToolDescription if it doesn't exist
         if "ToolDescription" not in schema["components"]["schemas"]:
             schema["components"]["schemas"]["ToolDescription"] = {
@@ -208,25 +220,19 @@ class CustomOpenAPIGenerator:
                 "title": "Tool Description",
                 "description": "Description of the microservice tool",
                 "properties": {
-                    "name": {
-                        "type": "string",
-                        "description": "Name of the tool"
-                    },
+                    "name": {"type": "string", "description": "Name of the tool"},
                     "description": {
                         "type": "string",
-                        "description": "Description of the tool"
+                        "description": "Description of the tool",
                     },
-                    "version": {
-                        "type": "string",
-                        "description": "Tool version"
-                    }
+                    "version": {"type": "string", "description": "Tool version"},
                 },
-                "required": ["name", "description"]
+                "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"
@@ -237,9 +243,9 @@ class CustomOpenAPIGenerator:
         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",
@@ -247,33 +253,33 @@ class CustomOpenAPIGenerator:
             "properties": {
                 "without_params": {
                     "type": "object",
-                    "description": "Get a list of all commands"
+                    "description": "Get a list of all commands",
                 },
                 "with_params": {
                     "type": "object",
-                    "description": "Get information about a specific command"
-                }
+                    "description": "Get information about a specific command",
+                },
             },
-            "example": help_examples
+            "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
+            "items": {"type": "string"},
+            "example": command_names,
         }
-        
+
         if version:
             schema["info"]["version"] = version
 
         # Add commands to schema
         self._add_commands_to_schema(schema)
 
-        logger.debug(f"Generated OpenAPI schema with {len(registry.get_all_commands())} commands")
+        logger.debug(
+            f"Generated OpenAPI schema with {len(registry.get_all_commands())} commands"
+        )
 
         return schema
 
@@ -287,18 +293,18 @@ def custom_openapi(app: FastAPI) -> Dict[str, Any]:
     RU:
     Создаёт кастомную OpenAPI-схему для FastAPI-приложения.
     Передаёт параметры title, description и version из приложения в генератор схемы.
-    
+
     Args:
         app: The FastAPI application / FastAPI-приложение
-        
+
     Returns:
         Dict containing the custom OpenAPI schema / Словарь с кастомной OpenAPI-схемой
     """
     generator = CustomOpenAPIGenerator()
     openapi_schema = generator.generate(
-        title=getattr(app, 'title', None),
-        description=getattr(app, 'description', None),
-        version=getattr(app, 'version', None)
+        title=getattr(app, "title", None),
+        description=getattr(app, "description", None),
+        version=getattr(app, "version", None),
     )
 
     # Cache the schema
@@ -311,10 +317,12 @@ def custom_openapi(app: FastAPI) -> Dict[str, Any]:
 _openapi_generators: Dict[str, Callable] = {}
 
 
-def register_openapi_generator(name: str, generator_func: Callable[[FastAPI], Dict[str, Any]]) -> None:
+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.
@@ -326,10 +334,10 @@ def register_openapi_generator(name: str, generator_func: Callable[[FastAPI], Di
 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.
     """
@@ -339,7 +347,7 @@ def get_openapi_generator(name: str) -> Optional[Callable[[FastAPI], Dict[str, A
 def list_openapi_generators() -> List[str]:
     """
     Get list of registered OpenAPI generators.
-    
+
     Returns:
         List of generator names.
     """
@@ -357,10 +365,10 @@ def custom_openapi_with_fallback(app: FastAPI) -> Dict[str, Any]:
     Создаёт кастомную OpenAPI-схему для FastAPI-приложения.
     Сначала проверяет наличие кастомных генераторов, затем использует встроенный генератор.
     Передаёт параметры title, description и version из приложения в генератор схемы.
-    
+
     Args:
         app: The FastAPI application / FastAPI-приложение
-        
+
     Returns:
         Dict containing the custom OpenAPI schema / Словарь с кастомной OpenAPI-схемой
     """
@@ -371,7 +379,7 @@ def custom_openapi_with_fallback(app: FastAPI) -> Dict[str, Any]:
         generator_func = _openapi_generators[generator_name]
         logger.debug(f"Using custom OpenAPI generator: {generator_name}")
         return generator_func(app)
-    
+
     # Fall back to default generator
     logger.debug("Using default OpenAPI generator")
-    return custom_openapi(app) 
+    return custom_openapi(app)

mcp_proxy_adapter/examples/basic_framework/main.py

@@ -9,13 +9,18 @@ email: vasilyvz@gmail.com
 import sys
 import argparse
 from pathlib import Path
+
 # Add the framework to the path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 from mcp_proxy_adapter.core.app_factory import create_and_run_server
+
+
 def main():
     """Main entry point for the basic framework example."""
     parser = argparse.ArgumentParser(description="Basic Framework Example")
-    parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
+    parser.add_argument(
+        "--config", "-c", required=True, help="Path to configuration file"
+    )
     parser.add_argument("--host", help="Server host")
     parser.add_argument("--port", type=int, help="Server port")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
@@ -38,7 +43,9 @@ def main():
         description="Basic MCP Proxy Adapter with minimal configuration",
         version="1.0.0",
         host=config_overrides.get("host", "0.0.0.0"),
-        log_level="debug" if config_overrides.get("debug", False) else "info"
+        log_level="debug" if config_overrides.get("debug", False) else "info",
     )
+
+
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/commands/__init__.py

@@ -2,4 +2,4 @@
 
 This package contains example command implementations demonstrating
 various patterns for creating custom commands in MCP Proxy Adapter.
-"""
+"""