mcp-proxy-adapter 4.1.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

mcp_proxy_adapter/commands/base.py

@@ -13,7 +13,6 @@ from mcp_proxy_adapter.core.errors import (
     CommandError, InternalError, InvalidParamsError, NotFoundError, ValidationError
 )
 from mcp_proxy_adapter.core.logging import logger
-from .hooks import hooks, HookContext
 
 
 T = TypeVar("T", bound=CommandResult)
@@ -26,6 +25,20 @@ class Command(ABC):
     
     # Command name for registration
     name: ClassVar[str]
+    # Command version (default: 0.1)
+    version: ClassVar[str] = "0.1"
+    # Plugin filename
+    plugin: ClassVar[str] = ""
+    # Command description
+    descr: ClassVar[str] = ""
+    # Command category
+    category: ClassVar[str] = ""
+    # Command author
+    author: ClassVar[str] = ""
+    # Author email
+    email: ClassVar[str] = ""
+    # Source URL
+    source_url: ClassVar[str] = ""
     # Result class
     result_class: ClassVar[Type[CommandResult]]
     
@@ -68,8 +81,7 @@ class Command(ABC):
             return cls.result_class.get_schema()
         return {}
     
-    @classmethod
-    def validate_params(cls, params: Dict[str, Any]) -> Dict[str, Any]:
+    def validate_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
         """
         Validate command parameters.
         
@@ -100,9 +112,39 @@ class Command(ABC):
                 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)}")
+        
+        # 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}
+                )
                 
-        # This is a simple implementation that can be overridden by subclasses
-        # In real implementation this method would validate parameters against the schema
         return validated_params
     
     @classmethod
@@ -134,35 +176,17 @@ class Command(ABC):
             if kwargs is None:
                 kwargs = {}
                 
-            # Parameters validation
-            validated_params = cls.validate_params(kwargs)
-            
-            # Execute before hooks
-            hook_context = hooks.execute_before_hooks(command_name, validated_params)
-            
-            # Check if standard processing should be skipped
-            if not hook_context.standard_processing:
-                logger.debug(f"Standard processing skipped for command {command_name} due to hook")
-                # Return the params as result if standard processing is disabled
-                return SuccessResult(data=validated_params)
-            
             # Get command with priority (custom commands first, then built-in)
-            priority_command_class = registry.get_priority_command(command_name)
-            if priority_command_class is None:
+            command_class = registry.get_command(command_name)
+            if command_class is None:
                 raise NotFoundError(f"Command '{command_name}' not found")
             
-            # Check if we have a registered instance for this command
-            if registry.has_instance(command_name):
-                # Use existing instance with dependencies
-                command = registry.get_command_instance(command_name)
-                result = await command.execute(**validated_params)
-            else:
-                # Create new instance for commands without dependencies
-                command = priority_command_class()
-                result = await command.execute(**validated_params)
+            # Create new instance and validate parameters
+            command = command_class()
+            validated_params = command.validate_params(kwargs)
             
-            # Execute after hooks
-            hooks.execute_after_hooks(command_name, validated_params, result)
+            # Execute command with validated parameters
+            result = await command.execute(**validated_params)
             
             logger.debug(f"Command {cls.__name__} executed successfully")
             return result
@@ -271,6 +295,13 @@ class Command(ABC):
         
         return {
             "name": cls.name,
+            "version": cls.version,
+            "plugin": cls.plugin,
+            "descr": cls.descr,
+            "category": cls.category,
+            "author": cls.author,
+            "email": cls.email,
+            "source_url": cls.source_url,
             "summary": summary,
             "description": description,
             "params": param_info,

mcp_proxy_adapter/commands/builtin_commands.py

@@ -0,0 +1,89 @@
+"""
+Module for registering built-in framework commands.
+
+This module contains the procedure for adding predefined commands
+that are part of the framework.
+"""
+
+from typing import List
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.help_command import HelpCommand
+from mcp_proxy_adapter.commands.health_command import HealthCommand
+from mcp_proxy_adapter.commands.config_command import ConfigCommand
+from mcp_proxy_adapter.commands.reload_command import ReloadCommand
+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.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,
+        ConfigCommand,
+        ReloadCommand,
+        SettingsCommand,
+        LoadCommand,
+        UnloadCommand,
+        PluginsCommand,
+        TransportManagementCommand,
+        ProxyRegistrationCommand
+    ]
+    
+    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 = 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")
+                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.info(f"Registered {registered_count} built-in framework commands")
+    return registered_count
+
+
+def get_builtin_commands_list() -> list:
+    """
+    Get list of all built-in command classes.
+    
+    Returns:
+        List of built-in command classes.
+    """
+    return [
+        HelpCommand,
+        HealthCommand,
+        ConfigCommand,
+        ReloadCommand,
+        SettingsCommand,
+        LoadCommand,
+        UnloadCommand,
+        PluginsCommand,
+        TransportManagementCommand,
+        ProxyRegistrationCommand
+    ]