mcp-proxy-adapter 2.1.7__tar.gz → 2.1.9__tar.gz

{mcp_proxy_adapter-2.1.7/mcp_proxy_adapter.egg-info → mcp_proxy_adapter-2.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 2.1.7
+Version: 2.1.9
 Summary: Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy.
 Home-page: https://github.com/vasilyvz/mcp-proxy-adapter
 Author: Vasiliy VZ

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9}/mcp_proxy_adapter/adapter.py

@@ -493,6 +493,13 @@ class MCPProxyAdapter:
                             "details": "Request requires 'command', 'method' or 'params' field"
                         }
                     }
+                # Подмена help -> __help
+                if command == "help":
+                    command = "__help"
+                    # Переименовываем параметр внутри params
+                    if "command" in params:
+                        params["cmdname"] = params.pop("command")
+                logger.info(f"[DEBUG] MCP CMD: command={command}, params={params}")
                 
                 # Check if command exists
                 if command not in self.registry.dispatcher.get_valid_commands():
@@ -501,12 +508,14 @@ class MCPProxyAdapter:
                         "error": {
                             "code": 404,
                             "message": f"Unknown command: {command}",
-                            "details": f"Command '{command}' not found in registry. Available commands: {', '.join(self.registry.dispatcher.get_valid_commands())}"
+                            "details": f"Unknown command: {command}. Available commands: {', '.join(self.registry.dispatcher.get_valid_commands())}"
                         }
                     }
                 
+                logger.info(f"[DEBUG] MCP CMD: command={command}, params={params}")
                 # Check for required parameters
                 command_info = self.registry.dispatcher.get_command_info(command)
+                logger.info(f"[DEBUG] MCP CMD: command_info={command_info}")
                 if command_info and "params" in command_info:
                     missing_params = []
                     for param_name, param_info in command_info["params"].items():
@@ -522,7 +531,7 @@ class MCPProxyAdapter:
                                 "details": f"Command '{command}' requires following parameters: {', '.join(missing_params)}"
                             }
                         }
-                
+                logger.info(f"[DEBUG] MCP CMD: command={command}, params={params}")
                 # Check parameter types
                 type_errors = self._validate_param_types(command, params)
                 if type_errors:
@@ -534,9 +543,10 @@ class MCPProxyAdapter:
                             "details": "Check parameter types and try again"
                         }
                     }
-                
+                logger.info(f"[DEBUG] MCP CMD: command={command}, params={params}")
                 # Execute the command
                 try:
+                    logger.info(f"[DEBUG] MCP CMD: executing command={command}, params={params}")
                     result = self.registry.dispatcher.execute(command, **params)
                     
                     # Return result in MCP Proxy format

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9}/mcp_proxy_adapter/dispatchers/json_rpc_dispatcher.py

@@ -41,7 +41,7 @@ class JsonRpcDispatcher(BaseDispatcher):
             description="Returns information about available commands",
             summary="Command help",
             params={
-                "command": {
+                "cmdname": {
                     "type": "string",
                     "description": "Command name for detailed information",
                     "required": False
@@ -157,31 +157,26 @@ class JsonRpcDispatcher(BaseDispatcher):
     def _help_command(self, params: Dict[str, Any] = None) -> Dict[str, Any]:
         """
         Built-in help command for getting command information.
-        
         Args:
-            params: Command parameters
-                command: Command name for detailed information
-                
+            params: Command parameters (dict)
+                cmdname: Command name for detailed information
         Returns:
             Dict[str, Any]: Command help information
         """
-        if not params:
+        if params is None:
             params = {}
-            
         # If specific command is specified, return information only about it
-        if "command" in params and params["command"]:
-            command = params["command"]
-            if command not in self._metadata:
+        cmdname = params.get("cmdname")
+        if cmdname:
+            if cmdname not in self._metadata:
                 return {
-                    "error": f"Command '{command}' not found",
+                    "error": f"Command '{cmdname}' not found",
                     "available_commands": list(self._metadata.keys())
                 }
-            
             return {
-                "command": command,
-                "info": self._metadata[command]
+                "cmdname": cmdname,
+                "info": self._metadata[cmdname]
             }
-        
         # Otherwise return brief information about all commands
         commands_info = {}
         for cmd, info in self._metadata.items():
@@ -190,9 +185,8 @@ class JsonRpcDispatcher(BaseDispatcher):
                 "description": info["description"],
                 "params_count": len(info["params"])
             }
-        
         return {
             "commands": commands_info,
             "total": len(commands_info),
-            "note": "Use the 'command' parameter to get detailed information about a specific command"
+            "note": "Use the 'cmdname' parameter to get detailed information about a specific command"
         } 

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9}/mcp_proxy_adapter/examples/openapi_server.py

@@ -26,7 +26,7 @@ from mcp_proxy_adapter.models import JsonRpcRequest, JsonRpcResponse
 
 # Import MockRegistry from tests for example
 # (in a real project, CommandRegistry would be used)
-from tests.test_mcp_proxy_adapter import MockRegistry
+from mcp_proxy_adapter.testing_utils import MockRegistry
 
 # Configure logging
 logging.basicConfig(level=logging.DEBUG)

mcp_proxy_adapter-2.1.9/mcp_proxy_adapter/testing_utils.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+Test utilities for MCP Proxy Adapter: mock dispatcher, registry, and OpenAPI generator.
+Can be used in examples and tests.
+"""
+
+def success_command(value: int = 1) -> dict:
+    return {"result": value * 2}
+
+def error_command() -> None:
+    raise ValueError("Test error")
+
+def param_command(required_param: str, optional_param: int = 0) -> dict:
+    return {"required": required_param, "optional": optional_param}
+
+def complex_param_command(array_param: list, object_param: dict, bool_param: bool = True) -> dict:
+    return {
+        "array_length": len(array_param),
+        "object_keys": list(object_param.keys()),
+        "bool_value": bool_param
+    }
+
+def type_error_command(param: int) -> dict:
+    return {"param": param + 1}
+
+class MockDispatcher:
+    def __init__(self):
+        self.commands = {
+            "success": success_command,
+            "error": error_command,
+            "param": param_command,
+            "execute": self.execute_from_params
+        }
+        self.commands_info = {
+            "success": {
+                "description": "Successful command",
+                "params": {"value": {"type": "integer", "description": "Input value", "required": False, "default": 1}}
+            },
+            "error": {"description": "Command with error", "params": {}},
+            "param": {
+                "description": "Command with parameters",
+                "params": {
+                    "required_param": {"type": "string", "description": "Required parameter", "required": True},
+                    "optional_param": {"type": "integer", "description": "Optional parameter", "required": False, "default": 0}
+                }
+            },
+            "execute": {
+                "description": "Universal command for executing other commands",
+                "params": {"query": {"type": "string", "description": "Command or query to execute", "required": False}}
+            },
+            "complex_param": {
+                "description": "Command with complex parameters",
+                "params": {
+                    "array_param": {"type": "array", "description": "Array of values", "required": True},
+                    "object_param": {"type": "object", "description": "Object", "required": True},
+                    "bool_param": {"type": "boolean", "description": "Boolean value", "required": False, "default": True}
+                }
+            },
+            "type_error": {
+                "description": "Command that will raise TypeError",
+                "params": {"param": {"type": "integer", "description": "Integer parameter", "required": True}}
+            }
+        }
+
+    def execute_from_params(self, **params):
+        if "query" in params and params["query"] in self.commands:
+            command = params.pop("query")
+            return self.execute(command, **params)
+        return {"available_commands": self.get_valid_commands(), "received_params": params}
+
+    def execute(self, command, **params):
+        if command not in self.commands:
+            raise KeyError(f"Unknown command: {command}")
+        return self.commands[command](**params)
+
+    def get_valid_commands(self):
+        return list(self.commands.keys())
+
+    def get_command_info(self, command):
+        return self.commands_info.get(command)
+
+    def get_commands_info(self):
+        return self.commands_info
+
+class MockRegistry:
+    def __init__(self, use_openapi_generator=False):
+        self.dispatcher = MockDispatcher()
+        self.generators = []
+        self.use_openapi_generator = use_openapi_generator
+
+    def get_commands_info(self):
+        return self.dispatcher.get_commands_info()
+
+    def add_generator(self, generator):
+        self.generators.append(generator)
+        if hasattr(generator, 'set_dispatcher'):
+            generator.set_dispatcher(self.dispatcher)
+
+class MockOpenApiGenerator:
+    def __init__(self, **kwargs):
+        self.dispatcher = None
+        self.kwargs = kwargs
+
+    def set_dispatcher(self, dispatcher):
+        self.dispatcher = dispatcher
+
+    def generate_schema(self):
+        return {
+            "openapi": "3.0.0",
+            "info": {"title": "Mock API", "version": "1.0.0"},
+            "paths": {}
+        } 

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9/mcp_proxy_adapter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 2.1.7
+Version: 2.1.9
 Summary: Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy.
 Home-page: https://github.com/vasilyvz/mcp-proxy-adapter
 Author: Vasiliy VZ

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9}/mcp_proxy_adapter.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ mcp_proxy_adapter/adapter.py
 mcp_proxy_adapter/models.py
 mcp_proxy_adapter/registry.py
 mcp_proxy_adapter/schema.py
+mcp_proxy_adapter/testing_utils.py
 mcp_proxy_adapter.egg-info/PKG-INFO
 mcp_proxy_adapter.egg-info/SOURCES.txt
 mcp_proxy_adapter.egg-info/dependency_links.txt

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-proxy-adapter"
-version = "2.1.7"
+version = "2.1.9"
 description = "Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy."
 readme = "README.md"
 requires-python = ">=3.9"

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9}/setup.py

@@ -14,7 +14,7 @@ with open(os.path.join(here, 'requirements.txt'), encoding='utf-8') as f:
 
 setup(
     name="mcp-proxy-adapter",
-    version="2.1.7",
+    version="2.1.9",
     description="Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy.",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -42,6 +42,6 @@ setup(
     },
     include_package_data=True,
     package_data={
-        'mcp_proxy_adapter': ['examples/*.py', 'examples/*.json', 'docs/*.md', '../README.md'],
+        'mcp_proxy_adapter': ['examples/*.py', 'examples/*.json', 'docs/*.md', '../README.md', 'testing_utils.py'],
     },
 ) 

{mcp_proxy_adapter-2.1.7 → mcp_proxy_adapter-2.1.9}/tests/test_adapter.py

@@ -29,6 +29,8 @@ except ImportError:
     from src.adapter import MCPProxyAdapter, configure_logger
     from src.registry import CommandRegistry
 
+print('LOADED test_adapter.py')
+
 # Test command functions
 def success_command(value: int = 1) -> dict:
     """Test command that completes successfully."""
@@ -63,7 +65,7 @@ class BaseDispatcher:
         raise NotImplementedError("Method must be overridden in subclass")
 
 # Mock for command dispatcher
-class MockDispatcher(BaseDispatcher):
+class MockDispatcherXXX(BaseDispatcher):
     """Mock for command dispatcher in tests."""
     
     def __init__(self):
@@ -71,7 +73,8 @@ class MockDispatcher(BaseDispatcher):
             "success": success_command,
             "error": error_command,
             "param": param_command,
-            "execute": self.execute_from_params
+            "execute": self.execute_from_params,
+            "__help": self.help_command
         }
         self.commands_info = {
             "success": {
@@ -114,6 +117,16 @@ class MockDispatcher(BaseDispatcher):
                         "required": False
                     }
                 }
+            },
+            "__help": {
+                "description": "Show help for commands",
+                "params": {
+                    "cmdname": {
+                        "type": "string",
+                        "description": "Command name for detailed info",
+                        "required": False
+                    }
+                }
             }
         }
     
@@ -121,6 +134,8 @@ class MockDispatcher(BaseDispatcher):
         """Executes command based on parameters."""
         if "query" in params and params["query"] in self.commands:
             command = params.pop("query")
+            if command == "help":
+                command = "__help"
             return self.execute(command, **params)
         return {
             "available_commands": self.get_valid_commands(),
@@ -128,25 +143,48 @@ class MockDispatcher(BaseDispatcher):
         }
     
     def execute(self, command, **params):
+        print(f"[DEBUG] execute called: command={command}, params={params}")
+        if command == "help":
+            command = "__help"
         if command not in self.commands:
             raise KeyError(f"Unknown command: {command}")
+        if command == "__help":
+            return self.commands[command](params=params)
         return self.commands[command](**params)
     
     def get_valid_commands(self):
         return list(self.commands.keys())
     
     def get_command_info(self, command):
+        if command == "help":
+            command = "__help"
         return self.commands_info.get(command)
     
     def get_commands_info(self):
         return self.commands_info
 
+    def help_command(self, params=None):
+        import traceback; print(f"[DEBUG] help_command called with params: {params}"); print(f"[DEBUG] commands_info: {self.commands_info}"); traceback.print_stack()
+        if params is None:
+            params = {}
+        cmdname = params.get("cmdname")
+        if cmdname:
+            if cmdname in self.commands_info:
+                return {"cmdname": cmdname, "info": self.commands_info[cmdname]}
+            else:
+                return {"error": f"Command '{cmdname}' not found", "available_commands": list(self.commands_info.keys())}
+        return {
+            "commands": {cmd: {"description": info["description"], "params": info["params"]} for cmd, info in self.commands_info.items()},
+            "total": len(self.commands_info),
+            "note": "Use the 'cmdname' parameter to get detailed information about a specific command"
+        }
+
 # Mock for CommandRegistry
 class MockRegistry:
     """Mock for CommandRegistry in tests."""
     
     def __init__(self):
-        self.dispatcher = MockDispatcher()
+        self.dispatcher = MockDispatcherXXX()
         self.generators = []
     
     def get_commands_info(self):
@@ -419,9 +457,9 @@ def test_save_config_to_file(adapter, tmp_path):
     
     assert "version" in config
     assert "tools" in config
-    assert len(config["tools"]) == 4  # Corrected: now we have 4 commands
+    assert len(config["tools"]) == 5  # Теперь 5 команд (включая help)
     assert "routes" in config
-    assert len(config["routes"]) == 4  # Corrected: now we have 4 routes, corresponding to commands
+    assert len(config["routes"]) == 5  # Теперь 5 маршрутов
 
 def test_parameter_type_validation(test_app):
     """Test parameter type validation."""
@@ -526,4 +564,62 @@ def test_params_only_format(test_app):
     data = response.json()
     assert "result" in data
     assert "available_commands" in data["result"]
-    assert "received_params" in data["result"] 
+    assert "received_params" in data["result"]
+
+def test_jsonrpc_proxy_and_help_conflict(test_app):
+    """Test JSON-RPC proxying and help/command param conflict."""
+    # Обычный JSON-RPC вызов существующей команды
+    response = test_app.post("/cmd", json={
+        "jsonrpc": "2.0",
+        "method": "success",
+        "params": {"value": 3},
+        "id": 42
+    })
+    assert response.status_code == 200
+    data = response.json()
+    assert "result" in data
+    assert data["result"] == {"result": 6}
+
+    # Вызов help по конкретной команде (не должно быть multiple values for argument 'command')
+    response = test_app.post("/cmd", json={
+        "jsonrpc": "2.0",
+        "method": "help",
+        "params": {"cmdname": "success"},
+        "id": 43
+    })
+    assert response.status_code == 200
+    data = response.json()
+    assert "result" in data
+    assert data["result"]["cmdname"] == "success"
+    assert "info" in data["result"]
+    assert "description" in data["result"]["info"]
+
+    # Вызов help по несуществующей команде
+    response = test_app.post("/cmd", json={
+        "jsonrpc": "2.0",
+        "method": "help",
+        "params": {"cmdname": "not_a_command"},
+        "id": 44
+    })
+    assert response.status_code == 200
+    data = response.json()
+    assert "result" in data
+    # Ошибка может быть либо в data['result']['error'], либо в data['error']['message']
+    found = False
+    if "error" in data["result"] and "not found" in data["result"]["error"]:
+        found = True
+    if "error" in data and "message" in data["error"] and "not found" in data["error"]["message"]:
+        found = True
+    assert found, f"No 'not found' in error: {data}"
+
+    # Вызов несуществующей команды
+    response = test_app.post("/cmd", json={
+        "jsonrpc": "2.0",
+        "method": "not_a_command",
+        "params": {},
+        "id": 45
+    })
+    assert response.status_code == 200
+    data = response.json()
+    assert "error" in data
+    assert "Unknown command" in data["error"]["message"]