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

mcp_proxy_adapter/commands/base.py

@@ -10,7 +10,11 @@ from docstring_parser import parse
 
 from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
 from mcp_proxy_adapter.core.errors import (
-    CommandError, InternalError, InvalidParamsError, NotFoundError, ValidationError
+    CommandError,
+    InternalError,
+    InvalidParamsError,
+    NotFoundError,
+    ValidationError,
 )
 from mcp_proxy_adapter.core.logging import logger
 
@@ -22,7 +26,7 @@ class Command(ABC):
     """
     Base abstract class for all commands.
     """
-    
+
     # Command name for registration
     name: ClassVar[str]
     # Command version (default: 0.1)
@@ -41,112 +45,114 @@ class Command(ABC):
     source_url: ClassVar[str] = ""
     # Result class
     result_class: ClassVar[Type[CommandResult]]
-    
+
     @abstractmethod
     async def execute(self, **kwargs) -> CommandResult:
         """
         Execute command with the specified parameters.
-        
+
         Args:
             **kwargs: Command parameters including optional 'context' parameter.
-            
+
         Returns:
             Command result.
         """
         pass
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for command parameters.
-        
+
         Returns:
             JSON schema.
         """
-        return {
-            "type": "object",
-            "properties": {},
-            "additionalProperties": False
-        }
-        
+        return {"type": "object", "properties": {}, "additionalProperties": False}
+
     @classmethod
     def get_result_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for command result.
-        
+
         Returns:
             JSON schema.
         """
         if hasattr(cls, "result_class") and cls.result_class:
             return cls.result_class.get_schema()
         return {}
-    
+
     def validate_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
         """
         Validate command parameters.
-        
+
         Args:
             params: Parameters to validate.
-            
+
         Returns:
             Validated parameters.
-            
+
         Raises:
             ValidationError: If parameters are invalid.
         """
         # Ensure params is a dictionary, even if None was passed
         if params is None:
             params = {}
-            
+
         # Create a copy to avoid modifying the input dictionary during iteration
         validated_params = params.copy()
-        
+
         # Handle None values and empty strings in parameters
         for key, value in list(validated_params.items()):
             # Process None values or empty strings - this helps with JavaScript null/undefined conversions
-            if value is None or (isinstance(value, str) and value.lower() in ["null", "none", ""]):
+            if value is None or (
+                isinstance(value, str) and value.lower() in ["null", "none", ""]
+            ):
                 # For commands that specifically handle None values, keep the parameter
                 # (like help), keep the parameter but ensure it's a proper Python None
-                if key in ["cmdname"]:  # список параметров, для которых None является допустимым значением
+                if key in [
+                    "cmdname"
+                ]:  # список параметров, для которых None является допустимым значением
                     validated_params[key] = None
                 else:
                     # For most parameters, remove None values to avoid issues
                     del validated_params[key]
-        
+
         # Get command schema to validate parameters
         schema = self.get_schema()
         if schema and "properties" in schema:
             allowed_properties = schema["properties"].keys()
-            
+
             # Filter out parameters that are not in the schema
             invalid_params = []
             for param_name in list(validated_params.keys()):
                 if param_name not in allowed_properties:
                     invalid_params.append(param_name)
                     del validated_params[param_name]
-            
+
             # Log warning about invalid parameters
             if invalid_params:
-                logger.warning(f"Command {self.__class__.__name__} received invalid parameters: {invalid_params}. "
-                             f"Allowed parameters: {list(allowed_properties)}")
-        
+                logger.warning(
+                    f"Command {self.__class__.__name__} received invalid parameters: {invalid_params}. "
+                    f"Allowed parameters: {list(allowed_properties)}"
+                )
+
         # Validate required parameters based on command schema
         if schema and "required" in schema:
             required_params = schema["required"]
             missing_params = []
-            
+
             for param in required_params:
                 if param not in validated_params:
                     missing_params.append(param)
-            
+
             if missing_params:
                 raise ValidationError(
                     f"Missing required parameters: {', '.join(missing_params)}",
-                    data={"missing_parameters": missing_params}
+                    data={"missing_parameters": missing_params},
                 )
-                
+
         return validated_params
-    
+
     @classmethod
     async def run(cls, **kwargs) -> CommandResult:
         """
@@ -159,14 +165,14 @@ class Command(ABC):
             Command result.
         """
         # Extract context from kwargs
-        context = kwargs.pop('context', {}) if 'context' in kwargs else {}
-        
+        context = kwargs.pop("context", {}) if "context" in kwargs else {}
+
         try:
             logger.debug(f"Running command {cls.__name__} with params: {kwargs}")
-            
+
             # Import registry here to avoid circular imports
             from mcp_proxy_adapter.commands.command_registry import registry
-            
+
             # Get command name
             if not hasattr(cls, "name") or not cls.name:
                 command_name = cls.__name__.lower()
@@ -174,65 +180,45 @@ class Command(ABC):
                     command_name = command_name[:-7]
             else:
                 command_name = cls.name
-            
+
             # Ensure kwargs is never None
             if kwargs is None:
                 kwargs = {}
-                
+
             # Get command with priority (custom commands first, then built-in)
             command_class = registry.get_command(command_name)
             if command_class is None:
                 raise NotFoundError(f"Command '{command_name}' not found")
-            
+
             # Create new instance and validate parameters
             command = command_class()
             validated_params = command.validate_params(kwargs)
-            
+
             # Execute command with validated parameters and context
             result = await command.execute(**validated_params, context=context)
-            
+
             logger.debug(f"Command {cls.__name__} executed successfully")
             return result
         except ValidationError as e:
             # Ошибка валидации параметров
             logger.error(f"Validation error in command {cls.__name__}: {e}")
-            return ErrorResult(
-                message=str(e), 
-                code=e.code, 
-                details=e.data
-            )
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
         except InvalidParamsError as e:
             # Ошибка в параметрах команды
             logger.error(f"Invalid parameters error in command {cls.__name__}: {e}")
-            return ErrorResult(
-                message=str(e), 
-                code=e.code, 
-                details=e.data
-            )
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
         except NotFoundError as e:
             # Ресурс не найден
             logger.error(f"Resource not found error in command {cls.__name__}: {e}")
-            return ErrorResult(
-                message=str(e), 
-                code=e.code, 
-                details=e.data
-            )
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
         except TimeoutError as e:
             # Превышено время ожидания
             logger.error(f"Timeout error in command {cls.__name__}: {e}")
-            return ErrorResult(
-                message=str(e), 
-                code=e.code, 
-                details=e.data
-            )
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
         except CommandError as e:
             # Ошибка выполнения команды
             logger.error(f"Command error in {cls.__name__}: {e}")
-            return ErrorResult(
-                message=str(e), 
-                code=e.code, 
-                details=e.data
-            )
+            return ErrorResult(message=str(e), code=e.code, details=e.data)
         except Exception as e:
             # Непредвиденная ошибка
             logger.exception(f"Unexpected error executing command {cls.__name__}: {e}")
@@ -240,9 +226,9 @@ class Command(ABC):
             return ErrorResult(
                 message=internal_error.message,
                 code=internal_error.code,
-                details={"original_error": str(e)}
+                details={"original_error": str(e)},
             )
-    
+
     @classmethod
     def get_param_info(cls) -> Dict[str, Dict[str, Any]]:
         """
@@ -253,49 +239,49 @@ class Command(ABC):
         """
         signature = inspect.signature(cls.execute)
         params = {}
-        
+
         for name, param in signature.parameters.items():
             if name == "self":
                 continue
-                
+
             param_info = {
                 "name": name,
-                "required": param.default == inspect.Parameter.empty
+                "required": param.default == inspect.Parameter.empty,
             }
-            
+
             if param.annotation != inspect.Parameter.empty:
                 param_info["type"] = str(param.annotation)
-            
+
             if param.default != inspect.Parameter.empty:
                 param_info["default"] = param.default
-                
+
             params[name] = param_info
-            
+
         return params
-    
+
     @classmethod
     def get_metadata(cls) -> Dict[str, Any]:
         """
         Returns complete metadata about the command.
-        
+
         Provides a single access point to all command metadata.
-        
+
         Returns:
             Dict with command metadata
         """
         # Get and format docstring
         doc = cls.__doc__ or ""
         description = inspect.cleandoc(doc) if doc else ""
-        
+
         # Extract first line for summary
         summary = description.split("\n")[0] if description else ""
-        
+
         # Get parameters information
         param_info = cls.get_param_info()
-        
+
         # Generate examples based on parameters
         examples = cls._generate_examples(param_info)
-        
+
         return {
             "name": cls.name,
             "version": cls.version,
@@ -311,29 +297,35 @@ class Command(ABC):
             "examples": examples,
             "schema": cls.get_schema(),
             "result_schema": cls.get_result_schema(),
-            "result_class": cls.result_class.__name__ if hasattr(cls, "result_class") else None,
+            "result_class": (
+                cls.result_class.__name__ if hasattr(cls, "result_class") else None
+            ),
         }
-    
+
     @classmethod
-    def _generate_examples(cls, params: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _generate_examples(
+        cls, params: Dict[str, Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
         """
         Generates usage examples of the command based on its parameters.
-        
+
         Args:
             params: Information about command parameters
-            
+
         Returns:
             List of examples
         """
         examples = []
-        
+
         # Simple example without parameters, if all parameters are optional
         if not any(param.get("required", False) for param in params.values()):
-            examples.append({
-                "command": cls.name,
-                "description": f"Call {cls.name} command without parameters"
-            })
-        
+            examples.append(
+                {
+                    "command": cls.name,
+                    "description": f"Call {cls.name} command without parameters",
+                }
+            )
+
         # Example with all required parameters
         required_params = {k: v for k, v in params.items() if v.get("required", False)}
         if required_params:
@@ -341,7 +333,7 @@ class Command(ABC):
             for param_name, param_info in required_params.items():
                 # Try to generate sample value based on type
                 param_type = param_info.get("type", "")
-                
+
                 if "str" in param_type:
                     sample_params[param_name] = f"sample_{param_name}"
                 elif "int" in param_type:
@@ -356,13 +348,15 @@ class Command(ABC):
                     sample_params[param_name] = {}
                 else:
                     sample_params[param_name] = "..."
-            
-            examples.append({
-                "command": cls.name,
-                "params": sample_params,
-                "description": f"Call {cls.name} command with required parameters"
-            })
-        
+
+            examples.append(
+                {
+                    "command": cls.name,
+                    "params": sample_params,
+                    "description": f"Call {cls.name} command with required parameters",
+                }
+            )
+
         # Example with all parameters (including optional ones)
         if len(params) > len(required_params):
             all_params = {}
@@ -371,7 +365,7 @@ class Command(ABC):
                 if param_info.get("required", False):
                     # Try to generate sample value based on type
                     param_type = param_info.get("type", "")
-                    
+
                     if "str" in param_type:
                         all_params[param_name] = f"sample_{param_name}"
                     elif "int" in param_type:
@@ -392,7 +386,7 @@ class Command(ABC):
                         all_params[param_name] = param_info["default"]
                     else:
                         param_type = param_info.get("type", "")
-                        
+
                         if "str" in param_type:
                             all_params[param_name] = f"optional_{param_name}"
                         elif "int" in param_type:
@@ -407,11 +401,13 @@ class Command(ABC):
                             all_params[param_name] = {}
                         else:
                             all_params[param_name] = None
-            
-            examples.append({
-                "command": cls.name,
-                "params": all_params,
-                "description": f"Call {cls.name} command with all parameters"
-            })
-        
-        return examples
+
+            examples.append(
+                {
+                    "command": cls.name,
+                    "params": all_params,
+                    "description": f"Call {cls.name} command with all parameters",
+                }
+            )
+
+        return examples

mcp_proxy_adapter/commands/builtin_commands.py

@@ -15,8 +15,12 @@ from mcp_proxy_adapter.commands.settings_command import SettingsCommand
 from mcp_proxy_adapter.commands.load_command import LoadCommand
 from mcp_proxy_adapter.commands.unload_command import UnloadCommand
 from mcp_proxy_adapter.commands.plugins_command import PluginsCommand
-from mcp_proxy_adapter.commands.transport_management_command import TransportManagementCommand
-from mcp_proxy_adapter.commands.proxy_registration_command import ProxyRegistrationCommand
+from mcp_proxy_adapter.commands.transport_management_command import (
+    TransportManagementCommand,
+)
+from mcp_proxy_adapter.commands.proxy_registration_command import (
+    ProxyRegistrationCommand,
+)
 from mcp_proxy_adapter.commands.echo_command import EchoCommand
 from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
 from mcp_proxy_adapter.core.logging import logger
@@ -25,12 +29,12 @@ from mcp_proxy_adapter.core.logging import logger
 def register_builtin_commands() -> int:
     """
     Register all built-in framework commands.
-    
+
     Returns:
         Number of built-in commands registered.
     """
     logger.debug("Registering built-in framework commands...")
-    
+
     builtin_commands = [
         HelpCommand,
         HealthCommand,
@@ -43,31 +47,37 @@ def register_builtin_commands() -> int:
         TransportManagementCommand,
         ProxyRegistrationCommand,
         EchoCommand,
-        RoleTestCommand
+        RoleTestCommand,
     ]
-    
+
     registered_count = 0
-    
+
     for command_class in builtin_commands:
         try:
             # Get command name for logging
-            command_name = getattr(command_class, 'name', command_class.__name__.lower())
-            if command_name.endswith('command'):
+            command_name = getattr(
+                command_class, "name", command_class.__name__.lower()
+            )
+            if command_name.endswith("command"):
                 command_name = command_name[:-7]
-            
+
             # Check if command already exists (should not happen for built-in)
             if registry.command_exists(command_name):
-                logger.warning(f"Built-in command '{command_name}' already exists, skipping")
+                logger.warning(
+                    f"Built-in command '{command_name}' already exists, skipping"
+                )
                 continue
-            
+
             # Register the command
             registry.register_builtin(command_class)
             registered_count += 1
             logger.debug(f"Registered built-in command: {command_name}")
-            
+
         except Exception as e:
-            logger.error(f"Failed to register built-in command {command_class.__name__}: {e}")
-    
+            logger.error(
+                f"Failed to register built-in command {command_class.__name__}: {e}"
+            )
+
     logger.info(f"Registered {registered_count} built-in framework commands")
     return registered_count
 
@@ -75,7 +85,7 @@ def register_builtin_commands() -> int:
 def get_builtin_commands_list() -> list:
     """
     Get list of all built-in command classes.
-    
+
     Returns:
         List of built-in command classes.
     """
@@ -91,5 +101,5 @@ def get_builtin_commands_list() -> list:
         TransportManagementCommand,
         ProxyRegistrationCommand,
         EchoCommand,
-        RoleTestCommand
-    ] 
+        RoleTestCommand,
+    ]