mcp-proxy-adapter 3.1.6__py3-none-any.whl → 4.0.0__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -18,7 +18,7 @@ from mcp_proxy_adapter.config import config
 from mcp_proxy_adapter.core.errors import MicroserviceError, NotFoundError
 from mcp_proxy_adapter.core.logging import logger, RequestLogger
 from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.custom_openapi import custom_openapi
+from mcp_proxy_adapter.custom_openapi import custom_openapi_with_fallback
 
 
 @asynccontextmanager
@@ -29,12 +29,16 @@ async def lifespan(app: FastAPI):
     # Startup events
     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
     
-    # Register built-in commands (help should be registered first)
+    # Register built-in commands if they don't exist (user can override them)
     if not registry.command_exists("help"):
         registry.register(HelpCommand)
     
-    # Register other commands
+    if not registry.command_exists("health"):
+        registry.register(HealthCommand)
+    
+    # Discover and register additional commands automatically
     registry.discover_commands()
     
     logger.info(f"Application started with {len(registry.get_all_commands())} commands registered")
@@ -45,18 +49,28 @@ async def lifespan(app: FastAPI):
     logger.info("Application shutting down")
 
 
-def create_app() -> FastAPI:
+def create_app(title: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None) -> FastAPI:
     """
     Creates and configures FastAPI application.
 
+    Args:
+        title: Application title (default: "MCP Proxy Adapter")
+        description: Application description (default: "JSON-RPC API for interacting with MCP Proxy")
+        version: Application version (default: "1.0.0")
+
     Returns:
         Configured FastAPI application.
     """
+    # Use provided parameters or defaults
+    app_title = title or "MCP Proxy Adapter"
+    app_description = description or "JSON-RPC API for interacting with MCP Proxy"
+    app_version = version or "1.0.0"
+    
     # Create application
     app = FastAPI(
-        title="MCP Proxy Adapter",
-        description="JSON-RPC API for interacting with MCP Proxy",
-        version="1.0.0",
+        title=app_title,
+        description=app_description,
+        version=app_version,
         docs_url="/docs",
         redoc_url="/redoc",
         lifespan=lifespan,
@@ -75,7 +89,7 @@ def create_app() -> FastAPI:
     setup_middleware(app)
     
     # Use custom OpenAPI schema
-    app.openapi = lambda: custom_openapi(app)
+    app.openapi = lambda: custom_openapi_with_fallback(app)
     
     # Explicit endpoint for OpenAPI schema
     @app.get("/openapi.json")
@@ -83,8 +97,8 @@ def create_app() -> FastAPI:
         """
         Returns optimized OpenAPI schema compatible with MCP-Proxy.
         """
-        return custom_openapi(app)
-    
+        return custom_openapi_with_fallback(app)
+
     # JSON-RPC handler
     @app.post("/api/jsonrpc", response_model=Union[JsonRpcSuccessResponse, JsonRpcErrorResponse, List[Union[JsonRpcSuccessResponse, JsonRpcErrorResponse]]])
     async def jsonrpc_endpoint(request: Request, request_data: Union[Dict[str, Any], List[Dict[str, Any]]] = Body(...)):
@@ -119,7 +133,7 @@ def create_app() -> FastAPI:
         else:
             # Process single request
             return await handle_json_rpc(request_data, request_id)
-    
+
     # Command execution endpoint (/cmd)
     @app.post("/cmd")
     async def cmd_endpoint(request: Request, command_data: Dict[str, Any] = Body(...)):
@@ -245,7 +259,7 @@ def create_app() -> FastAPI:
                     }
                 }
             )
-    
+
     # Direct command call
     @app.post("/api/command/{command_name}")
     async def command_endpoint(request: Request, command_name: str, params: Dict[str, Any] = Body(default={})):
@@ -259,29 +273,50 @@ def create_app() -> FastAPI:
             result = await execute_command(command_name, params, request_id)
             return result
         except MicroserviceError as e:
+            # Convert to proper HTTP status code
+            status_code = 400 if e.code < 0 else e.code
             return JSONResponse(
-                status_code=e.code,
+                status_code=status_code,
                 content=e.to_dict()
             )
-    
+
     # Server health check
     @app.get("/health", operation_id="health_check")
     async def health_endpoint():
         """
-        Проверить работоспособность сервиса.
-        
-        Возвращает информацию о состоянии сервиса.
+        Health check endpoint.
+        Returns server status and basic information.
         """
-        # Получаем базовую информацию о здоровье сервера
-        health_data = await get_server_health()
-        
-        # Возвращаем информацию в формате, соответствующем схеме
-        return JSONResponse(content={
+        return {
             "status": "ok",
             "model": "mcp-proxy-adapter",
-            "version": config.get("version", "1.0.0")
-        })
+            "version": "1.0.0"
+        }
     
+    # Graceful shutdown endpoint
+    @app.post("/shutdown")
+    async def shutdown_endpoint():
+        """
+        Graceful shutdown endpoint.
+        Triggers server shutdown after completing current requests.
+        """
+        import asyncio
+        
+        # Schedule shutdown after a short delay to allow response
+        async def delayed_shutdown():
+            await asyncio.sleep(1)
+            # This will trigger the lifespan shutdown event
+            import os
+            os._exit(0)
+        
+        # Start shutdown task
+        asyncio.create_task(delayed_shutdown())
+        
+        return {
+            "status": "shutting_down",
+            "message": "Server shutdown initiated. New requests will be rejected."
+        }
+
     # List of available commands
     @app.get("/api/commands", response_model=CommandListResponse)
     async def commands_list_endpoint():
@@ -290,7 +325,7 @@ def create_app() -> FastAPI:
         """
         commands = await get_commands_list()
         return {"commands": commands}
-    
+
     # Get command information by name
     @app.get("/api/commands/{command_name}")
     async def command_info_endpoint(request: Request, command_name: str):
@@ -317,7 +352,7 @@ def create_app() -> FastAPI:
                     }
                 }
             )
-    
+
     # Get API tool description
     @app.get("/api/tools/{tool_name}")
     async def tool_description_endpoint(tool_name: str, format: Optional[str] = "json"):
@@ -368,7 +403,7 @@ def create_app() -> FastAPI:
                     }
                 }
             )
-    
+
     # Execute API tool
     @app.post("/api/tools/{tool_name}")
     async def execute_tool_endpoint(tool_name: str, params: Dict[str, Any] = Body(...)):
@@ -408,5 +443,8 @@ def create_app() -> FastAPI:
     return app
 
 
+
+
+
 # Create global application instance
 app = create_app()

mcp_proxy_adapter/api/handlers.py

@@ -43,7 +43,7 @@ async def execute_command(command_name: str, params: Dict[str, Any], request_id:
         start_time = time.time()
         
         # Use Command.run that handles instances with dependencies properly
-        command_class = registry.get_command(command_name)
+        command_class = registry.get_command_with_priority(command_name)
         result = await command_class.run(**params)
         
         execution_time = time.time() - start_time

mcp_proxy_adapter/api/middleware/error_handling.py

@@ -35,7 +35,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         except CommandError as e:
             # Command error
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.error(f"[{request_id}] Command error: {str(e)}")
+            logger.debug(f"[{request_id}] Command error: {str(e)}")
             
             # Проверяем, является ли запрос JSON-RPC
             is_jsonrpc = self._is_json_rpc_request(request)
@@ -52,7 +52,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
                         "error": {
                             "code": e.code,
                             "message": str(e),
-                            "data": e.details if hasattr(e, "details") else None
+                            "data": e.data if hasattr(e, "data") and e.data else None
                         },
                         "id": request_id_jsonrpc
                     }
@@ -67,7 +67,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         except ValidationError as e:
             # Validation error
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.error(f"[{request_id}] Validation error: {str(e)}")
+            logger.debug(f"[{request_id}] Validation error: {str(e)}")
             
             # Get JSON-RPC request ID if available
             request_id_jsonrpc = await self._get_json_rpc_id(request)
@@ -81,7 +81,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
                         "error": {
                             "code": -32602,
                             "message": "Invalid params",
-                            "data": e.details if hasattr(e, "details") else None
+                            "data": e.data if hasattr(e, "data") and e.data else None
                         },
                         "id": request_id_jsonrpc
                     }
@@ -96,7 +96,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         except MicroserviceError as e:
             # Other microservice error
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.error(f"[{request_id}] Microservice error: {str(e)}")
+            logger.debug(f"[{request_id}] Microservice error: {str(e)}")
             
             # Get JSON-RPC request ID if available
             request_id_jsonrpc = await self._get_json_rpc_id(request)
@@ -104,13 +104,13 @@ class ErrorHandlingMiddleware(BaseMiddleware):
             # If request was JSON-RPC
             if self._is_json_rpc_request(request):
                 return JSONResponse(
-                    status_code=e.code,
+                    status_code=400,
                     content={
                         "jsonrpc": "2.0",
                         "error": {
                             "code": -32000,
                             "message": str(e),
-                            "data": e.details if hasattr(e, "details") else None
+                            "data": e.data if hasattr(e, "data") and e.data else None
                         },
                         "id": request_id_jsonrpc
                     }
@@ -118,14 +118,14 @@ class ErrorHandlingMiddleware(BaseMiddleware):
             
             # Regular API error
             return JSONResponse(
-                status_code=e.code,
+                status_code=400,
                 content=e.to_dict()
             )
             
         except Exception as e:
             # Unexpected error
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.exception(f"[{request_id}] Unexpected error: {str(e)}")
+            logger.debug(f"[{request_id}] Unexpected error: {str(e)}")
             
             # Get JSON-RPC request ID if available
             request_id_jsonrpc = await self._get_json_rpc_id(request)
@@ -165,7 +165,8 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         Returns:
             True if request is JSON-RPC, False otherwise.
         """
-        return request.url.path.endswith("/jsonrpc")
+        # Only requests to /api/jsonrpc are JSON-RPC requests
+        return request.url.path == "/api/jsonrpc"
     
     async def _get_json_rpc_id(self, request: Request) -> Optional[Any]:
         """

mcp_proxy_adapter/api/tool_integration.py

@@ -126,7 +126,7 @@ class ToolIntegration:
                 
                 logger.info(f"Successfully registered tool: {tool_name}")
             except Exception as e:
-                logger.error(f"Error registering tool {tool_name}: {e}")
+                logger.debug(f"Error registering tool {tool_name}: {e}")
                 results[tool_name] = {
                     "status": "error",
                     "error": str(e)
@@ -149,7 +149,10 @@ class ToolIntegration:
         
         # Формируем словарь типов для всех параметров всех команд
         for cmd_name, cmd_info in commands.items():
-            for param_name, param_info in cmd_info.get("params", {}).items():
+            params = cmd_info.get("params", {})
+            if params is None:
+                continue
+            for param_name, param_info in params.items():
                 param_type = param_info.get("type", "значение")
                 
                 # Преобразуем русские типы в типы JSON Schema

mcp_proxy_adapter/api/tools.py

@@ -50,14 +50,14 @@ class TSTCommandExecutor:
         
         try:
             # Проверяем существование команды
-            if not registry.command_exists(command):
+            if not registry.command_exists_with_priority(command):
                 raise NotFoundError(f"Команда '{command}' не найдена")
             
             # Получаем класс команды
-            command_class = registry.get_command(command)
+            command_class = registry.get_command_with_priority(command)
             
             # Выполняем команду
-            result = await command_class.run(**params)
+            result = await command_class.execute(**params)
             
             # Возвращаем результат
             return result.to_dict()

mcp_proxy_adapter/commands/base.py

@@ -13,6 +13,7 @@ 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)
@@ -136,6 +137,20 @@ class Command(ABC):
             # 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:
+                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
@@ -143,9 +158,12 @@ class Command(ABC):
                 result = await command.execute(**validated_params)
             else:
                 # Create new instance for commands without dependencies
-                command = cls()
+                command = priority_command_class()
                 result = await command.execute(**validated_params)
             
+            # Execute after hooks
+            hooks.execute_after_hooks(command_name, validated_params, result)
+            
             logger.debug(f"Command {cls.__name__} executed successfully")
             return result
         except ValidationError as e:

mcp_proxy_adapter/commands/command_registry.py

@@ -41,6 +41,7 @@ class CommandRegistry:
         """
         self._commands: Dict[str, Type[Command]] = {}
         self._instances: Dict[str, Command] = {}
+        self._custom_commands: Dict[str, Type[Command]] = {}  # Custom commands with priority
     
     def register(self, command: Union[Type[Command], Command]) -> None:
         """
@@ -196,7 +197,7 @@ class CommandRegistry:
         Raises:
             NotFoundError: If command is not found.
         """
-        command_class = self.get_command(command_name)
+        command_class = self.get_command_with_priority(command_name)
         
         return {
             "name": command_name,
@@ -219,7 +220,7 @@ class CommandRegistry:
         Raises:
             NotFoundError: If command is not found
         """
-        command_class = self.get_command(command_name)
+        command_class = self.get_command_with_priority(command_name)
         return command_class.get_metadata()
     
     def get_all_metadata(self) -> Dict[str, Dict[str, Any]]:
@@ -230,8 +231,13 @@ class CommandRegistry:
             Dict with command names as keys and metadata as values
         """
         metadata = {}
-        for name, command_class in self._commands.items():
+        # Add custom commands first (they have priority)
+        for name, command_class in self._custom_commands.items():
             metadata[name] = command_class.get_metadata()
+        # Add built-in commands (custom commands will override if same name)
+        for name, command_class in self._commands.items():
+            if name not in self._custom_commands:  # Only add if not overridden by custom
+                metadata[name] = command_class.get_metadata()
         return metadata
     
     def get_all_commands_info(self) -> Dict[str, Dict[str, Any]]:
@@ -242,8 +248,13 @@ class CommandRegistry:
             Dictionary with information about all commands.
         """
         commands_info = {}
-        for name in self._commands:
+        # Add custom commands first (they have priority)
+        for name in self._custom_commands:
             commands_info[name] = self.get_command_info(name)
+        # Add built-in commands (custom commands will override if same name)
+        for name in self._commands:
+            if name not in self._custom_commands:  # Only add if not overridden by custom
+                commands_info[name] = self.get_command_info(name)
         return commands_info
     
     def discover_commands(self, package_path: str = "mcp_proxy_adapter.commands") -> None:
@@ -296,13 +307,239 @@ class CommandRegistry:
         except Exception as e:
             logger.error(f"Error discovering commands: {e}")
             
+    def register_custom_command(self, command: Union[Type[Command], Command]) -> None:
+        """
+        Register a custom command with priority over built-in commands.
+        
+        Args:
+            command: Command class or instance to register.
+            
+        Raises:
+            ValueError: If command with the same name is already registered.
+        """
+        # Determine if this is a class or an instance
+        if isinstance(command, type) and issubclass(command, Command):
+            command_class = command
+            command_instance = None
+        elif isinstance(command, Command):
+            command_class = command.__class__
+            command_instance = command
+        else:
+            raise ValueError(f"Invalid command type: {type(command)}. Expected Command class or instance.")
+            
+        # Get command name
+        if not hasattr(command_class, "name") or not command_class.name:
+            # Use class name if name attribute is not set
+            command_name = command_class.__name__.lower()
+            if command_name.endswith("command"):
+                command_name = command_name[:-7]  # Remove "command" suffix
+        else:
+            command_name = command_class.name
+            
+        if command_name in self._custom_commands:
+            logger.debug(f"Custom command '{command_name}' is already registered, skipping")
+            raise ValueError(f"Custom command '{command_name}' is already registered")
+            
+        logger.debug(f"Registering custom command: {command_name}")
+        self._custom_commands[command_name] = command_class
+        
+        # Store instance if provided
+        if command_instance:
+            logger.debug(f"Storing custom instance for command: {command_name}")
+            self._instances[command_name] = command_instance
+    
+    def unregister_custom_command(self, command_name: str) -> None:
+        """
+        Remove custom command from registry.
+        
+        Args:
+            command_name: Command name to remove.
+            
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        if command_name not in self._custom_commands:
+            raise NotFoundError(f"Custom command '{command_name}' not found")
+            
+        logger.debug(f"Unregistering custom command: {command_name}")
+        del self._custom_commands[command_name]
+        
+        # Also remove from instances if present
+        if command_name in self._instances:
+            del self._instances[command_name]
+    
+    def custom_command_exists(self, command_name: str) -> bool:
+        """
+        Check if custom command exists.
+        
+        Args:
+            command_name: Command name to check.
+            
+        Returns:
+            True if custom command exists, False otherwise.
+        """
+        return command_name in self._custom_commands
+    
+    def get_custom_command(self, command_name: str) -> Type[Command]:
+        """
+        Get custom command class.
+        
+        Args:
+            command_name: Command name.
+            
+        Returns:
+            Command class.
+            
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        if command_name not in self._custom_commands:
+            raise NotFoundError(f"Custom command '{command_name}' not found")
+        return self._custom_commands[command_name]
+    
+    def get_all_custom_commands(self) -> Dict[str, Type[Command]]:
+        """
+        Get all custom commands.
+        
+        Returns:
+            Dictionary with custom command names as keys and classes as values.
+        """
+        return self._custom_commands.copy()
+    
+    def get_priority_command(self, command_name: str) -> Optional[Type[Command]]:
+        """
+        Get command with priority (custom commands first, then built-in).
+        
+        Args:
+            command_name: Command name.
+            
+        Returns:
+            Command class if found, None otherwise.
+        """
+        # First check custom commands
+        if command_name in self._custom_commands:
+            return self._custom_commands[command_name]
+        
+        # Then check built-in commands
+        if command_name in self._commands:
+            return self._commands[command_name]
+        
+        return None
+    
+    def command_exists_with_priority(self, command_name: str) -> bool:
+        """
+        Check if command exists (custom or built-in).
+        
+        Args:
+            command_name: Command name to check.
+            
+        Returns:
+            True if command exists, False otherwise.
+        """
+        return (command_name in self._custom_commands or 
+                command_name in self._commands)
+    
+    def get_command_with_priority(self, command_name: str) -> Type[Command]:
+        """
+        Get command with priority (custom commands first, then built-in).
+        
+        Args:
+            command_name: Command name.
+            
+        Returns:
+            Command class.
+            
+        Raises:
+            NotFoundError: If command is not found.
+        """
+        # First check custom commands
+        if command_name in self._custom_commands:
+            return self._custom_commands[command_name]
+        
+        # Then check built-in commands
+        if command_name in self._commands:
+            return self._commands[command_name]
+        
+        raise NotFoundError(f"Command '{command_name}' not found")
+    
     def clear(self) -> None:
         """
-        Clears command registry.
+        Clear all registered commands.
+        """
+        logger.debug("Clearing all registered commands")
+        self._commands.clear()
+        self._instances.clear()
+        self._custom_commands.clear()
+    
+    def reload_config_and_commands(self, package_path: str = "mcp_proxy_adapter.commands") -> Dict[str, Any]:
+        """
+        Reload configuration and rediscover commands.
+        
+        Args:
+            package_path: Path to package with commands.
+            
+        Returns:
+            Dictionary with reload information including:
+            - config_reloaded: Whether config was reloaded
+            - commands_discovered: Number of commands discovered
+            - custom_commands_preserved: Number of custom commands preserved
+            - total_commands: Total number of commands after reload
         """
-        logger.debug("Clearing command registry")
+        logger.info("🔄 Starting configuration and commands reload...")
+        
+        # Store current custom commands
+        custom_commands_backup = self._custom_commands.copy()
+        
+        # Reload configuration
+        try:
+            from mcp_proxy_adapter.config import config
+            config.load_config()
+            config_reloaded = True
+            logger.info("✅ Configuration reloaded successfully")
+        except Exception as e:
+            logger.error(f"❌ Failed to reload configuration: {e}")
+            config_reloaded = False
+        
+        # Reinitialize logging with new configuration
+        try:
+            from mcp_proxy_adapter.core.logging import setup_logging
+            setup_logging()
+            logger.info("✅ Logging reinitialized with new configuration")
+        except Exception as e:
+            logger.error(f"❌ Failed to reinitialize logging: {e}")
+        
+        # Clear all commands except custom ones
         self._commands.clear()
         self._instances.clear()
+        
+        # Restore custom commands
+        self._custom_commands = custom_commands_backup
+        custom_commands_preserved = len(custom_commands_backup)
+        
+        # Rediscover commands
+        try:
+            commands_discovered = self.discover_commands(package_path)
+            logger.info(f"✅ Rediscovered {commands_discovered} commands")
+        except Exception as e:
+            logger.error(f"❌ Failed to rediscover commands: {e}")
+            commands_discovered = 0
+        
+        # Get final counts
+        total_commands = len(self._commands)
+        built_in_commands = total_commands - custom_commands_preserved
+        custom_commands = custom_commands_preserved
+        
+        result = {
+            "config_reloaded": config_reloaded,
+            "commands_discovered": commands_discovered,
+            "custom_commands_preserved": custom_commands_preserved,
+            "total_commands": total_commands,
+            "built_in_commands": built_in_commands,
+            "custom_commands": custom_commands
+        }
+        
+        logger.info(f"🔄 Reload completed: {result}")
+        return result
 
 
 # Global command registry instance