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

mcp_proxy_adapter/api/schemas.py

@@ -11,15 +11,19 @@ class ErrorResponse(BaseModel):
     """
     Error response model.
     """
+
     code: int = Field(..., description="Error code")
     message: str = Field(..., description="Error message")
-    details: Optional[Dict[str, Any]] = Field(None, description="Additional error details")
+    details: Optional[Dict[str, Any]] = Field(
+        None, description="Additional error details"
+    )
 
 
 class ErrorWrapper(BaseModel):
     """
     Wrapper for error response.
     """
+
     error: ErrorResponse
 
 
@@ -27,9 +31,12 @@ class JsonRpcRequest(BaseModel):
     """
     JSON-RPC request model.
     """
+
     jsonrpc: Literal["2.0"] = Field("2.0", description="JSON-RPC version")
     method: str = Field(..., description="Method name")
-    params: Optional[Union[Dict[str, Any], List[Any]]] = Field(None, description="Method parameters")
+    params: Optional[Union[Dict[str, Any], List[Any]]] = Field(
+        None, description="Method parameters"
+    )
     id: Optional[Union[str, int]] = Field(None, description="Request ID")
 
 
@@ -37,6 +44,7 @@ class JsonRpcError(BaseModel):
     """
     JSON-RPC error model.
     """
+
     code: int = Field(..., description="Error code")
     message: str = Field(..., description="Error message")
     data: Optional[Dict[str, Any]] = Field(None, description="Additional error data")
@@ -46,6 +54,7 @@ class JsonRpcSuccessResponse(BaseModel):
     """
     JSON-RPC success response model.
     """
+
     jsonrpc: Literal["2.0"] = Field("2.0", description="JSON-RPC version")
     result: Dict[str, Any] = Field(..., description="Method result")
     id: Optional[Union[str, int]] = Field(None, description="Request ID")
@@ -55,6 +64,7 @@ class JsonRpcErrorResponse(BaseModel):
     """
     JSON-RPC error response model.
     """
+
     jsonrpc: Literal["2.0"] = Field("2.0", description="JSON-RPC version")
     error: JsonRpcError = Field(..., description="Error information")
     id: Optional[Union[str, int]] = Field(None, description="Request ID")
@@ -64,6 +74,7 @@ class CommandResponse(BaseModel):
     """
     Command response model.
     """
+
     success: bool = Field(..., description="Command execution success flag")
     data: Optional[Dict[str, Any]] = Field(None, description="Result data")
     message: Optional[str] = Field(None, description="Result message")
@@ -74,6 +85,7 @@ class HealthResponse(BaseModel):
     """
     Health response model.
     """
+
     status: str = Field(..., description="Server status")
     version: str = Field(..., description="Server version")
     uptime: float = Field(..., description="Server uptime in seconds")
@@ -84,6 +96,7 @@ class CommandListResponse(BaseModel):
     """
     Command list response model.
     """
+
     commands: Dict[str, Dict[str, Any]] = Field(..., description="Available commands")
 
 
@@ -91,6 +104,7 @@ class CommandRequest(BaseModel):
     """
     Command request model for /cmd endpoint.
     """
+
     command: str = Field(..., description="Command name to execute")
     params: Optional[Dict[str, Any]] = Field({}, description="Command parameters")
 
@@ -99,6 +113,7 @@ class CommandSuccessResponse(BaseModel):
     """
     Command success response model for /cmd endpoint.
     """
+
     result: Dict[str, Any] = Field(..., description="Command execution result")
 
 
@@ -106,113 +121,124 @@ class CommandErrorResponse(BaseModel):
     """
     Command error response model for /cmd endpoint.
     """
+
     error: JsonRpcError = Field(..., description="Error information")
 
 
 class APIToolDescription:
     """
     Генератор описаний для инструментов API на основе метаданных команд.
-    
+
     Класс предоставляет функциональность для создания подробных и понятных
     описаний инструментов API, которые помогают пользователям сразу понять
     как использовать API.
     """
-    
+
     @classmethod
     def generate_tool_description(cls, name: str, registry) -> Dict[str, Any]:
         """
         Генерирует подробное описание инструмента API на основе имени и реестра команд.
-        
+
         Args:
             name: Имя инструмента API
             registry: Реестр команд
-            
+
         Returns:
             Словарь с полным описанием инструмента
         """
         # Получаем все метаданные из реестра команд
         all_metadata = registry.get_all_metadata()
-        
+
         # Базовое описание инструмента
         description = {
             "name": name,
             "description": f"Выполняет команды через JSON-RPC протокол на сервере проекта.",
             "supported_commands": {},
-            "examples": []
+            "examples": [],
         }
-        
+
         # Добавляем информацию о поддерживаемых командах
         for cmd_name, metadata in all_metadata.items():
             command_info = {
                 "summary": metadata["summary"],
                 "description": metadata["description"],
                 "params": {},
-                "required_params": []
+                "required_params": [],
             }
-            
+
             # Добавляем информацию о параметрах
             for param_name, param_info in metadata["params"].items():
                 param_type = param_info.get("type", "any").replace("typing.", "")
-                
+
                 # Определяем тип параметра для документации
                 simple_type = cls._simplify_type(param_type)
-                
+
                 command_info["params"][param_name] = {
                     "type": simple_type,
-                    "description": cls._extract_param_description(metadata["description"], param_name),
-                    "required": param_info.get("required", False)
+                    "description": cls._extract_param_description(
+                        metadata["description"], param_name
+                    ),
+                    "required": param_info.get("required", False),
                 }
-                
+
                 # Если параметр обязательный, добавляем его в список обязательных
                 if param_info.get("required", False):
                     command_info["required_params"].append(param_name)
-            
+
             description["supported_commands"][cmd_name] = command_info
-            
+
             # Добавляем примеры из метаданных команды
             for example in metadata.get("examples", []):
-                description["examples"].append({
-                    "command": example.get("command", cmd_name),
-                    "params": example.get("params", {}),
-                    "description": example.get("description", f"Пример использования команды {cmd_name}")
-                })
-        
+                description["examples"].append(
+                    {
+                        "command": example.get("command", cmd_name),
+                        "params": example.get("params", {}),
+                        "description": example.get(
+                            "description", f"Пример использования команды {cmd_name}"
+                        ),
+                    }
+                )
+
         return description
-    
+
     @classmethod
     def generate_tool_description_text(cls, name: str, registry) -> str:
         """
         Генерирует текстовое описание инструмента API для документации.
-        
+
         Args:
             name: Имя инструмента API
             registry: Реестр команд
-            
+
         Returns:
             Текстовое описание инструмента в формате markdown
         """
         tool_data = cls.generate_tool_description(name, registry)
-        
+
         # Формируем заголовок и базовое описание
         text = f"# Инструмент {tool_data['name']}\n\n"
         text += f"{tool_data['description']}\n\n"
-        
+
         # Список доступных команд
         text += "## Доступные команды\n\n"
         for cmd_name, cmd_info in tool_data["supported_commands"].items():
             text += f"### {cmd_name}\n\n"
             text += f"{cmd_info['description']}\n\n"
-            
+
             # Информация о параметрах
             if cmd_info["params"]:
                 text += "#### Параметры:\n\n"
                 for param_name, param_info in cmd_info["params"].items():
-                    required_mark = "**обязательный**" if param_info["required"] else "опциональный"
+                    required_mark = (
+                        "**обязательный**" if param_info["required"] else "опциональный"
+                    )
                     text += f"- `{param_name}` ({param_info['type']}, {required_mark}): {param_info['description']}\n"
                 text += "\n"
-            
+
             # Примеры использования
-            cmd_examples = [ex for ex in tool_data["examples"] if ex["command"] == cmd_name]
+            cmd_examples = [
+                ex for ex in tool_data["examples"] if ex["command"] == cmd_name
+            ]
             if cmd_examples:
                 text += "#### Примеры:\n\n"
                 for i, example in enumerate(cmd_examples):
@@ -235,23 +261,23 @@ class APIToolDescription:
                         text += '    "params": {}\n'
                     text += "}\n"
                     text += "```\n\n"
-        
+
         return text
-    
+
     @classmethod
     def _simplify_type(cls, type_str: str) -> str:
         """
         Упрощает строковое представление типа для документации.
-        
+
         Args:
             type_str: Строковое представление типа
-            
+
         Returns:
             Упрощенное строковое представление типа
         """
         # Удаляем префиксы из строки типа
         type_str = type_str.replace("<class '", "").replace("'>", "")
-        
+
         # Преобразование стандартных типов
         if "str" in type_str:
             return "строка"
@@ -271,16 +297,16 @@ class APIToolDescription:
             return cls._simplify_type(inner_type)
         else:
             return "значение"
-    
+
     @classmethod
     def _extract_param_description(cls, doc_string: str, param_name: str) -> str:
         """
         Извлекает описание параметра из строки документации.
-        
+
         Args:
             doc_string: Строка документации
             param_name: Имя параметра
-            
+
         Returns:
             Описание параметра или пустая строка, если описание не найдено
         """
@@ -291,13 +317,13 @@ class APIToolDescription:
             args_section = doc_string.split("Parameters:")[1].split("\n\n")[0]
         else:
             return ""
-        
+
         # Ищем описание параметра
         for line in args_section.split("\n"):
             line = line.strip()
             if line.startswith(param_name + ":") or line.startswith(param_name + " :"):
                 return line.split(":", 1)[1].strip()
-        
+
         return ""
 
 

mcp_proxy_adapter/api/tool_integration.py

@@ -19,31 +19,39 @@ logger = logging.getLogger(__name__)
 class ToolIntegration:
     """
     Класс для интеграции метаданных команд с внешними инструментами API.
-    
+
     Обеспечивает генерацию описаний инструментов API для различных систем
     на основе метаданных команд микросервиса.
     """
-    
+
     @classmethod
-    def generate_tool_schema(cls, tool_name: str, registry: CommandRegistry, 
-                             description: Optional[str] = None) -> Dict[str, Any]:
+    def generate_tool_schema(
+        cls,
+        tool_name: str,
+        registry: CommandRegistry,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
         """
         Генерирует схему инструмента API для использования в OpenAPI и других системах.
-        
+
         Args:
             tool_name: Имя инструмента API
             registry: Реестр команд
             description: Дополнительное описание инструмента (опционально)
-            
+
         Returns:
             Словарь с описанием инструмента в формате OpenAPI
         """
         # Получаем базовое описание инструмента
-        base_description = APIToolDescription.generate_tool_description(tool_name, registry)
-        
+        base_description = APIToolDescription.generate_tool_description(
+            tool_name, registry
+        )
+
         # Получаем типы параметров
-        parameter_types = cls._extract_parameter_types(base_description["supported_commands"])
-        
+        parameter_types = cls._extract_parameter_types(
+            base_description["supported_commands"]
+        )
+
         # Формируем схему инструмента
         schema = {
             "name": tool_name,
@@ -53,100 +61,105 @@ class ToolIntegration:
                     "command": {
                         "description": "Команда для выполнения",
                         "type": "string",
-                        "enum": list(base_description["supported_commands"].keys())
+                        "enum": list(base_description["supported_commands"].keys()),
                     },
                     "params": {
                         "description": "Параметры команды",
                         "type": "object",
                         "additionalProperties": True,
-                        "properties": parameter_types
-                    }
+                        "properties": parameter_types,
+                    },
                 },
                 "required": ["command"],
-                "type": "object"
-            }
+                "type": "object",
+            },
         }
-        
+
         return schema
-    
+
     @classmethod
-    def generate_tool_documentation(cls, tool_name: str, registry: CommandRegistry, 
-                                   format: str = "markdown") -> str:
+    def generate_tool_documentation(
+        cls, tool_name: str, registry: CommandRegistry, format: str = "markdown"
+    ) -> str:
         """
         Генерирует документацию по инструменту API в заданном формате.
-        
+
         Args:
             tool_name: Имя инструмента API
             registry: Реестр команд
             format: Формат документации (markdown, html)
-            
+
         Returns:
             Строка с документацией в заданном формате
         """
         if format.lower() == "markdown":
-            return APIToolDescription.generate_tool_description_text(tool_name, registry)
+            return APIToolDescription.generate_tool_description_text(
+                tool_name, registry
+            )
         elif format.lower() == "html":
-            # Преобразуем markdown в HTML (в реальном проекте здесь будет 
+            # Преобразуем markdown в HTML (в реальном проекте здесь будет
             # использоваться библиотека для конвертации markdown в HTML)
-            markdown = APIToolDescription.generate_tool_description_text(tool_name, registry)
+            markdown = APIToolDescription.generate_tool_description_text(
+                tool_name, registry
+            )
             # Простая конвертация для примера
-            body = markdown.replace('#', '<h1>').replace('\n\n', '</p><p>')
+            body = markdown.replace("#", "<h1>").replace("\n\n", "</p><p>")
             html = f"<html><body>{body}</body></html>"
             return html
         else:
             # По умолчанию возвращаем markdown
-            return APIToolDescription.generate_tool_description_text(tool_name, registry)
-    
+            return APIToolDescription.generate_tool_description_text(
+                tool_name, registry
+            )
+
     @classmethod
-    def register_external_tools(cls, registry: CommandRegistry, tool_names: List[str]) -> Dict[str, Dict[str, Any]]:
+    def register_external_tools(
+        cls, registry: CommandRegistry, tool_names: List[str]
+    ) -> Dict[str, Dict[str, Any]]:
         """
         Регистрирует инструменты API во внешних системах.
-        
+
         Args:
             registry: Реестр команд
             tool_names: Список имен инструментов API для регистрации
-            
+
         Returns:
             Словарь с результатами регистрации инструментов
         """
         results = {}
-        
+
         for tool_name in tool_names:
             try:
                 # Генерируем схему инструмента
                 schema = cls.generate_tool_schema(tool_name, registry)
-                
+
                 # Здесь будет код для регистрации инструмента во внешней системе
                 # Например, отправка схемы в API регистрации инструментов
-                
-                results[tool_name] = {
-                    "status": "success",
-                    "schema": schema
-                }
-                
+
+                results[tool_name] = {"status": "success", "schema": schema}
+
                 logger.info(f"Successfully registered tool: {tool_name}")
             except Exception as e:
                 logger.debug(f"Error registering tool {tool_name}: {e}")
-                results[tool_name] = {
-                    "status": "error",
-                    "error": str(e)
-                }
-        
+                results[tool_name] = {"status": "error", "error": str(e)}
+
         return results
-    
+
     @classmethod
-    def _extract_parameter_types(cls, commands: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    def _extract_parameter_types(
+        cls, commands: Dict[str, Dict[str, Any]]
+    ) -> Dict[str, Dict[str, Any]]:
         """
         Извлекает типы параметров из описания команд для формирования схемы.
-        
+
         Args:
             commands: Словарь с описанием команд
-            
+
         Returns:
             Словарь с типами параметров для схемы OpenAPI
         """
         parameter_types = {}
-        
+
         # Формируем словарь типов для всех параметров всех команд
         for cmd_name, cmd_info in commands.items():
             params = cmd_info.get("params", {})
@@ -154,7 +167,7 @@ class ToolIntegration:
                 continue
             for param_name, param_info in params.items():
                 param_type = param_info.get("type", "значение")
-                
+
                 # Преобразуем русские типы в типы JSON Schema
                 if param_type == "строка":
                     json_type = "string"
@@ -170,58 +183,65 @@ class ToolIntegration:
                     json_type = "object"
                 else:
                     json_type = "string"
-                
+
                 # Добавляем тип в общий словарь
                 parameter_types[param_name] = {
                     "type": json_type,
-                    "description": param_info.get("description", "")
+                    "description": param_info.get("description", ""),
                 }
-        
+
         return parameter_types
 
 
 def generate_tool_help(tool_name: str, registry: CommandRegistry) -> str:
     """
     Генерирует справочную информацию по инструменту API.
-    
+
     Args:
         tool_name: Имя инструмента API
         registry: Реестр команд
-        
+
     Returns:
         Строка с описанием инструмента и доступных команд
     """
     # Получаем метаданные всех команд
     all_metadata = registry.get_all_metadata()
-    
+
     # Формируем текст справки
     help_text = f"# Инструмент {tool_name}\n\n"
     help_text += "Позволяет выполнять команды через JSON-RPC протокол.\n\n"
     help_text += "## Доступные команды:\n\n"
-    
+
     # Добавляем информацию о каждой команде
     for cmd_name, metadata in all_metadata.items():
         help_text += f"### {cmd_name}\n"
         help_text += f"{metadata['summary']}\n\n"
-        
+
         # Добавляем информацию о параметрах команды
         if metadata["params"]:
             help_text += "Параметры:\n"
             for param_name, param_info in metadata["params"].items():
-                required = "обязательный" if param_info.get("required", False) else "опциональный"
+                required = (
+                    "обязательный"
+                    if param_info.get("required", False)
+                    else "опциональный"
+                )
                 help_text += f"- {param_name}: {required}\n"
             help_text += "\n"
-        
+
         # Добавляем пример использования команды
         if metadata.get("examples"):
             example = metadata["examples"][0]
             help_text += "Пример:\n"
             help_text += "```json\n"
             help_text += json.dumps(
-                {"command": example.get("command", cmd_name), "params": example.get("params", {})},
+                {
+                    "command": example.get("command", cmd_name),
+                    "params": example.get("params", {}),
+                },
                 indent=2,
-                ensure_ascii=False
+                ensure_ascii=False,
             )
             help_text += "\n```\n\n"
-    
-    return help_text 
+
+    return help_text