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

mcp_proxy_adapter/commands/health_command.py

@@ -19,11 +19,13 @@ class HealthResult(SuccessResult):
     """
     Result of the health command execution.
     """
-    
-    def __init__(self, status: str, version: str, uptime: float, components: Dict[str, Any]):
+
+    def __init__(
+        self, status: str, version: str, uptime: float, components: Dict[str, Any]
+    ):
         """
         Initialize health command result.
-        
+
         Args:
             status: Server status ("ok" or "error")
             version: Server version
@@ -35,15 +37,15 @@ class HealthResult(SuccessResult):
                 "status": status,
                 "version": version,
                 "uptime": uptime,
-                "components": components
+                "components": components,
             }
         )
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for result validation.
-        
+
         Returns:
             Dict[str, Any]: JSON schema
         """
@@ -61,14 +63,14 @@ class HealthResult(SuccessResult):
                             "properties": {
                                 "system": {"type": "object"},
                                 "process": {"type": "object"},
-                                "commands": {"type": "object"}
-                            }
-                        }
+                                "commands": {"type": "object"},
+                            },
+                        },
                     },
-                    "required": ["status", "version", "uptime", "components"]
+                    "required": ["status", "version", "uptime", "components"],
                 }
             },
-            "required": ["data"]
+            "required": ["data"],
         }
 
 
@@ -76,14 +78,14 @@ class HealthCommand(Command):
     """
     Command that returns information about server health and status.
     """
-    
+
     name = "health"
     result_class = HealthResult
-    
+
     async def execute(self, **kwargs) -> HealthResult:
         """
         Execute health command.
-        
+
         Returns:
             HealthResult: Health command result
         """
@@ -92,15 +94,15 @@ class HealthCommand(Command):
             from mcp_proxy_adapter.version import __version__ as version
         except ImportError:
             version = "unknown"
-        
+
         # Get process start time
         process = psutil.Process(os.getpid())
         start_time = datetime.fromtimestamp(process.create_time())
         uptime_seconds = (datetime.now() - start_time).total_seconds()
-        
+
         # Get system information
         memory_info = process.memory_info()
-        
+
         return HealthResult(
             status="ok",
             version=version,
@@ -109,35 +111,35 @@ class HealthCommand(Command):
                 "system": {
                     "python_version": sys.version,
                     "platform": platform.platform(),
-                    "cpu_count": os.cpu_count()
+                    "cpu_count": os.cpu_count(),
                 },
                 "process": {
                     "pid": os.getpid(),
                     "memory_usage_mb": memory_info.rss / (1024 * 1024),
-                    "start_time": start_time.isoformat()
-                },
-                "commands": {
-                    "registered_count": len(registry.get_all_commands())
+                    "start_time": start_time.isoformat(),
                 },
+                "commands": {"registered_count": len(registry.get_all_commands())},
                 "proxy_registration": {
                     "enabled": get_proxy_registration_status().get("enabled", False),
-                    "registered": get_proxy_registration_status().get("registered", False),
+                    "registered": get_proxy_registration_status().get(
+                        "registered", False
+                    ),
                     "server_key": get_proxy_registration_status().get("server_key"),
-                    "proxy_url": get_proxy_registration_status().get("proxy_url")
-                }
-            }
+                    "proxy_url": get_proxy_registration_status().get("proxy_url"),
+                },
+            },
         )
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for command parameters validation.
-        
+
         Returns:
             Dict[str, Any]: JSON schema
         """
         return {
             "type": "object",
             "additionalProperties": False,
-            "description": "Command doesn't accept any parameters"
+            "description": "Command doesn't accept any parameters",
         }

mcp_proxy_adapter/commands/help_command.py

@@ -20,7 +20,11 @@ class HelpResult(CommandResult):
     Result of the help command execution.
     """
 
-    def __init__(self, commands_info: Optional[Dict[str, Any]] = None, command_info: Optional[Dict[str, Any]] = None):
+    def __init__(
+        self,
+        commands_info: Optional[Dict[str, Any]] = None,
+        command_info: Optional[Dict[str, Any]] = None,
+    ):
         """
         Initialize help command result.
 
@@ -28,7 +32,9 @@ class HelpResult(CommandResult):
             commands_info: Information about all commands (for request without parameters)
             command_info: Information about a specific command (for request with cmdname parameter)
         """
-        logger.debug(f"HelpResult.__init__: commands_info={commands_info is not None}, command_info={command_info is not None}")
+        logger.debug(
+            f"HelpResult.__init__: commands_info={commands_info is not None}, command_info={command_info is not None}"
+        )
         self.commands_info = commands_info
         self.command_info = command_info
 
@@ -40,11 +46,15 @@ class HelpResult(CommandResult):
             Dict[str, Any]: Result as dictionary
         """
         try:
-            logger.debug(f"HelpResult.to_dict: command_info={self.command_info is not None}, commands_info={self.commands_info is not None}")
+            logger.debug(
+                f"HelpResult.to_dict: command_info={self.command_info is not None}, commands_info={self.commands_info is not None}"
+            )
 
             # Защита от None для self.command_info
             if self.command_info is not None:
-                logger.debug(f"HelpResult.to_dict: returning command_info for {self.command_info.get('name', 'unknown')}")
+                logger.debug(
+                    f"HelpResult.to_dict: returning command_info for {self.command_info.get('name', 'unknown')}"
+                )
                 # Делаем безопасное получение всех полей с дефолтными значениями
                 metadata = self.command_info.get("metadata", {})
                 schema = self.command_info.get("schema", {})
@@ -54,42 +64,57 @@ class HelpResult(CommandResult):
                         "description": metadata.get("description", ""),
                         "summary": metadata.get("summary", ""),
                         "params": schema.get("properties", {}),
-                        "examples": metadata.get("examples", [])
-                    }
+                        "examples": metadata.get("examples", []),
+                    },
                 }
 
             # Защита от None для self.commands_info
             if self.commands_info is None:
-                logger.warning("HelpResult.to_dict: commands_info is None, создаем пустой результат")
+                logger.warning(
+                    "HelpResult.to_dict: commands_info is None, создаем пустой результат"
+                )
                 # Возвращаем пустой список команд вместо ошибки
                 return {
                     "tool_info": {
                         "name": "MCP-Proxy API Service",
                         "description": "JSON-RPC API for microservice command execution",
-                        "version": "1.0.0"
+                        "version": "1.0.0",
                     },
                     "help_usage": {
                         "description": "Get information about commands",
                         "examples": [
-                            {"command": "help", "description": "List of all available commands"},
-                            {"command": "help", "params": {"cmdname": "command_name"}, "description": "Get detailed information about a specific command"}
-                        ]
+                            {
+                                "command": "help",
+                                "description": "List of all available commands",
+                            },
+                            {
+                                "command": "help",
+                                "params": {"cmdname": "command_name"},
+                                "description": "Get detailed information about a specific command",
+                            },
+                        ],
                     },
                     "commands": {},
                     "total": 0,
-                    "note": "To get detailed information about a specific command, call help with parameter: POST /cmd {\"command\": \"help\", \"params\": {\"cmdname\": \"<command_name>\"}}"
+                    "note": 'To get detailed information about a specific command, call help with parameter: POST /cmd {"command": "help", "params": {"cmdname": "<command_name>"}}',
                 }
 
             # For list of all commands, return as is (already formatted)
-            logger.debug(f"HelpResult.to_dict: processing commands_info with {len(self.commands_info.get('commands', {}))} commands")
+            logger.debug(
+                f"HelpResult.to_dict: processing commands_info with {len(self.commands_info.get('commands', {}))} commands"
+            )
             result = self.commands_info.copy()
 
             # Add total count and note about usage
             commands = result.get("commands", {})
             result["total"] = len(commands)
-            result["note"] = "To get detailed information about a specific command, call help with parameter: POST /cmd {\"command\": \"help\", \"params\": {\"cmdname\": \"<command_name>\"}}"
+            result["note"] = (
+                'To get detailed information about a specific command, call help with parameter: POST /cmd {"command": "help", "params": {"cmdname": "<command_name>"}}'
+            )
 
-            logger.debug(f"HelpResult.to_dict: returning result with {result['total']} commands")
+            logger.debug(
+                f"HelpResult.to_dict: returning result with {result['total']} commands"
+            )
             return result
         except Exception as e:
             logger.error(f"Ошибка в HelpResult.to_dict: {e}")
@@ -99,11 +124,11 @@ class HelpResult(CommandResult):
                 "tool_info": {
                     "name": "MCP-Proxy API Service",
                     "description": "JSON-RPC API for microservice command execution",
-                    "version": "1.0.0"
+                    "version": "1.0.0",
                 },
                 "commands": {},
                 "total": 0,
-                "error": str(e)
+                "error": str(e),
             }
 
     @classmethod
@@ -123,26 +148,22 @@ class HelpResult(CommandResult):
                             "type": "object",
                             "additionalProperties": {
                                 "type": "object",
-                                "properties": {
-                                    "description": {"type": "string"}
-                                }
-                            }
+                                "properties": {"description": {"type": "string"}},
+                            },
                         },
                         "tool_info": {
                             "type": "object",
                             "properties": {
                                 "name": {"type": "string"},
                                 "description": {"type": "string"},
-                                "version": {"type": "string"}
-                            }
-                        },
-                        "help_usage": {
-                            "type": "object"
+                                "version": {"type": "string"},
+                            },
                         },
+                        "help_usage": {"type": "object"},
                         "total": {"type": "integer"},
-                        "note": {"type": "string"}
+                        "note": {"type": "string"},
                     },
-                    "required": ["commands"]
+                    "required": ["commands"],
                 },
                 {
                     "properties": {
@@ -153,13 +174,13 @@ class HelpResult(CommandResult):
                                 "description": {"type": "string"},
                                 "summary": {"type": "string"},
                                 "params": {"type": "object"},
-                                "examples": {"type": "array"}
-                            }
-                        }
+                                "examples": {"type": "array"},
+                            },
+                        },
                     },
-                    "required": ["cmdname", "info"]
-                }
-            ]
+                    "required": ["cmdname", "info"],
+                },
+            ],
         }
 
 
@@ -206,41 +227,52 @@ class HelpCommand(Command):
                         example_cmd = all_commands[0]
                         example = {
                             "command": "help",
-                            "params": {"cmdname": example_cmd}
+                            "params": {"cmdname": example_cmd},
                         }
                         note = f"Use help with an existing command name to get detailed info. For example: help with cmdname '{example_cmd}'. To list all commands: call help without parameters."
                     else:
                         example = {"command": "help"}
                         note = "No commands registered. To list all commands: call help without parameters."
-                    return HelpResult(commands_info={
-                        "commands": {},
-                        "error": f"Command '{cmdname}' not found",
-                        "example": example,
-                        "note": note
-                    })
+                    return HelpResult(
+                        commands_info={
+                            "commands": {},
+                            "error": f"Command '{cmdname}' not found",
+                            "example": example,
+                            "note": note,
+                        }
+                    )
 
             # Otherwise, return information about all available commands
             logger.debug("Обработка запроса для всех команд")
 
             # Get info for all commands
             all_commands_info = registry.get_all_commands_info()
-            logger.debug(f"Получены метаданные для {len(all_commands_info.get('commands', {}))} команд")
+            logger.debug(
+                f"Получены метаданные для {len(all_commands_info.get('commands', {}))} команд"
+            )
 
             # Prepare response format with tool metadata
             result = {
                 "tool_info": {
                     "name": "MCP-Proxy API Service",
                     "description": "JSON-RPC API for microservice command execution",
-                    "version": "1.0.0"
+                    "version": "1.0.0",
                 },
                 "help_usage": {
                     "description": "Get information about commands",
                     "examples": [
-                        {"command": "help", "description": "List of all available commands"},
-                        {"command": "help", "params": {"cmdname": "command_name"}, "description": "Get detailed information about a specific command"}
-                    ]
+                        {
+                            "command": "help",
+                            "description": "List of all available commands",
+                        },
+                        {
+                            "command": "help",
+                            "params": {"cmdname": "command_name"},
+                            "description": "Get detailed information about a specific command",
+                        },
+                    ],
                 },
-                "commands": {}
+                "commands": {},
             }
 
             # Add brief information about commands
@@ -253,7 +285,7 @@ class HelpCommand(Command):
                     schema = command_info.get("schema", {})
                     result["commands"][name] = {
                         "summary": metadata.get("summary", ""),
-                        "params_count": len(schema.get("properties", {}))
+                        "params_count": len(schema.get("properties", {})),
                     }
                 except Exception as e:
                     logger.error(f"Ошибка при обработке метаданных команды {name}: {e}")
@@ -261,21 +293,25 @@ class HelpCommand(Command):
                     # Пропускаем проблемную команду
                     continue
 
-            logger.debug(f"HelpCommand.execute завершение: возвращаем результат с {len(result['commands'])} командами")
+            logger.debug(
+                f"HelpCommand.execute завершение: возвращаем результат с {len(result['commands'])} командами"
+            )
             return HelpResult(commands_info=result)
         except Exception as e:
             logger.error(f"Неожиданная ошибка в HelpCommand.execute: {e}")
             logger.debug(f"Трассировка: {traceback.format_exc()}")
             # В случае неожиданной ошибки возвращаем пустой результат вместо ошибки
-            return HelpResult(commands_info={
-                "tool_info": {
-                    "name": "MCP-Proxy API Service",
-                    "description": "JSON-RPC API for microservice command execution",
-                    "version": "1.0.0"
-                },
-                "commands": {},
-                "error": str(e)
-            })
+            return HelpResult(
+                commands_info={
+                    "tool_info": {
+                        "name": "MCP-Proxy API Service",
+                        "description": "JSON-RPC API for microservice command execution",
+                        "version": "1.0.0",
+                    },
+                    "commands": {},
+                    "error": str(e),
+                }
+            )
 
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
@@ -290,8 +326,8 @@ class HelpCommand(Command):
             "properties": {
                 "cmdname": {
                     "type": "string",
-                    "description": "Name of command to get information about"
+                    "description": "Name of command to get information about",
                 }
             },
-            "additionalProperties": False
-        } 
+            "additionalProperties": False,
+        }