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

mcp_proxy_adapter/schema.py

@@ -1,257 +0,0 @@
-"""
-Module for optimizing OpenAPI schema for MCP Proxy.
-"""
-from typing import Dict, Any, List, Optional
-
-class SchemaOptimizer:
-    """
-    OpenAPI schema optimizer for use with MCP Proxy.
-    
-    This class transforms a standard OpenAPI schema into a format
-    more suitable for use with MCP Proxy and AI models.
-    """
-    
-    def optimize(
-        self, 
-        schema: Dict[str, Any], 
-        cmd_endpoint: str,
-        commands_info: Dict[str, Dict[str, Any]]
-    ) -> Dict[str, Any]:
-        """
-        Optimizes OpenAPI schema for MCP Proxy.
-        
-        Args:
-            schema: Original OpenAPI schema
-            cmd_endpoint: Path for universal JSON-RPC endpoint
-            commands_info: Information about registered commands
-            
-        Returns:
-            Dict[str, Any]: Optimized schema
-        """
-        # Create a new schema in a format compatible with the proxy
-        optimized = {
-            "openapi": "3.0.2",
-            "info": {
-                "title": "Command Registry API",
-                "description": "API for executing commands through MCPProxy",
-                "version": "1.0.0"
-            },
-            "paths": {
-                cmd_endpoint: {
-                    "post": {
-                        "summary": "Execute command",
-                        "description": "Universal endpoint for executing various commands",
-                        "operationId": "execute_command",
-                        "requestBody": {
-                            "content": {
-                                "application/json": {
-                                    "schema": {
-                                        "$ref": "#/components/schemas/CommandRequest"
-                                    },
-                                    "examples": {}
-                                }
-                            },
-                            "required": True
-                        },
-                        "responses": {
-                            "200": {
-                                "description": "Command executed successfully",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {
-                                            "$ref": "#/components/schemas/CommandResponse"
-                                        }
-                                    }
-                                }
-                            },
-                            "400": {
-                                "description": "Error in request or during command execution",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {
-                                            "type": "object",
-                                            "properties": {
-                                                "detail": {
-                                                    "type": "string",
-                                                    "description": "Error description"
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            },
-            "components": {
-                "schemas": {
-                    "CommandRequest": {
-                        "title": "CommandRequest",
-                        "description": "Command execution request",
-                        "type": "object",
-                        "required": ["command"],
-                        "properties": {
-                            "command": {
-                                "title": "Command",
-                                "description": "Command to execute",
-                                "type": "string",
-                                "enum": list(commands_info.keys())
-                            },
-                            "params": {
-                                "title": "Parameters",
-                                "description": "Command parameters, depend on command type",
-                                "oneOf": []
-                            }
-                        }
-                    },
-                    "CommandResponse": {
-                        "title": "CommandResponse",
-                        "description": "Command execution response",
-                        "type": "object",
-                        "required": ["result"],
-                        "properties": {
-                            "result": {
-                                "title": "Result",
-                                "description": "Command execution result"
-                            }
-                        }
-                    }
-                },
-                "examples": {}
-            }
-        }
-        
-        # Add parameter schemas and examples for each command
-        for cmd_name, cmd_info in commands_info.items():
-            param_schema_name = f"{cmd_name.capitalize()}Params"
-            params = cmd_info.get("params", {})
-            has_params = bool(params)
-
-            # Define parameter schema (даже если params пустой, схема будет пустым объектом)
-            param_schema = {
-                "title": param_schema_name,
-                "description": f"Parameters for command {cmd_name}",
-                "type": "object",
-                "properties": {},
-            }
-            required_params = []
-            example_params = {}
-
-            for param_name, param_info in params.items():
-                param_property = {
-                    "title": param_name.capitalize(),
-                    "type": param_info.get("type", "string"),
-                    "description": param_info.get("description", "")
-                }
-                if "default" in param_info:
-                    param_property["default"] = param_info["default"]
-                if "enum" in param_info:
-                    param_property["enum"] = param_info["enum"]
-                param_schema["properties"][param_name] = param_property
-                if param_info.get("required", False):
-                    required_params.append(param_name)
-                if "example" in param_info:
-                    example_params[param_name] = param_info["example"]
-                elif "default" in param_info:
-                    example_params[param_name] = param_info["default"]
-                elif param_info.get("type") == "string":
-                    example_params[param_name] = "example_value"
-                elif param_info.get("type") == "integer":
-                    example_params[param_name] = 1
-                elif param_info.get("type") == "boolean":
-                    example_params[param_name] = False
-
-            if required_params:
-                param_schema["required"] = required_params
-
-            # Добавляем схему параметров всегда, даже если она пустая
-            optimized["components"]["schemas"][param_schema_name] = param_schema
-
-            # Добавляем $ref на схему параметров в oneOf всегда
-            optimized["components"]["schemas"]["CommandRequest"]["properties"]["params"]["oneOf"].append({
-                "$ref": f"#/components/schemas/{param_schema_name}"
-            })
-
-            # Пример использования команды
-            example_id = f"{cmd_name}_example"
-            example = {
-                "summary": f"Example of using command {cmd_name}",
-                "value": {
-                    "command": cmd_name
-                }
-            }
-            if has_params:
-                example["value"]["params"] = example_params
-            optimized["components"]["examples"][example_id] = example
-            optimized["paths"][cmd_endpoint]["post"]["requestBody"]["content"]["application/json"]["examples"][example_id] = {
-                "$ref": f"#/components/examples/{example_id}"
-            }
-
-        # Для команд без параметров добавляем type: null в oneOf
-        optimized_oneof = optimized["components"]["schemas"]["CommandRequest"]["properties"]["params"]["oneOf"]
-        optimized_oneof.append({"type": "null"})
-
-        # Add tool descriptions to schema for AI models
-        self._add_tool_descriptions(optimized, commands_info)
-        return optimized
-    
-    def _add_tool_descriptions(
-        self, 
-        schema: Dict[str, Any],
-        commands_info: Dict[str, Dict[str, Any]]
-    ) -> None:
-        """
-        Adds AI tool descriptions to the schema.
-        
-        This method enhances the OpenAPI schema with special descriptions
-        for better integration with AI models and MCPProxy.
-        
-        Args:
-            schema: OpenAPI schema to enhance
-            commands_info: Information about registered commands
-        """
-        # Add AI tool descriptions to x-mcp-tools
-        schema["x-mcp-tools"] = []
-        
-        for cmd_name, cmd_info in commands_info.items():
-            # Create tool description
-            tool = {
-                "name": f"mcp_{cmd_name}",  # Add mcp_ prefix to command name
-                "description": cmd_info.get("description", "") or cmd_info.get("summary", ""),
-                "parameters": {
-                    "type": "object",
-                    "properties": {},
-                    "required": []
-                }
-            }
-            
-            # Add parameters
-            for param_name, param_info in cmd_info.get("params", {}).items():
-                # Convert parameter to JSON Schema format
-                param_schema = {}
-                
-                # Parameter type
-                param_schema["type"] = param_info.get("type", "string")
-                
-                # Description
-                if "description" in param_info:
-                    param_schema["description"] = param_info["description"]
-                
-                # Default value
-                if "default" in param_info:
-                    param_schema["default"] = param_info["default"]
-                
-                # Possible values
-                if "enum" in param_info:
-                    param_schema["enum"] = param_info["enum"]
-                
-                # Add parameter to schema
-                tool["parameters"]["properties"][param_name] = param_schema
-                
-                # If parameter is required, add to required list
-                if param_info.get("required", False):
-                    tool["parameters"]["required"].append(param_name)
-            
-            # Add tool to list
-            schema["x-mcp-tools"].append(tool) 

mcp_proxy_adapter/testing_utils.py

@@ -1,112 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Test utilities for MCP Proxy Adapter: mock dispatcher, registry, and OpenAPI generator.
-Can be used in examples and tests.
-"""
-
-def success_command(value: int = 1) -> dict:
-    return {"result": value * 2}
-
-def error_command() -> None:
-    raise ValueError("Test error")
-
-def param_command(required_param: str, optional_param: int = 0) -> dict:
-    return {"required": required_param, "optional": optional_param}
-
-def complex_param_command(array_param: list, object_param: dict, bool_param: bool = True) -> dict:
-    return {
-        "array_length": len(array_param),
-        "object_keys": list(object_param.keys()),
-        "bool_value": bool_param
-    }
-
-def type_error_command(param: int) -> dict:
-    return {"param": param + 1}
-
-class MockDispatcher:
-    def __init__(self):
-        self.commands = {
-            "success": success_command,
-            "error": error_command,
-            "param": param_command,
-            "execute": self.execute_from_params
-        }
-        self.commands_info = {
-            "success": {
-                "description": "Successful command",
-                "params": {"value": {"type": "integer", "description": "Input value", "required": False, "default": 1}}
-            },
-            "error": {"description": "Command with error", "params": {}},
-            "param": {
-                "description": "Command with parameters",
-                "params": {
-                    "required_param": {"type": "string", "description": "Required parameter", "required": True},
-                    "optional_param": {"type": "integer", "description": "Optional parameter", "required": False, "default": 0}
-                }
-            },
-            "execute": {
-                "description": "Universal command for executing other commands",
-                "params": {"query": {"type": "string", "description": "Command or query to execute", "required": False}}
-            },
-            "complex_param": {
-                "description": "Command with complex parameters",
-                "params": {
-                    "array_param": {"type": "array", "description": "Array of values", "required": True},
-                    "object_param": {"type": "object", "description": "Object", "required": True},
-                    "bool_param": {"type": "boolean", "description": "Boolean value", "required": False, "default": True}
-                }
-            },
-            "type_error": {
-                "description": "Command that will raise TypeError",
-                "params": {"param": {"type": "integer", "description": "Integer parameter", "required": True}}
-            }
-        }
-
-    def execute_from_params(self, **params):
-        if "query" in params and params["query"] in self.commands:
-            command = params.pop("query")
-            return self.execute(command, **params)
-        return {"available_commands": self.get_valid_commands(), "received_params": params}
-
-    def execute(self, command, **params):
-        if command not in self.commands:
-            raise KeyError(f"Unknown command: {command}")
-        return self.commands[command](**params)
-
-    def get_valid_commands(self):
-        return list(self.commands.keys())
-
-    def get_command_info(self, command):
-        return self.commands_info.get(command)
-
-    def get_commands_info(self):
-        return self.commands_info
-
-class MockRegistry:
-    def __init__(self, use_openapi_generator=False):
-        self.dispatcher = MockDispatcher()
-        self.generators = []
-        self.use_openapi_generator = use_openapi_generator
-
-    def get_commands_info(self):
-        return self.dispatcher.get_commands_info()
-
-    def add_generator(self, generator):
-        self.generators.append(generator)
-        if hasattr(generator, 'set_dispatcher'):
-            generator.set_dispatcher(self.dispatcher)
-
-class MockOpenApiGenerator:
-    def __init__(self, **kwargs):
-        self.dispatcher = None
-        self.kwargs = kwargs
-
-    def set_dispatcher(self, dispatcher):
-        self.dispatcher = dispatcher
-
-    def generate_schema(self):
-        return {
-            "openapi": "3.0.0",
-            "info": {"title": "Mock API", "version": "1.0.0"},
-            "paths": {}
-        } 

mcp_proxy_adapter/validators/__init__.py

@@ -1 +0,0 @@
- 

mcp_proxy_adapter/validators/docstring_validator.py

@@ -1,75 +0,0 @@
-"""
-Validator for checking the correspondence between docstrings and function signatures.
-"""
-import inspect
-from typing import Dict, Any, Optional, Callable, List, Tuple, get_type_hints
-import docstring_parser
-
-class DocstringValidator:
-    """
-    Validator for checking the correspondence between docstrings and handler functions.
-    
-    This class verifies that function docstrings match their signatures,
-    contain all necessary sections, and describe all parameters.
-    """
-    
-    def validate(self, handler: Callable, command_name: str, metadata: Dict[str, Any]) -> Tuple[bool, List[str]]:
-        """
-        Validates the function's docstring against its formal parameters.
-        
-        Args:
-            handler: Command handler function
-            command_name: Command name
-            metadata: Command metadata
-            
-        Returns:
-            Tuple[bool, List[str]]: Validity flag and list of errors
-        """
-        errors = []
-        
-        # Get formal parameters of the function
-        sig = inspect.signature(handler)
-        formal_params = list(sig.parameters.keys())
-        
-        # Skip self parameter for methods
-        if formal_params and formal_params[0] == 'self':
-            formal_params = formal_params[1:]
-            
-        # Parse docstring
-        docstring = handler.__doc__ or ""
-        parsed_doc = docstring_parser.parse(docstring)
-        
-        # Check for function description
-        if not parsed_doc.short_description and not parsed_doc.long_description:
-            errors.append(f"Missing function description")
-        
-        # Get parameters from docstring
-        doc_params = {param.arg_name: param for param in parsed_doc.params}
-        
-        # Check that all formal parameters are described in the docstring
-        for param in formal_params:
-            # Skip special parameters
-            if param in ('params', 'kwargs'):
-                continue
-                
-            if param not in doc_params:
-                errors.append(f"Parameter '{param}' is not described in the function docstring")
-        
-        # Check for returns in docstring
-        if not parsed_doc.returns and not any(t.type_name == 'Returns' for t in parsed_doc.meta):
-            errors.append(f"Missing return value description in the function docstring")
-        
-        # Check for type annotations
-        try:
-            type_hints = get_type_hints(handler)
-            for param in formal_params:
-                # Skip special parameters
-                if param in ('params', 'kwargs'):
-                    continue
-                    
-                if param not in type_hints:
-                    errors.append(f"Missing type annotation for parameter '{param}' in function {command_name}")
-        except Exception as e:
-            errors.append(f"Error getting type hints: {str(e)}")
-        
-        return len(errors) == 0, errors 

mcp_proxy_adapter/validators/metadata_validator.py

@@ -1,76 +0,0 @@
-"""
-Validator for checking command metadata against function signatures.
-"""
-import inspect
-from typing import Dict, Any, Optional, Callable, List, Tuple
-
-class MetadataValidator:
-    """
-    Validator for checking handler function metadata.
-    
-    This class verifies that command metadata matches function signatures,
-    and all parameters are correctly described.
-    """
-    
-    def validate(self, handler: Callable, command_name: str, metadata: Dict[str, Any]) -> Tuple[bool, List[str]]:
-        """
-        Checks if metadata matches function's formal parameters.
-        
-        Args:
-            handler: Command handler function
-            command_name: Command name
-            metadata: Command metadata
-            
-        Returns:
-            Tuple[bool, List[str]]: Validity flag and list of errors
-        """
-        errors = []
-        
-        # Check presence of main fields in metadata
-        if not metadata.get('description'):
-            errors.append(f"Missing description for command '{command_name}'")
-            
-        # Get function's formal parameters
-        sig = inspect.signature(handler)
-        formal_params = list(sig.parameters.keys())
-        
-        # Skip self parameter for methods
-        if formal_params and formal_params[0] == 'self':
-            formal_params = formal_params[1:]
-            
-        # Check presence of parameters in metadata
-        if 'parameters' not in metadata or not isinstance(metadata['parameters'], dict):
-            errors.append(f"Parameters are missing or incorrectly defined in metadata for command '{command_name}'")
-            return False, errors
-            
-        meta_params = metadata['parameters']
-        
-        # Check that all formal parameters are in metadata
-        for param in formal_params:
-            # Skip special parameters
-            if param in ('params', 'kwargs'):
-                continue
-                
-            if param not in meta_params:
-                errors.append(f"Parameter '{param}' is not described in metadata for command '{command_name}'")
-                continue
-                
-            param_info = meta_params[param]
-            
-            # Check presence of required fields for parameter
-            if not isinstance(param_info, dict):
-                errors.append(f"Incorrect format for parameter '{param}' description in metadata for command '{command_name}'")
-                continue
-                
-            if 'type' not in param_info:
-                errors.append(f"Type is not specified for parameter '{param}' in metadata for command '{command_name}'")
-                
-            if 'description' not in param_info:
-                errors.append(f"Description is not specified for parameter '{param}' in metadata for command '{command_name}'")
-        
-        # Check that there are no extra parameters in metadata
-        for param in meta_params:
-            if param not in formal_params and param not in ('params', 'kwargs'):
-                errors.append(f"Extra parameter '{param}' in metadata for command '{command_name}'")
-        
-        return len(errors) == 0, errors