mcp-proxy-adapter 3.1.5__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(...)):
@@ -200,6 +214,27 @@ def create_app() -> FastAPI:
                         "error": e.to_dict()
                     }
                 )
+            except NotFoundError as e:
+                # Специальная обработка для help-команды: возвращаем result с пустым commands и error
+                if command_name == "help":
+                    return {
+                        "result": {
+                            "success": False,
+                            "commands": {},
+                            "error": str(e),
+                            "note": "To get detailed information about a specific command, call help with parameter: POST /cmd {\"command\": \"help\", \"params\": {\"cmdname\": \"<command_name>\"}}"
+                        }
+                    }
+                # Для остальных команд — стандартная ошибка
+                return JSONResponse(
+                    status_code=200,
+                    content={
+                        "error": {
+                            "code": e.code,
+                            "message": str(e)
+                        }
+                    }
+                )
             
         except json.JSONDecodeError:
             req_logger.error("JSON decode error")
@@ -224,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={})):
@@ -238,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():
@@ -269,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):
@@ -296,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"):
@@ -347,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(...)):
@@ -387,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: