mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.30__py3-none-any.whl

mcp_proxy_adapter/commands/key_management_command.py

@@ -11,7 +11,6 @@ Version: 1.0.0
 import logging
 import os
 import shutil
-from typing import Dict, List, Optional, Any
 from pathlib import Path
 from datetime import datetime
 
@@ -78,30 +77,6 @@ class KeyResult:
         }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for this result.
-
-        Returns:
-            JSON schema dictionary
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "key_path": {"type": "string", "description": "Path to key file"},
-                "key_type": {"type": "string", "description": "Type of key"},
-                "key_size": {"type": "integer", "description": "Key size in bits"},
-                "created_date": {"type": "string", "description": "Key creation date"},
-                "expiry_date": {"type": "string", "description": "Key expiry date"},
-                "status": {
-                    "type": "string",
-                    "enum": ["valid", "expired", "error"],
-                    "description": "Key status",
-                },
-                "error": {"type": "string", "description": "Error message if any"},
-            },
-            "required": ["key_path", "key_type", "key_size", "status"],
-        }
 
 
 class KeyManagementCommand(Command):

mcp_proxy_adapter/commands/load_command.py

@@ -5,8 +5,8 @@ Module with load command implementation.
 from typing import Dict, Any, Optional, List
 
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
 from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.result import SuccessResult
 
 
 class LoadResult(SuccessResult):
@@ -49,36 +49,15 @@ class LoadResult(SuccessResult):
 
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result validation.
-
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
         return {
             "type": "object",
             "properties": {
-                "data": {
-                    "type": "object",
-                    "properties": {
-                        "success": {"type": "boolean"},
-                        "commands_loaded": {"type": "integer"},
-                        "loaded_commands": {
-                            "type": "array",
-                            "items": {"type": "string"},
-                        },
-                        "source": {"type": "string"},
-                        "error": {"type": "string"},
-                    },
-                    "required": [
-                        "success",
-                        "commands_loaded",
-                        "loaded_commands",
-                        "source",
-                    ],
-                }
+                "success": {"type": "boolean"},
+                "commands_loaded": {"type": "integer"},
+                "loaded_commands": {"type": "array", "items": {"type": "string"}},
+                "source": {"type": "string"},
+                "error": {"type": "string"},
             },
-            "required": ["data"],
         }
 
 
@@ -135,60 +114,10 @@ class LoadCommand(Command):
 
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters.
-
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
         return {
             "type": "object",
             "properties": {
-                "source": {
-                    "type": "string",
-                    "description": "Source path or URL to load command from (must end with '_command.py')",
-                    "examples": [
-                        "./my_command.py",
-                        "https://example.com/remote_command.py",
-                    ],
-                }
+                "source": {"type": "string", "description": "Path or URL to command file"}
             },
             "required": ["source"],
         }
-
-    @classmethod
-    def _generate_examples(
-        cls, params: Dict[str, Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        """
-        Generate custom examples for load command.
-
-        Args:
-            params: Information about command parameters
-
-        Returns:
-            List of examples
-        """
-        examples = [
-            {
-                "command": cls.name,
-                "params": {"source": "./custom_command.py"},
-                "description": "Load a command from local file system",
-            },
-            {
-                "command": cls.name,
-                "params": {
-                    "source": "https://raw.githubusercontent.com/user/repo/main/remote_command.py"
-                },
-                "description": "Load a command from GitHub raw content",
-            },
-            {
-                "command": cls.name,
-                "params": {
-                    "source": "https://example.com/api/commands/test_command.py"
-                },
-                "description": "Load a command from remote API endpoint",
-            },
-        ]
-
-        return examples

mcp_proxy_adapter/commands/plugins_command.py

@@ -5,7 +5,6 @@ Module with plugins command implementation.
 from typing import Dict, Any, Optional, List
 
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.config import get_config
 
@@ -219,21 +218,6 @@ class PluginsCommand(Command):
             )
 
     @classmethod
-    def get_metadata(cls) -> Dict[str, Any]:
-        """
-        Get command metadata.
-
-        Returns:
-            Dict[str, Any]: Command metadata
-        """
-        return {
-            "name": cls.name,
-            "summary": "Command that reads and displays available plugins from a plugins server",
-            "description": cls.__doc__,
-            "parameters": {},
-            "examples": cls._generate_examples({}),
-            "schema": cls.result_class.get_schema(),
-        }
 
     @classmethod
     def _generate_examples(

mcp_proxy_adapter/commands/protocol_management_command.py

@@ -52,34 +52,6 @@ class ProtocolManagementCommand(Command):
     descr = "Manage and query protocol configurations (HTTP, HTTPS, MTLS)"
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get command schema.
-
-        Returns:
-            Command schema dictionary
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": [
-                        "get_info",
-                        "validate_config",
-                        "get_allowed",
-                        "check_protocol",
-                    ],
-                    "description": "Action to perform",
-                },
-                "protocol": {
-                    "type": "string",
-                    "enum": ["http", "https", "mtls"],
-                    "description": "Protocol to check (for check_protocol action)",
-                },
-            },
-            "required": ["action"],
-        }
 
     async def execute(self, **kwargs) -> SuccessResult | ErrorResult:
         """

mcp_proxy_adapter/commands/proxy_registration_command.py

@@ -10,7 +10,6 @@ email: vasilyvz@gmail.com
 
 import json
 import time
-import uuid
 from typing import Dict, Any, List, Optional
 from dataclasses import dataclass
 
@@ -29,42 +28,8 @@ class ProxyRegistrationCommandResult(SuccessResult):
     message: str = ""
     details: Optional[Dict[str, Any]] = None
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert result to dictionary."""
-        result = {
-            "operation": self.operation,
-            "success": self.success,
-            "message": self.message,
-        }
-
-        if self.server_key:
-            result["server_key"] = self.server_key
-
-        if self.details:
-            result["details"] = self.details
-
-        return result
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema for result."""
-        return {
-            "type": "object",
-            "properties": {
-                "operation": {"type": "string", "description": "Operation performed"},
-                "success": {
-                    "type": "boolean",
-                    "description": "Whether operation was successful",
-                },
-                "server_key": {
-                    "type": "string",
-                    "description": "Server key for registered server",
-                },
-                "message": {"type": "string", "description": "Result message"},
-                "details": {"type": "object", "description": "Additional details"},
-            },
-            "required": ["operation", "success", "message"],
-        }
 
 
 class ProxyRegistrationCommand(Command):
@@ -352,56 +317,3 @@ class ProxyRegistrationCommand(Command):
         return True
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get JSON schema for command parameters."""
-        return {
-            "type": "object",
-            "properties": {
-                "operation": {
-                    "type": "string",
-                    "enum": ["register", "unregister", "heartbeat", "discover"],
-                    "description": "Operation to perform",
-                    "default": "register",
-                },
-                "server_id": {
-                    "type": "string",
-                    "description": "Server ID for registration",
-                },
-                "server_url": {
-                    "type": "string",
-                    "description": "Server URL for registration",
-                },
-                "server_name": {"type": "string", "description": "Server name"},
-                "description": {"type": "string", "description": "Server description"},
-                "version": {"type": "string", "description": "Server version"},
-                "capabilities": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Server capabilities",
-                },
-                "endpoints": {"type": "object", "description": "Server endpoints"},
-                "auth_method": {
-                    "type": "string",
-                    "description": "Authentication method",
-                },
-                "security_enabled": {
-                    "type": "boolean",
-                    "description": "Whether security is enabled",
-                },
-                "server_key": {
-                    "type": "string",
-                    "description": "Server key for unregistration/heartbeat",
-                },
-                "copy_number": {
-                    "type": "integer",
-                    "description": "Copy number for unregistration",
-                },
-                "timestamp": {
-                    "type": "integer",
-                    "description": "Timestamp for heartbeat",
-                },
-                "status": {"type": "string", "description": "Status for heartbeat"},
-            },
-            "required": ["operation"],
-            "additionalProperties": False,
-        }