mcp-proxy-adapter 2.1.15__tar.gz → 2.1.16__tar.gz

{mcp_proxy_adapter-2.1.15/mcp_proxy_adapter.egg-info → mcp_proxy_adapter-2.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 2.1.15
+Version: 2.1.16
 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.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/adapter.py

@@ -236,7 +236,7 @@ class MCPProxyAdapter:
                 # Execute the command
                 logger.debug(f"Executing command {request.method} with parameters {request.params}")
                 try:
-                    result = await self.registry.dispatcher.execute(
+                    result = self.registry.dispatcher.execute(
                         request.method, 
                         **request.params
                     )
@@ -537,7 +537,7 @@ class MCPProxyAdapter:
                 
                 # Execute the command
                 try:
-                    result = await self.registry.dispatcher.execute(command, **params)
+                    result = self.registry.dispatcher.execute(command, **params)
                     
                     # Return result in MCP Proxy format
                     return {"result": result}

mcp_proxy_adapter-2.1.16/mcp_proxy_adapter/dispatchers/__init__.py

@@ -0,0 +1 @@
+ 

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/dispatchers/base_dispatcher.py

@@ -34,7 +34,7 @@ class BaseDispatcher(ABC):
         pass
     
     @abstractmethod
-    async def execute(self, command: str, **kwargs) -> Any:
+    def execute(self, command: str, **kwargs) -> Any:
         """
         Executes a command with the specified parameters.
         
@@ -49,7 +49,7 @@ class BaseDispatcher(ABC):
             CommandNotFoundError: If command is not found
             CommandExecutionError: On command execution error
         """
-        raise NotImplementedError("Method must be overridden in subclass")
+        pass
     
     @abstractmethod
     def get_valid_commands(self) -> List[str]:

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/dispatchers/json_rpc_dispatcher.py

@@ -79,7 +79,7 @@ class JsonRpcDispatcher(BaseDispatcher):
             ),
             summary="Command help",
             params={
-                "command": {
+                "cmdname": {
                     "type": "string",
                     "description": "Command name for detailed information",
                     "required": False
@@ -197,7 +197,7 @@ class JsonRpcDispatcher(BaseDispatcher):
         
         Args:
             params: Command parameters
-                command: Command name for detailed information
+                cmdname: Command name for detailed information
                 
         Returns:
             Dict[str, Any]: Command help information
@@ -206,8 +206,8 @@ class JsonRpcDispatcher(BaseDispatcher):
             params = {}
             
         # If specific command is specified, return information only about it
-        if "command" in params and params["command"]:
-            command = params["command"]
+        if "cmdname" in params and params["cmdname"]:
+            command = params["cmdname"]
             if command not in self._metadata:
                 return {
                     "error": f"Command '{command}' not found",
@@ -231,5 +231,5 @@ class JsonRpcDispatcher(BaseDispatcher):
         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.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/examples/docstring_and_schema_example.py

@@ -33,13 +33,13 @@ class MyRegistry:
         return self.commands_info.get(command)
     def get_commands_info(self):
         return self.commands_info
-    async def execute(self, command, **params):
+    def execute(self, command, **params):
         if command == "sum":
-            return await self.sum_numbers(**params)
+            return self.sum_numbers(**params)
         raise KeyError(f"Unknown command: {command}")
     def add_generator(self, generator):
         pass
-    async def sum_numbers(self, a: int, b: int) -> int:
+    def sum_numbers(self, a: int, b: int) -> int:
         """
         Returns the sum of two numbers.
         

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/examples/extension_example.py

@@ -20,7 +20,7 @@ class MyRegistry:
         self.commands = {"ping": self.ping, "help": self.help_command}
         self.commands_info = {
             "ping": {"description": "Ping command (returns pong)", "params": {}},
-            "help": {"description": "Show help for commands", "params": {"command": {"type": "string", "description": "Command name", "required": False}}}
+            "help": {"description": "Show help for commands", "params": {"cmdname": {"type": "string", "description": "Command name", "required": False}}}
         }
     def get_valid_commands(self):
         return list(self.commands.keys())
@@ -33,7 +33,7 @@ class MyRegistry:
             command = args[0]
             params = {k: v for k, v in params.items()}
         else:
-            command = params.pop("command", None)
+            command = params.pop("cmdname", None)
         if command == "ping":
             return self.ping()
         if command == "help":
@@ -44,13 +44,13 @@ class MyRegistry:
     def ping(self):
         """Ping command."""
         return {"result": "pong"}
-    def help_command(self, command: str = None):
+    def help_command(self, cmdname: str = None):
         """Custom help logic: returns info for command or all commands."""
-        if not command:
+        if not cmdname:
             return {"commands": list(self.commands_info.keys())}
-        if command in self.commands_info:
-            return {"command": command, "info": self.commands_info[command]}
-        return {"error": f"Command '{command}' not found"}
+        if cmdname in self.commands_info:
+            return {"command": cmdname, "info": self.commands_info[cmdname]}
+        return {"error": f"Command '{cmdname}' not found"}
 
 if __name__ == "__main__":
     registry = MyRegistry()
@@ -64,9 +64,9 @@ if __name__ == "__main__":
     print("Help (all)", result_help_all)
 
     # Call help (ping)
-    result_help_ping = registry.execute("help", command="ping")
+    result_help_ping = registry.execute("help", cmdname="ping")
     print("Help (ping)", result_help_ping)
 
     # Call help (notfound)
-    result_help_notfound = registry.execute("help", command="notfound")
+    result_help_notfound = registry.execute("help", cmdname="notfound")
     print("Help (notfound)", result_help_notfound) 

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/examples/help_best_practices.py

@@ -21,33 +21,33 @@ from mcp_proxy_adapter.testing_utils import MockRegistry
 registry = MockRegistry()
 adapter = MCPProxyAdapter(registry)
 
-def robust_help(command: str = None) -> Dict[str, Any]:
+def robust_help(cmdname: str = None) -> Dict[str, Any]:
     """
     Best practice: always check for project help, handle errors, fallback to adapter help.
     """
     dispatcher = registry.dispatcher
     if "help" in dispatcher.get_valid_commands():
         try:
-            if command:
-                return dispatcher.help_command(command=command)
+            if cmdname:
+                return dispatcher.help_command(cmdname=cmdname)
             return dispatcher.help_command()
         except Exception as e:
             # Log error, fallback to adapter help
             print(f"[WARN] Project help failed: {e}. Fallback to adapter help.")
-            return fallback_adapter_help(command)
+            return fallback_adapter_help(cmdname)
     else:
-        return fallback_adapter_help(command)
+        return fallback_adapter_help(cmdname)
 
-def fallback_adapter_help(command: str = None) -> Dict[str, Any]:
+def fallback_adapter_help(cmdname: str = None) -> Dict[str, Any]:
     """
     Fallback: call adapter's help (simulate REST/JSON-RPC call).
     """
     dispatcher = registry.dispatcher
-    if not command:
+    if not cmdname:
         return {"source": "adapter", "commands": dispatcher.get_valid_commands()}
-    if command in dispatcher.get_valid_commands():
-        return {"source": "adapter", "command": command, "info": {"description": "Adapter help for command"}}
-    return {"source": "adapter", "error": f"Command '{command}' not found (adapter)", "available_commands": dispatcher.get_valid_commands()}
+    if cmdname in dispatcher.get_valid_commands():
+        return {"source": "adapter", "command": cmdname, "info": {"description": "Adapter help for command"}}
+    return {"source": "adapter", "error": f"Command '{cmdname}' not found (adapter)", "available_commands": dispatcher.get_valid_commands()}
 
 # --- Example test cases ---
 def test_help():

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/examples/help_usage.py

@@ -24,29 +24,29 @@ registry = MockRegistry()
 adapter = MCPProxyAdapter(registry)
 
 # --- Best practice: always check if 'help' is in commands ---
-def call_help(command: str = None) -> Dict[str, Any]:
+def call_help(cmdname: str = None) -> Dict[str, Any]:
     """Call help command with or without parameter."""
     dispatcher = registry.dispatcher
     if "help" in dispatcher.get_valid_commands():
-        if command:
+        if cmdname:
             try:
-                return dispatcher.help_command(command=command)
+                return dispatcher.help_command(cmdname=cmdname)
             except Exception as e:
                 print(f"Project help failed: {e}. Fallback to adapter help.")
-                return adapter_help(command)
+                return adapter_help(cmdname)
         else:
             return dispatcher.help_command()
     else:
-        return adapter_help(command)
+        return adapter_help(cmdname)
 
-def adapter_help(command: str = None) -> Dict[str, Any]:
+def adapter_help(cmdname: str = None) -> Dict[str, Any]:
     """Fallback: call adapter's help (simulate)."""
     dispatcher = registry.dispatcher
-    if not command:
+    if not cmdname:
         return {"source": "adapter", "commands": dispatcher.get_valid_commands()}
-    if command in dispatcher.get_valid_commands():
-        return {"source": "adapter", "command": command, "info": {"description": "Adapter help for command"}}
-    return {"source": "adapter", "error": f"Command '{command}' not found (adapter)", "available_commands": dispatcher.get_valid_commands()}
+    if cmdname in dispatcher.get_valid_commands():
+        return {"source": "adapter", "command": cmdname, "info": {"description": "Adapter help for command"}}
+    return {"source": "adapter", "error": f"Command '{cmdname}' not found (adapter)", "available_commands": dispatcher.get_valid_commands()}
 
 if __name__ == "__main__":
     print("=== Project help (no param) ===")

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/examples/openapi_server.py

@@ -171,7 +171,7 @@ class MockDispatcher:
             "help": {
                 "description": "Show information about available commands or a specific command.",
                 "params": {
-                    "command": {
+                    "cmdname": {
                         "type": "string",
                         "description": "Command name for detailed info",
                         "required": False
@@ -278,19 +278,18 @@ class MockDispatcher:
 
     def help_command(self, **params):
         """Return info about all commands or a specific command."""
-        # Если в будущем появится пользовательская команда help, можно реализовать её здесь
-        command = params.get("command")
-        if command:
-            info = self.commands_info.get(command)
+        cmdname = params.get("cmdname")
+        if cmdname:
+            info = self.commands_info.get(cmdname)
             if info:
-                return {"command": command, "info": info}
+                return {"command": cmdname, "info": info}
             else:
-                return {"error": f"Command '{command}' not found", "available_commands": list(self.commands_info.keys())}
-        # Если параметр command не указан, возвращаем краткую информацию обо всех
+                return {"error": f"Command '{cmdname}' not found", "available_commands": list(self.commands_info.keys())}
+        # Если параметр cmdname не указан, возвращаем краткую информацию обо всех
         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 'command' parameter to get detailed information about a specific command"
+            "note": "Use the 'cmdname' parameter to get detailed information about a specific command"
         }
 
 # --- Создание registry и FastAPI-приложения на верхнем уровне ---

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/examples/project_structure_example.py

@@ -10,7 +10,6 @@ Run:
 """
 import os
 import sys
-import asyncio
 sys.path.insert(0, os.path.abspath(os.path.dirname(os.path.dirname(__file__))))
 from fastapi import FastAPI
 from mcp_proxy_adapter.adapter import MCPProxyAdapter
@@ -27,7 +26,7 @@ class MyRegistry:
         return self.commands_info.get(command)
     def get_commands_info(self):
         return self.commands_info
-    async def execute(self, command, **params):
+    def execute(self, command, **params):
         if command == "hello":
             return {"message": "Hello, world!"}
         raise KeyError(f"Unknown command: {command}")
@@ -45,8 +44,4 @@ adapter.register_endpoints(app)
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
-
-# Call sync handler
-result_sync = registry.execute('hello')
-print(result_sync)  # {'message': 'Hello, world!'} 
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/examples/testing_example.py

@@ -17,14 +17,8 @@ from mcp_proxy_adapter.adapter import MCPProxyAdapter
 class MyRegistry:
     def __init__(self):
         self.dispatcher = self
-        self.commands = {
-            "echo": self.echo,
-            "async_double": self.async_double
-        }
-        self.commands_info = {
-            "echo": {"description": "Echo input string", "params": {"text": {"type": "string", "description": "Text to echo", "required": True}}},
-            "async_double": {"description": "Double the input asynchronously", "params": {"x": {"type": "integer", "description": "Value to double", "required": True}}}
-        }
+        self.commands = {"echo": self.echo}
+        self.commands_info = {"echo": {"description": "Echo input string", "params": {"text": {"type": "string", "description": "Text to echo", "required": True}}}}
     def get_valid_commands(self):
         return list(self.commands.keys())
     def get_command_info(self, command):
@@ -34,17 +28,12 @@ class MyRegistry:
     def execute(self, command, **params):
         if command == "echo":
             return self.echo(**params)
-        if command == "async_double":
-            return self.async_double(**params)
         raise KeyError(f"Unknown command: {command}")
     def add_generator(self, generator):
         pass
     def echo(self, text: str) -> str:
         """Echo input string."""
         return text
-    async def async_double(self, x: int) -> int:
-        await asyncio.sleep(0.01)
-        return x * 2
 
 def test_echo():
     registry = MyRegistry()
@@ -67,7 +56,7 @@ result_sync = registry.execute('echo', text='hi')
 print(result_sync)  # hi
 
 # Call async handler
-result_async = asyncio.run(registry.execute('async_double', x=10))
+result_async = asyncio.run(registry.execute('async', x=10))
 print(result_async)  # 20
 
 if __name__ == "__main__":

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/registry.py

@@ -416,16 +416,18 @@ class CommandRegistry:
         
         return stats
     
-    async def execute(self, command: str, **kwargs) -> Any:
+    def execute(self, command: str, **kwargs) -> Any:
         """
-        Executes a command with the specified parameters.
+        Executes a command through the dispatcher.
+        
+        Args:
+            command: Command name
+            **kwargs: Command parameters
+            
+        Returns:
+            Any: Command execution result
         """
-        if command not in self._commands_info:
-            raise KeyError(f"Unknown command: {command}")
-        handler = self._commands_info[command]["handler"]
-        if inspect.iscoroutinefunction(handler):
-            return await handler(**kwargs)
-        return handler(**kwargs)
+        return self.dispatcher.execute(command, **kwargs)
     
     def get_commands_info(self) -> Dict[str, Dict[str, Any]]:
         """

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter/testing_utils.py

@@ -4,9 +4,6 @@ Test utilities for MCP Proxy Adapter: mock dispatcher, registry, and OpenAPI gen
 Can be used in examples and tests.
 """
 
-import asyncio
-import inspect
-
 def success_command(value: int = 1) -> dict:
     return {"result": value * 2}
 
@@ -68,18 +65,13 @@ class MockDispatcher:
     def execute_from_params(self, **params):
         if "query" in params and params["query"] in self.commands:
             command = params.pop("query")
-            result = self.execute(command, **params)
-            return result
+            return self.execute(command, **params)
         return {"available_commands": self.get_valid_commands(), "received_params": params}
 
-    async def execute(self, command, **params):
+    def execute(self, command, **params):
         if command not in self.commands:
             raise KeyError(f"Unknown command: {command}")
-        handler = self.commands[command]
-        if inspect.iscoroutinefunction(handler):
-            return await handler(**params)
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, lambda: handler(**params))
+        return self.commands[command](**params)
 
     def get_valid_commands(self):
         return list(self.commands.keys())

mcp_proxy_adapter-2.1.16/mcp_proxy_adapter/validators/__init__.py

@@ -0,0 +1 @@
+ 

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16/mcp_proxy_adapter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 2.1.15
+Version: 2.1.16
 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.15 → mcp_proxy_adapter-2.1.16}/mcp_proxy_adapter.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ pyproject.toml
 requirements.txt
 setup.py
 docs/RU/FAQ_HOWTO.md
+mcp_proxy_adapter/__init__.py
 mcp_proxy_adapter/adapter.py
 mcp_proxy_adapter/models.py
 mcp_proxy_adapter/registry.py
@@ -32,6 +33,7 @@ mcp_proxy_adapter/examples/mcp_proxy_client.py
 mcp_proxy_adapter/examples/openapi_server.py
 mcp_proxy_adapter/examples/project_structure_example.py
 mcp_proxy_adapter/examples/testing_example.py
+mcp_proxy_adapter/validators/__init__.py
 mcp_proxy_adapter/validators/docstring_validator.py
 mcp_proxy_adapter/validators/metadata_validator.py
 tests/conftest.py

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-proxy-adapter"
-version = "2.1.15"
+version = "2.1.16"
 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.15 → mcp_proxy_adapter-2.1.16}/tests/test_adapter.py

@@ -12,7 +12,6 @@ from typing import Dict, Any, List, Optional, Callable, Type
 import inspect
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
-import asyncio
 
 # Add parent directory to import path
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -63,71 +62,6 @@ class BaseDispatcher:
         """Returns information about all commands."""
         raise NotImplementedError("Method must be overridden in subclass")
 
-# Общая информация о командах для моков
-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
-            }
-        }
-    }
-}
-
-# Универсальный обработчик для команды 'execute' в моках
-def mock_execute_command(query=None, **params):
-    """Universal command for executing other commands in mocks."""
-    if not query:
-        return {"available_commands": list(MOCK_COMMANDS.keys()), "received_params": params}
-    if query not in COMMANDS_INFO:
-        return {"error": f"Unknown command: {query}"}
-    # Получаем функцию-обработчик
-    handler = MOCK_COMMANDS.get(query)
-    if not handler:
-        return {"error": f"Handler not found for command: {query}"}
-    return handler(**params)
-
-# Словарь команд для универсального вызова
-MOCK_COMMANDS = {
-    "success": success_command,
-    "error": error_command,
-    "param": param_command
-}
-
 # Mock for command dispatcher
 class MockDispatcher(BaseDispatcher):
     """Mock for command dispatcher in tests."""
@@ -137,24 +71,66 @@ class MockDispatcher(BaseDispatcher):
             "success": success_command,
             "error": error_command,
             "param": param_command,
-            "execute": mock_execute_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
+                    }
+                }
+            }
         }
-        self.commands_info = COMMANDS_INFO
-    
-    async def execute(self, command, **params):
-        if command not in self.commands:
-            raise KeyError(f"Unknown command: {command}")
-        handler = self.commands[command]
-        if inspect.iscoroutinefunction(handler):
-            return await handler(**params)
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, lambda: handler(**params))
     
-    async def execute_from_params(self, **params):
+    def execute_from_params(self, **params):
+        """Executes command based on parameters."""
         if "query" in params and params["query"] in self.commands:
             command = params.pop("query")
-            return await self.execute(command, **params)
-        return {"available_commands": self.get_valid_commands(), "received_params": params}
+            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())
@@ -198,7 +174,6 @@ def adapter(registry):
 def test_app(adapter):
     """Creates a test FastAPI application with configured adapter."""
     app = FastAPI()
-    adapter.registry.dispatcher = MockDispatcher()
     adapter.register_endpoints(app)
     return TestClient(app)
 
@@ -520,15 +495,16 @@ def test_configure_logger():
     default_logger = configure_logger()
     assert default_logger.name == "mcp_proxy_adapter"
 
-@pytest.mark.asyncio
-async def test_params_only_format(test_app):
+def test_params_only_format(test_app):
     """Test request format with only params."""
     # Test request with only params field
     response = test_app.post("/cmd", json={
         "params": {"query": "success", "value": 5}
     })
+    
     assert response.status_code == 200
     data = response.json()
+    assert "result" in data
     assert data["result"] == {"result": 10}
     
     # Test request with command in params
@@ -550,36 +526,4 @@ async 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"]
-
-def test_execute_from_params():
-    dispatcher = SyncMockDispatcher()
-    result = dispatcher.execute_from_params(query="success", value=2)
-    assert result == {"result": 4}
-    result2 = dispatcher.execute_from_params()
-    assert "available_commands" in result2
-
-class SyncMockDispatcher(BaseDispatcher):
-    def __init__(self):
-        self.commands = {
-            "success": success_command,
-            "error": error_command,
-            "param": param_command,
-            "execute": mock_execute_command
-        }
-        self.commands_info = COMMANDS_INFO
-    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 
+    assert "received_params" in data["result"] 

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/tests/test_adapter_coverage.py

@@ -8,8 +8,6 @@ import json
 import logging
 from unittest.mock import MagicMock, patch
 from typing import Dict, Any, List, Optional
-import asyncio
-import inspect
 
 # Add parent directory to path for imports
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -67,28 +65,31 @@ class MockDispatcher:
         }
     
     def execute_from_params(self, **params):
+        """Executes command based on parameters."""
         if "query" in params and params["query"] in self.commands:
             command = params.pop("query")
-            result = self.execute(command, **params)
-            return result
-        return {"available_commands": self.get_valid_commands(), "received_params": params}
+            return self.execute(command, **params)
+        return {
+            "available_commands": self.get_valid_commands(),
+            "received_params": params
+        }
     
-    async def execute(self, command, **params):
+    def execute(self, command, **params):
+        """Executes command with specified parameters."""
         if command not in self.commands:
             raise KeyError(f"Unknown command: {command}")
-        handler = self.commands[command]
-        if inspect.iscoroutinefunction(handler):
-            return await handler(**params)
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, lambda: handler(**params))
+        return self.commands[command](**params)
     
     def get_valid_commands(self):
+        """Returns list of available commands."""
         return list(self.commands.keys())
     
     def get_command_info(self, command):
+        """Returns information about command."""
         return self.commands_info.get(command)
     
     def get_commands_info(self):
+        """Returns information about all commands."""
         return self.commands_info
 
 # Mock for CommandRegistry

{mcp_proxy_adapter-2.1.15 → mcp_proxy_adapter-2.1.16}/tests/test_mcp_proxy_adapter.py

@@ -10,8 +10,6 @@ import pytest
 import tempfile
 from unittest.mock import MagicMock, patch
 import types
-import inspect
-import asyncio
 
 # Добавляем путь к исходникам
 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
@@ -137,20 +135,20 @@ class MockDispatcher:
         }
     
     def execute_from_params(self, **params):
+        """Executes command based on parameters."""
         if "query" in params and params["query"] in self.commands:
             command = params.pop("query")
-            result = self.execute(command, **params)
-            return result
-        return {"available_commands": self.get_valid_commands(), "received_params": params}
+            return self.execute(command, **params)
+        return {
+            "available_commands": self.get_valid_commands(),
+            "received_params": params
+        }
     
-    async def execute(self, command, **params):
+    def execute(self, command, **params):
+        """Executes command with specified parameters."""
         if command not in self.commands:
             raise KeyError(f"Unknown command: {command}")
-        handler = self.commands[command]
-        if inspect.iscoroutinefunction(handler):
-            return await handler(**params)
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, lambda: handler(**params))
+        return self.commands[command](**params)
     
     def get_valid_commands(self):
         """Returns list of available commands."""
@@ -339,16 +337,10 @@ class HelpDispatcher(MockDispatcher):
         if project_help:
             self.commands["help"] = self.help_command
             self.commands_info["help"] = {"description": "Project help command", "params": {"command": {"type": "string", "required": False}}}
-    async def help_command(self, **params):
-        result = self.project_help(**params)
-        if inspect.isawaitable(result):
-            return await result
-        return result
-    async def adapter_help_command(self, **params):
-        result = self.adapter_help(**params)
-        if inspect.isawaitable(result):
-            return await result
-        return result
+    def help_command(self, **params):
+        return self.project_help(**params)
+    def adapter_help_command(self, **params):
+        return self.adapter_help(**params)
 
 class HelpRegistry(MockRegistry):
     def __init__(self, project_help=None, adapter_help=None):
@@ -376,75 +368,71 @@ def test_successful_command_execution(test_app):
     assert data["result"] == {"result": 10}
 
 # === HELP WRAPPER TESTS ===
-@pytest.mark.asyncio
-async def test_help_project_no_param(monkeypatch, help_project_command, help_adapter_command):
+def test_help_project_no_param(monkeypatch, help_project_command, help_adapter_command):
     """help реализован в проекте, вызов без параметров: должен вызываться help проекта."""
     registry = HelpRegistry(project_help=help_project_command, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command()
+    # monkeypatch: simulate help-wrapper logic
+    result = registry.dispatcher.help_command()
     assert result["source"] == "project"
     assert "commands" in result
 
-@pytest.mark.asyncio
-async def test_help_project_with_param(monkeypatch, help_project_command, help_adapter_command):
+def test_help_project_with_param(monkeypatch, help_project_command, help_adapter_command):
     """help реализован в проекте, вызов с существующим параметром: должен вызываться help проекта."""
     registry = HelpRegistry(project_help=help_project_command, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command(command="success")
+    result = registry.dispatcher.help_command(command="success")
     assert result["source"] == "project"
     assert result["command"] == "success"
     assert "info" in result
 
-@pytest.mark.asyncio
-async def test_help_project_with_wrong_param(monkeypatch, help_project_command, help_adapter_command):
+def test_help_project_with_wrong_param(monkeypatch, help_project_command, help_adapter_command):
     """help реализован в проекте, вызов с несуществующим параметром: help проекта возвращает ошибку, вызывается help-адаптер."""
     registry = HelpRegistry(project_help=help_project_command, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command(command="unknown")
+    # Симулируем: если help проекта вернул ошибку, вызываем help-адаптер
+    result = registry.dispatcher.help_command(command="unknown")
     if "error" in result:
-        adapter_result = await registry.dispatcher.adapter_help_command(command="unknown")
+        adapter_result = registry.dispatcher.adapter_help_command(command="unknown")
         assert adapter_result["source"] == "adapter"
         assert "error" in adapter_result
     else:
         assert False, "Project help should return error for unknown command"
 
-@pytest.mark.asyncio
-async def test_help_adapter_no_project(monkeypatch, help_adapter_command):
+def test_help_adapter_no_project(monkeypatch, help_adapter_command):
     """help не реализован в проекте, вызов без параметров: должен вызываться help-адаптер."""
     registry = HelpRegistry(project_help=None, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.adapter_help_command()
+    # Симулируем: help-адаптер вызывается напрямую
+    result = registry.dispatcher.adapter_help_command()
     assert result["source"] == "adapter"
     assert "commands" in result
 
-@pytest.mark.asyncio
-async def test_help_adapter_with_param_no_project(monkeypatch, help_adapter_command):
+def test_help_adapter_with_param_no_project(monkeypatch, help_adapter_command):
     """help не реализован в проекте, вызов с параметром: должен вызываться help-адаптер."""
     registry = HelpRegistry(project_help=None, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.adapter_help_command(command="success")
+    result = registry.dispatcher.adapter_help_command(command="success")
     assert result["source"] == "adapter"
     assert result["command"] == "success"
     assert "info" in result
 
 # === COVERAGE BOOST TESTS ===
-@pytest.mark.asyncio
-async def test_dispatcher_keyerror():
+def test_dispatcher_keyerror():
     """Test KeyError for unknown command in MockDispatcher."""
     dispatcher = MockDispatcher()
     with pytest.raises(KeyError):
-        await dispatcher.execute("unknown")
+        dispatcher.execute("unknown")
 
-@pytest.mark.asyncio
-async def test_dispatcher_type_error():
+def test_dispatcher_type_error():
     """Test TypeError for wrong param type in type_error_command."""
     dispatcher = MockDispatcher()
+    # Явно добавляем type_error команду, если вдруг отсутствует
     dispatcher.commands["type_error"] = type_error_command
     with pytest.raises(TypeError):
-        await dispatcher.execute("type_error", param="not_an_int")
+        dispatcher.execute("type_error", param="not_an_int")
 
-@pytest.mark.asyncio
-async def test_execute_from_params_edge():
+def test_execute_from_params_edge():
     """Test execute_from_params with unknown query and empty params."""
     dispatcher = MockDispatcher()
     result = dispatcher.execute_from_params(query="unknown")
@@ -467,8 +455,7 @@ def test_adapter_fixtures(adapter, adapter_with_openapi, no_schema_adapter, no_o
     assert isinstance(no_optimize_adapter, MCPProxyAdapter)
     assert isinstance(custom_prefix_adapter, MCPProxyAdapter)
 
-@pytest.mark.asyncio
-async def test_custom_logger_fixture(custom_logger):
+def test_custom_logger_fixture(custom_logger):
     """Test custom_logger fixture."""
     logger, log_records = custom_logger
     logger.info("test message")
@@ -508,57 +495,72 @@ def test_help_dispatcher_and_registry():
     assert registry.generators
 
 # === DETAILED HELP-COMMAND TESTS ===
-@pytest.mark.asyncio
-async def test_project_help_priority(monkeypatch, help_project_command, help_adapter_command):
+def test_project_help_priority(monkeypatch, help_project_command, help_adapter_command):
     """If project help exists, it must always be called first (no param)."""
     registry = HelpRegistry(project_help=help_project_command, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command()
+    # Симулируем вызов help без параметров
+    result = registry.dispatcher.help_command()
     assert result["source"] == "project"
     assert "commands" in result
+    # Адаптер не должен вызываться
     assert not ("adapter" in result.get("source", ""))
 
-@pytest.mark.asyncio
-async def test_project_help_with_param_success(monkeypatch, help_project_command, help_adapter_command):
+def test_project_help_with_param_success(monkeypatch, help_project_command, help_adapter_command):
     """Project help with valid param: must return project info, not adapter."""
     registry = HelpRegistry(project_help=help_project_command, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command(command="success")
+    result = registry.dispatcher.help_command(command="success")
     assert result["source"] == "project"
     assert result["command"] == "success"
     assert "info" in result
+    # Адаптер не должен вызываться
     assert not ("adapter" in result.get("source", ""))
 
-@pytest.mark.asyncio
-async def test_project_help_with_param_not_found(monkeypatch, help_project_command, help_adapter_command):
+def test_project_help_with_param_not_found(monkeypatch, help_project_command, help_adapter_command):
     """Project help with unknown param: must call adapter help after project help error."""
     registry = HelpRegistry(project_help=help_project_command, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command(command="unknown")
+    result = registry.dispatcher.help_command(command="unknown")
+    # Проектный help возвращает ошибку
     assert "error" in result
-    adapter_result = await registry.dispatcher.adapter_help_command(command="unknown")
+    # После ошибки вызывается help-адаптер
+    adapter_result = registry.dispatcher.adapter_help_command(command="unknown")
     assert adapter_result["source"] == "adapter"
     assert "error" in adapter_result
 
-@pytest.mark.asyncio
-async def test_project_help_with_param_none(monkeypatch, help_project_command, help_adapter_command):
+def test_project_help_with_param_exception(monkeypatch, help_adapter_command):
+    """Project help raises exception: adapter help must be called as fallback."""
+    def broken_help(**params):
+        raise RuntimeError("project help failed")
+    registry = HelpRegistry(project_help=broken_help, adapter_help=help_adapter_command)
+    adapter = MCPProxyAdapter(registry)
+    # Симулируем: если проектный help падает, вызываем help-адаптер
+    try:
+        registry.dispatcher.help_command(command="any")
+    except Exception as e:
+        adapter_result = registry.dispatcher.adapter_help_command(command="any")
+        assert adapter_result["source"] == "adapter"
+        assert "commands" in adapter_result or "error" in adapter_result
+
+def test_project_help_with_param_none(monkeypatch, help_project_command, help_adapter_command):
     """Project help with param=None: must return project help info."""
     registry = HelpRegistry(project_help=help_project_command, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command(command=None)
+    result = registry.dispatcher.help_command(command=None)
     assert result["source"] == "project"
     assert "commands" in result
 
-@pytest.mark.asyncio
-async def test_project_help_returns_unexpected_type(monkeypatch, help_adapter_command):
+def test_project_help_returns_unexpected_type(monkeypatch, help_adapter_command):
     """Project help returns unexpected type: adapter help must be called as fallback."""
     def weird_help(**params):
         return "not a dict"
     registry = HelpRegistry(project_help=weird_help, adapter_help=help_adapter_command)
     adapter = MCPProxyAdapter(registry)
-    result = await registry.dispatcher.help_command(command="any")
+    result = registry.dispatcher.help_command(command="any")
+    # Если результат не dict, вызываем help-адаптер
     if not isinstance(result, dict):
-        adapter_result = await registry.dispatcher.adapter_help_command(command="any")
+        adapter_result = registry.dispatcher.adapter_help_command(command="any")
         assert adapter_result["source"] == "adapter"
         assert "commands" in adapter_result or "error" in adapter_result