mcp-proxy-adapter 3.1.6__py3-none-any.whl → 4.1.0__py3-none-any.whl

mcp_proxy_adapter/tests/unit/test_base_command.py

@@ -1,130 +1,436 @@
 """
-Tests for command base classes.
+Tests for base command module.
+
+This module contains comprehensive tests for the base Command class
+to ensure 90%+ code coverage.
 """
 
 import pytest
+import inspect
+from unittest.mock import Mock, patch, MagicMock, AsyncMock
 from typing import Dict, Any
 
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
+from mcp_proxy_adapter.commands.result import SuccessResult, ErrorResult
+from mcp_proxy_adapter.core.errors import (
+    ValidationError, InvalidParamsError, NotFoundError, 
+    TimeoutError, CommandError, InternalError
+)
 
 
-class MockResultClass(CommandResult):
-    """Test result class for testing."""
-    
-    def __init__(self, value: str):
-        self.value = value
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {"value": self.value}
+class MockResultClass:
+    """Mock result class for testing."""
+    def to_dict(self):
+        return {"status": "success", "data": "test_data"}
     
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "value": {"type": "string"}
-            },
-            "required": ["value"]
-        }
+    def get_schema(cls):
+        return {"type": "object", "properties": {"data": {"type": "string"}}}
 
 
 class TestCommand(Command):
-    """Test command for testing."""
-    
+    """Test command class for testing."""
     name = "test_command"
     result_class = MockResultClass
     
-    async def execute(self, value: str = "default") -> MockResultClass:
-        return MockResultClass(value)
-    
-    @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "value": {"type": "string"}
-            },
-            "additionalProperties": False
-        }
+    async def execute(self, **kwargs):
+        return SuccessResult(data=kwargs)
 
 
-@pytest.mark.unit
 def test_success_result():
-    """Test success result class."""
-    result = SuccessResult(data={"key": "value"}, message="success message")
-    
-    # Test to_dict method
+    """Test success result creation."""
+    result = SuccessResult(data="test_data")
+    assert result.data == "test_data"
     result_dict = result.to_dict()
     assert result_dict["success"] is True
-    assert result_dict["data"] == {"key": "value"}
-    assert result_dict["message"] == "success message"
-    
-    # Test from_dict method
-    result2 = SuccessResult.from_dict(result_dict)
-    assert result2.data == {"key": "value"}
-    assert result2.message == "success message"
 
 
-@pytest.mark.unit
 def test_error_result():
-    """Test error result class."""
-    result = ErrorResult(message="error message", code=400, details={"field": "invalid"})
-    
-    # Test to_dict method
-    result_dict = result.to_dict()
-    assert result_dict["success"] is False
-    assert result_dict["error"]["code"] == 400
-    assert result_dict["error"]["message"] == "error message"
-    assert result_dict["error"]["data"] == {"field": "invalid"}
-    
-    # Test from_dict method
-    result2 = ErrorResult.from_dict(result_dict)
-    assert result2.message == "error message"
-    assert result2.code == 400
-    assert result2.details == {"field": "invalid"}
+    """Test error result creation."""
+    result = ErrorResult(message="Test error", code=400)
+    assert result.message == "Test error"
+    assert result.code == 400
 
 
 class TestCommandClass:
-    """Test command class."""
-    
-    @pytest.mark.unit
+    """Test cases for Command class."""
+
     @pytest.mark.asyncio
     async def test_execute(self):
         """Test execute method."""
         command = TestCommand()
-        result = await command.execute(value="test_value")
-        assert isinstance(result, MockResultClass)
-        assert result.value == "test_value"
-    
-    @pytest.mark.unit
+        result = await command.execute(test_param="value")
+        assert isinstance(result, SuccessResult)
+
     @pytest.mark.asyncio
     async def test_run(self):
         """Test run method (with validation)."""
-        result = await TestCommand.run(value="test_value")
-        assert isinstance(result, MockResultClass)
-        assert result.value == "test_value"
-    
-    @pytest.mark.unit
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            # Mock the command execution to avoid registry lookup
+            with patch.object(TestCommand, 'execute', return_value=SuccessResult(data={"value": "test_value"})):
+                result = await TestCommand.run(value="test_value")
+                assert isinstance(result, SuccessResult)
+                assert result.data == {"value": "test_value"}
+
     def test_get_schema(self):
         """Test get_schema method."""
         schema = TestCommand.get_schema()
         assert schema["type"] == "object"
-        assert "value" in schema["properties"]
-        assert schema["additionalProperties"] is False
-    
-    @pytest.mark.unit
+        assert "properties" in schema
+
     def test_get_result_schema(self):
         """Test get_result_schema method."""
         schema = TestCommand.get_result_schema()
         assert schema["type"] == "object"
-        assert "value" in schema["properties"]
-        assert "value" in schema["required"]
-    
-    @pytest.mark.unit
+        assert "properties" in schema
+
     def test_get_param_info(self):
         """Test get_param_info method."""
-        params = TestCommand.get_param_info()
-        assert "value" in params
-        assert params["value"]["required"] is False
-        assert params["value"]["default"] == "default" 
+        param_info = TestCommand.get_param_info()
+        assert isinstance(param_info, dict)
+
+    def test_validate_params_none(self):
+        """Test validate_params with None."""
+        params = TestCommand.validate_params(None)
+        assert params == {}
+
+    def test_validate_params_empty_dict(self):
+        """Test validate_params with empty dict."""
+        params = TestCommand.validate_params({})
+        assert params == {}
+
+    def test_validate_params_with_none_values(self):
+        """Test validate_params with None values."""
+        params = TestCommand.validate_params({"param1": None, "param2": "value"})
+        assert "param1" not in params
+        assert params["param2"] == "value"
+
+    def test_validate_params_with_empty_strings(self):
+        """Test validate_params with empty strings."""
+        params = TestCommand.validate_params({"param1": "", "param2": "null", "param3": "value"})
+        assert "param1" not in params
+        assert "param2" not in params
+        assert params["param3"] == "value"
+
+    def test_validate_params_with_cmdname_none(self):
+        """Test validate_params with cmdname parameter."""
+        params = TestCommand.validate_params({"cmdname": None, "other": "value"})
+        assert params["cmdname"] is None
+        assert params["other"] == "value"
+
+    def test_validate_params_copy_input(self):
+        """Test that validate_params doesn't modify input."""
+        input_params = {"param1": "value1", "param2": None}
+        result = TestCommand.validate_params(input_params)
+        assert input_params == {"param1": "value1", "param2": None}  # Input unchanged
+        assert "param2" not in result  # Result filtered
+
+    @pytest.mark.asyncio
+    async def test_run_with_hooks_skip_processing(self):
+        """Test run method when hooks skip standard processing."""
+        with patch('mcp_proxy_adapter.commands.base.hooks') as mock_hooks:
+            mock_hooks.execute_before_hooks.return_value = Mock(standard_processing=False)
+            
+            result = await TestCommand.run(test_param="value")
+            assert isinstance(result, SuccessResult)
+            assert result.data == {"test_param": "value"}
+
+    @pytest.mark.asyncio
+    async def test_run_command_not_found(self):
+        """Test run method when command not found."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = None
+            
+            result = await TestCommand.run(test_param="value")
+            assert isinstance(result, ErrorResult)
+            assert "not found" in result.message
+
+    @pytest.mark.asyncio
+    async def test_run_with_registry_instance(self):
+        """Test run method with existing registry instance."""
+        mock_command = Mock()
+        mock_command.execute = AsyncMock(return_value=SuccessResult(data="test"))
+        
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = True
+            mock_registry.get_command_instance.return_value = mock_command
+            
+            result = await TestCommand.run(test_param="value")
+            assert isinstance(result, SuccessResult)
+
+    @pytest.mark.asyncio
+    async def test_run_validation_error(self):
+        """Test run method with validation error."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            # Mock TestCommand to raise ValidationError
+            with patch.object(TestCommand, 'execute', side_effect=ValidationError("Invalid params")):
+                result = await TestCommand.run(test_param="value")
+                assert isinstance(result, ErrorResult)
+                assert "Invalid params" in result.message
+
+    @pytest.mark.asyncio
+    async def test_run_invalid_params_error(self):
+        """Test run method with invalid params error."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            with patch.object(TestCommand, 'execute', side_effect=InvalidParamsError("Invalid params")):
+                result = await TestCommand.run(test_param="value")
+                assert isinstance(result, ErrorResult)
+                assert "Invalid params" in result.message
+
+    @pytest.mark.asyncio
+    async def test_run_not_found_error(self):
+        """Test run method with not found error."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            with patch.object(TestCommand, 'execute', side_effect=NotFoundError("Not found")):
+                result = await TestCommand.run(test_param="value")
+                assert isinstance(result, ErrorResult)
+                assert "Not found" in result.message
+
+    @pytest.mark.asyncio
+    async def test_run_timeout_error(self):
+        """Test run method with timeout error."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            with patch.object(TestCommand, 'execute', side_effect=TimeoutError("Timeout")):
+                result = await TestCommand.run(test_param="value")
+                assert isinstance(result, ErrorResult)
+                assert "Timeout" in result.message
+
+    @pytest.mark.asyncio
+    async def test_run_command_error(self):
+        """Test run method with command error."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            with patch.object(TestCommand, 'execute', side_effect=CommandError("Command error")):
+                result = await TestCommand.run(test_param="value")
+                assert isinstance(result, ErrorResult)
+                assert "Command error" in result.message
+
+    @pytest.mark.asyncio
+    async def test_run_unexpected_exception(self):
+        """Test run method with unexpected exception."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            with patch.object(TestCommand, 'execute', side_effect=Exception("Unexpected error")):
+                result = await TestCommand.run(test_param="value")
+                assert isinstance(result, ErrorResult)
+                assert "Command execution error" in result.message
+
+    @pytest.mark.asyncio
+    async def test_run_with_none_kwargs(self):
+        """Test run method with None kwargs."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            result = await TestCommand.run()
+            assert isinstance(result, SuccessResult)
+
+    def test_get_metadata(self):
+        """Test get_metadata method."""
+        metadata = TestCommand.get_metadata()
+        assert isinstance(metadata, dict)
+        assert "name" in metadata
+        assert "summary" in metadata
+        assert "params" in metadata
+
+    def test_get_metadata_with_schema(self):
+        """Test get_metadata method with schema."""
+        with patch.object(TestCommand, 'get_param_info') as mock_param_info:
+            mock_param_info.return_value = {
+                "param1": {"type": "string", "description": "Test param"}
+            }
+            
+            metadata = TestCommand.get_metadata()
+            assert "params" in metadata
+            assert "param1" in metadata["params"]
+
+    def test_generate_examples(self):
+        """Test _generate_examples method."""
+        params = {
+            "param1": {"type": "string", "description": "Test param"}
+        }
+        
+        examples = TestCommand._generate_examples(params)
+        assert isinstance(examples, list)
+        assert len(examples) > 0
+
+    def test_generate_examples_empty_params(self):
+        """Test _generate_examples with empty params."""
+        examples = TestCommand._generate_examples({})
+        assert isinstance(examples, list)
+
+    def test_get_param_info_with_annotations(self):
+        """Test get_param_info with type annotations."""
+        class AnnotatedCommand(Command):
+            name = "annotated_command"
+            result_class = MockResultClass
+            
+            async def execute(self, param1: str, param2: int = 42):
+                return SuccessResult(data={"param1": param1, "param2": param2})
+        
+        param_info = AnnotatedCommand.get_param_info()
+        assert "param1" in param_info
+        assert "param2" in param_info
+        assert param_info["param1"]["required"] is True
+        assert param_info["param2"]["required"] is False
+
+    def test_get_param_info_without_annotations(self):
+        """Test get_param_info without type annotations."""
+        class NoAnnotationCommand(Command):
+            name = "no_annotation_command"
+            result_class = MockResultClass
+            
+            async def execute(self, param1, param2=42):
+                return SuccessResult(data={"param1": param1, "param2": param2})
+        
+        param_info = NoAnnotationCommand.get_param_info()
+        assert "param1" in param_info
+        assert "param2" in param_info
+        assert param_info["param1"]["required"] is True
+        assert param_info["param2"]["required"] is False
+
+    def test_get_result_schema_with_result_class(self):
+        """Test get_result_schema with result class."""
+        class MockResultClassWithSchema:
+            @classmethod
+            def get_schema(cls):
+                return {"type": "object", "properties": {"data": {"type": "string"}}}
+        
+        class CommandWithResultClass(Command):
+            name = "command_with_result"
+            result_class = MockResultClassWithSchema
+            
+            async def execute(self, **kwargs):
+                return SuccessResult(data="test")
+        
+        schema = CommandWithResultClass.get_result_schema()
+        assert schema["type"] == "object"
+        assert "properties" in schema
+
+    def test_get_result_schema_without_result_class(self):
+        """Test get_result_schema without result class."""
+        class CommandWithoutResultClass(Command):
+            name = "command_without_result"
+            
+            async def execute(self, **kwargs):
+                return SuccessResult(data="test")
+        
+        schema = CommandWithoutResultClass.get_result_schema()
+        assert schema == {}
+
+    def test_command_name_generation(self):
+        """Test command name generation from class name."""
+        class TestCommandName(Command):
+            result_class = MockResultClass
+            
+            async def execute(self, **kwargs):
+                return SuccessResult(data="test")
+        
+        # Test that name is generated from class name
+        # The name will be generated dynamically in the run method
+        # So we test that the class can be instantiated
+        command = TestCommandName()
+        assert command is not None
+
+    def test_command_name_override(self):
+        """Test command name override."""
+        class CustomNamedCommand(Command):
+            name = "custom_name"
+            result_class = MockResultClass
+            
+            async def execute(self, **kwargs):
+                return SuccessResult(data="test")
+        
+        assert CustomNamedCommand.name == "custom_name"
+
+
+class TestCommandEdgeCases:
+    """Test edge cases for Command class."""
+
+    def test_validate_params_with_various_none_values(self):
+        """Test validate_params with various None-like values."""
+        params = {
+            "null_str": "null",
+            "none_str": "none",
+            "empty_str": "",
+            "real_none": None,
+            "valid_value": "test"
+        }
+        
+        result = TestCommand.validate_params(params)
+        assert "null_str" not in result
+        assert "none_str" not in result
+        assert "empty_str" not in result
+        assert "real_none" not in result
+        assert result["valid_value"] == "test"
+
+    def test_validate_params_case_insensitive(self):
+        """Test validate_params case insensitive handling."""
+        params = {
+            "null_upper": "NULL",
+            "none_upper": "NONE",
+            "valid_value": "test"
+        }
+        
+        result = TestCommand.validate_params(params)
+        assert "null_upper" not in result
+        assert "none_upper" not in result
+        assert result["valid_value"] == "test"
+
+    @pytest.mark.asyncio
+    async def test_run_with_complex_hook_context(self):
+        """Test run method with complex hook context."""
+        mock_hook_context = Mock()
+        mock_hook_context.standard_processing = False
+        
+        with patch('mcp_proxy_adapter.commands.base.hooks') as mock_hooks:
+            mock_hooks.execute_before_hooks.return_value = mock_hook_context
+            
+            result = await TestCommand.run(complex_param={"nested": "value"})
+            assert isinstance(result, SuccessResult)
+
+    @pytest.mark.asyncio
+    async def test_run_with_after_hooks(self):
+        """Test run method with after hooks execution."""
+        with patch('mcp_proxy_adapter.commands.base.registry', create=True) as mock_registry:
+            mock_registry.get_priority_command.return_value = TestCommand
+            mock_registry.has_instance.return_value = False
+            
+            with patch('mcp_proxy_adapter.commands.base.hooks') as mock_hooks:
+                mock_hooks.execute_before_hooks.return_value = Mock(standard_processing=True)
+                
+                result = await TestCommand.run(test_param="value")
+                
+                # Verify after hooks were called
+                mock_hooks.execute_after_hooks.assert_called_once()
+
+    def test_get_metadata_with_examples(self):
+        """Test get_metadata method with examples generation."""
+        with patch.object(TestCommand, 'get_param_info') as mock_param_info:
+            mock_param_info.return_value = {
+                "param1": {"type": "string", "description": "Test param"}
+            }
+            
+            metadata = TestCommand.get_metadata()
+            assert "examples" in metadata
+            assert isinstance(metadata["examples"], list) 

mcp_proxy_adapter/version.py

@@ -1,3 +1,3 @@
 """Version information for MCP Microservice."""
 
-__version__ = "3.1.6" 
+__version__ = "4.1.0" 

{mcp_proxy_adapter-3.1.6.dist-info → mcp_proxy_adapter-4.1.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 3.1.6
+Version: 4.1.0
 Summary: Reliable microservice with unified JSON-RPC endpoint
-Home-page: https://github.com/yourusername/mcp-proxy-adapter
-Author: MCP Team
+Home-page: https://github.com/maverikod/mcp-proxy-adapter
+Author: Vasiliy Zdanovskiy
 Author-email: Vasiliy Zubarev <vasiliy.zubarev@example.com>
 License: MIT License
         

mcp_proxy_adapter-4.1.0.dist-info/RECORD

@@ -0,0 +1,110 @@
+mcp_proxy_adapter/__init__.py,sha256=B7m1YWyv_Wb87-Q-JqVpHQgwajnfIgDyZ_iIxzdTbBY,1021
+mcp_proxy_adapter/config.py,sha256=FS-Zwg8F5lfb0WqaXRrVlPLgjHEvPCV5MtTmE6Qj0Cw,6447
+mcp_proxy_adapter/custom_openapi.py,sha256=1A7y8r65WfZSqhhzhJyEIpwqwV-qbTXzRrRX04amluk,14472
+mcp_proxy_adapter/openapi.py,sha256=36vOEbJjGnVZR6hUhl6mHCD29HYOEFKo2bL0JdGSm-4,13952
+mcp_proxy_adapter/version.py,sha256=92OLC5449Zo3k37tGhA1bpS09AYJa0q_UnsvNKmL3gg,71
+mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_proxy_adapter/api/app.py,sha256=Haj0ogy70KRMyAAwU2PQhQFPf28On9ynnUX2FPk0l94,16602
+mcp_proxy_adapter/api/handlers.py,sha256=LqPMRMGYtepoZUoJiKjjycRE2fJxsE545osoEsgHKQg,7208
+mcp_proxy_adapter/api/schemas.py,sha256=xOmiSwHaapY6myEFnLu7o-LWVPM7vwmLYZXFo2c6NfE,12381
+mcp_proxy_adapter/api/tool_integration.py,sha256=MrtX7vUXCGBBuZuOs3C6EF67R_U_0xMfOmlmsAz-wuE,10245
+mcp_proxy_adapter/api/tools.py,sha256=rRCRN2I8Odd2biBJZKByQS15rAWf0XwLRZEHDELc7Tg,8116
+mcp_proxy_adapter/api/middleware/__init__.py,sha256=RpaA5hbZ7XIjKaQK0PJpZNqc9tFISe5w7ZmqNgwC6FE,1556
+mcp_proxy_adapter/api/middleware/auth.py,sha256=bic-ez4o4xh74ZczLXSNafrk_m2qk82GF9MHmfDpf9w,4891
+mcp_proxy_adapter/api/middleware/base.py,sha256=aMV9YPLHkUnJECuQWYbnlEGaj6xUJFHZR_hJb0OKvu8,2282
+mcp_proxy_adapter/api/middleware/error_handling.py,sha256=0ZXsDN8Rjt0_tVOXXC1HB14TINrz8GKicillsl3fUg8,6940
+mcp_proxy_adapter/api/middleware/logging.py,sha256=wGtw4BqKMLgn5zqYd84DnVPtO3evfx2X-TxOCyAmysM,3679
+mcp_proxy_adapter/api/middleware/performance.py,sha256=dHBxTF43LEGXMKHMH3A8ybKmwAWURd_zswqq_oC4xbw,2454
+mcp_proxy_adapter/api/middleware/rate_limit.py,sha256=DIv_-ZUVmL-jEo_A5BlfnasZf25zT84AiIJDUUnXkpM,5041
+mcp_proxy_adapter/commands/__init__.py,sha256=bHZZcVYkXVL9g-YZOnWkHOxSP2WzT-I4_OleYycQhbw,610
+mcp_proxy_adapter/commands/base.py,sha256=-OwzKXVwt9Ov4BLmHE6CAu9966__RgMOl1bkstlWCuE,14719
+mcp_proxy_adapter/commands/command_registry.py,sha256=zErrZvJFYA0amJ9ruo5W09QY2JJSlj5ezlkesR4xfCo,20494
+mcp_proxy_adapter/commands/config_command.py,sha256=-Z6BGaEQTf859l56zZpHYBeZFeIVdpMYybDrd7LOPIg,3553
+mcp_proxy_adapter/commands/dependency_container.py,sha256=Uz9OPRAUZN7tsVrMVgXgPQcsRD2N-e2Ixg9XarPOlnY,3410
+mcp_proxy_adapter/commands/health_command.py,sha256=_tzxHwB_8vo53VBC6HnBv5fSfZL1pEuwlbrCcy_K78c,4087
+mcp_proxy_adapter/commands/help_command.py,sha256=dfqNt1h2H6vQJ9rLySWa_-0-QzesnN-Mgx0cz-uFlIo,13051
+mcp_proxy_adapter/commands/hooks.py,sha256=22i3bx1zk06B88rfoD6n8N-ITq3NU2AFXs1rBmFgUC8,9305
+mcp_proxy_adapter/commands/reload_command.py,sha256=Qs_9RYqzYecmGiYSez-zW6z7kBNlF6cNZEKKH0F7noA,7664
+mcp_proxy_adapter/commands/reload_settings_command.py,sha256=kLd5ICCa0S21K2_5ewRSKGNtrCZCVrbKiufzA-zGXlY,4100
+mcp_proxy_adapter/commands/result.py,sha256=2WjftiAuhlyzOKmPJlQHo_b08ZCzWoK7cquUHFLVE-E,5534
+mcp_proxy_adapter/commands/settings_command.py,sha256=hTBrFRABJDFYwnDf2ryfqoejUe06fM4XMOoiH0Exdyo,6407
+mcp_proxy_adapter/core/__init__.py,sha256=Ch50cV5Nd8m-HO9rMnVModajjwDK-OdUy7hxISDFkAM,800
+mcp_proxy_adapter/core/errors.py,sha256=s34OxiIR4NCJu_pYSigKXqrIvRjUUK2OWw0X4dpDjIA,5151
+mcp_proxy_adapter/core/logging.py,sha256=ReRFeRN0OZxFpT-OzQdiigE_hOXt5kbyrkRFKu55HVc,8957
+mcp_proxy_adapter/core/settings.py,sha256=XJmBrNrzB9EgseVkYGURAWZGL_Ka7iBBRj9Jdzp8PDE,10551
+mcp_proxy_adapter/core/utils.py,sha256=ly8Ttg2v1OBukThJLxudRvmttU1hxJFLJUfat4b2dOI,3268
+mcp_proxy_adapter/examples/README.md,sha256=rAaBDPCuat7RWaeoCFSR4X92XPn0OmD2QQaYBAT-rz4,3342
+mcp_proxy_adapter/examples/__init__.py,sha256=Y0Q3rsoHZTIJS0gHbcE3W-htBkUkeYFSZG7sAfowMUI,147
+mcp_proxy_adapter/examples/basic_server/README.md,sha256=E5dzfz3X6tPtLpNOOmbmZ2F6do_R9xy9wDI66KjlooY,1223
+mcp_proxy_adapter/examples/basic_server/__init__.py,sha256=63tFue2XfrlkNpIMC3foQxGOYooZiIHJkKFlmSjqgPw,128
+mcp_proxy_adapter/examples/basic_server/basic_custom_settings.json,sha256=OQGAT2TUERhnznpOV0IsUix5JM-am7VCEvG97BWUxos,1003
+mcp_proxy_adapter/examples/basic_server/config.json,sha256=wz0niZ2Q8zr1XPeNZBGsAXOZgciYnEn3XDW5FrOEqzQ,929
+mcp_proxy_adapter/examples/basic_server/custom_settings_example.py,sha256=9VM7_D5OzSZ-eezH17gthsLo3DvklOtzkx-3QM9j8RU,8218
+mcp_proxy_adapter/examples/basic_server/server.py,sha256=U6X9m7zCAlwMztFft5wfu6MdaLt2dppkyFlcUa_7BDc,3424
+mcp_proxy_adapter/examples/custom_commands/README.md,sha256=nkrZ-mbz0AfnYUVb57hPsO4jUadWvDaUTWkIDUwY0VY,3881
+mcp_proxy_adapter/examples/custom_commands/__init__.py,sha256=vqAm7c4crDMupwh0hAGPC8XE2inu0o-tAG5GHW04ZkE,684
+mcp_proxy_adapter/examples/custom_commands/advanced_hooks.py,sha256=MCL7OkkrOMc8zEt9qlZ_dV9YIGnB_fe4Ge6mjVq6qPE,9516
+mcp_proxy_adapter/examples/custom_commands/config.json,sha256=4CZ01rT5d9QX4zUzEAQvHzin4LQheHxgtk6Wph5bnp4,1750
+mcp_proxy_adapter/examples/custom_commands/custom_health_command.py,sha256=V7qqFRgFQAxriEnUtkJ_sHjIOCjGjeqgsHjcfZrd26w,5473
+mcp_proxy_adapter/examples/custom_commands/custom_help_command.py,sha256=3HPj4peKcwbwSfXW2ATQ4vFGvbsXLxfZXfxjjPYiowU,7486
+mcp_proxy_adapter/examples/custom_commands/custom_openapi_generator.py,sha256=txm6oC8jP-nOHNgWlB2B0_YIYf2YQFSqLYpObNyDDq4,2408
+mcp_proxy_adapter/examples/custom_commands/custom_settings.json,sha256=-5RQlIZzTIZLb8-OqIDc-2kEred2tbJncZBLHYHTvZA,2413
+mcp_proxy_adapter/examples/custom_commands/custom_settings_manager.py,sha256=JDkxfnxSDg2mASEKq4LTjpyT-QhVlCCY51YicTqP4Y8,9290
+mcp_proxy_adapter/examples/custom_commands/data_transform_command.py,sha256=Pi8noxGMbvj5rPqE-Yf-MFiN2g3LQZwuS9GgISY1588,4400
+mcp_proxy_adapter/examples/custom_commands/echo_command.py,sha256=5cP0MQiTcpEiix7k5oBD2aHEHcYDS75nIrS23KETzd0,3394
+mcp_proxy_adapter/examples/custom_commands/hooks.py,sha256=Zfd-9T2XYJF7XMgQmEGdzWtM8Gz2EF8dn-jNJbYOgb4,7486
+mcp_proxy_adapter/examples/custom_commands/intercept_command.py,sha256=06xPpS-9kC6Lu-b6anES1ah8gLtP0sgFL4N1JkDkOrk,3716
+mcp_proxy_adapter/examples/custom_commands/manual_echo_command.py,sha256=4Bma586HU17IpuVuCuG-_rk-kycDx_oN6gKJ-q3DQr4,2787
+mcp_proxy_adapter/examples/custom_commands/server.py,sha256=WA3kh1kqWtk_tG834oHTnfgCichiAZn1xyzrLU_WJfI,9209
+mcp_proxy_adapter/examples/custom_commands/test_hooks.py,sha256=0VUwENRAAYGDYMUxXVEA_EByKiHQiqJmdkul1LvebQE,5288
+mcp_proxy_adapter/examples/custom_commands/auto_commands/__init__.py,sha256=AN5b9FNYobhDL5MWaftVy0imcAlbEuLIxwRQYX1U-_o,161
+mcp_proxy_adapter/examples/custom_commands/auto_commands/auto_echo_command.py,sha256=M0QlkCdSY9rD1b88JdZLlVMo2zU9iCnWC4DeSWCtU44,2725
+mcp_proxy_adapter/examples/custom_commands/auto_commands/auto_info_command.py,sha256=zPgPc43YLKY6xObrLAqADne6T06bs3zCsx3BCeFZa0Q,2889
+mcp_proxy_adapter/examples/deployment/README.md,sha256=5JzrIQPEw1NolHsHRKByNxbUTLj__ZYI9WQrtbxLJMk,1227
+mcp_proxy_adapter/examples/deployment/__init__.py,sha256=Nu3mrZT9kg5-GK4AUtdcnE9uSa9QdeLStBMXWrR4fHA,131
+mcp_proxy_adapter/examples/deployment/config.development.json,sha256=o-P1s0Ci3CpaoS7f4xrCej1FyumuhqJwFsnhIFFcy-I,156
+mcp_proxy_adapter/examples/deployment/config.json,sha256=xXEr378-nkWn2RVkkPt-hvkSlFy12brXO6Ntqs2sZxE,505
+mcp_proxy_adapter/examples/deployment/config.production.json,sha256=3cWz5d50_Ojx1f_Wn9C6jh5cET4hyPlpacOFckVhg54,299
+mcp_proxy_adapter/examples/deployment/config.staging.json,sha256=8maxqWfSZ3mHtjpIOCa37JQXUs2iEZacwBSc0wcvpRE,270
+mcp_proxy_adapter/examples/deployment/docker-compose.yml,sha256=jYVVsegJIXtxy9IVhj2WEyjLs7omDWXP1lUkwMCydLg,739
+mcp_proxy_adapter/examples/deployment/run.sh,sha256=tzvjztSwewtetewjFb2MUVjOym9G0rVKVDLSmLKuB-E,1352
+mcp_proxy_adapter/examples/deployment/run_docker.sh,sha256=XniKJkDproyPxsENZAa55PAO7WmzmPNqqFhZHEp2PKQ,2668
+mcp_proxy_adapter/schemas/base_schema.json,sha256=v9G9cGMd4dRhCZsOQ_FMqOi5VFyVbI6Cf3fyIvOT9dc,2881
+mcp_proxy_adapter/schemas/openapi_schema.json,sha256=C3yLkwmDsvnLW9B5gnKKdBGl4zxkeU-rEmjTrNVsQU0,8405
+mcp_proxy_adapter/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_proxy_adapter/tests/conftest.py,sha256=VBA2wLeYfp9XAGSq4c489PVBIqMGAJiQPrT0k3kyzXw,2999
+mcp_proxy_adapter/tests/test_api_endpoints.py,sha256=ePtWCf0szD1JeY9WdHAhcKnuOzoSCpUcqZ_2DVhlC-A,10280
+mcp_proxy_adapter/tests/test_api_handlers.py,sha256=LeHO0o6eCxan6mt_8ZkUwSbeY7qYfoYMJ-bT_sSgdxc,11011
+mcp_proxy_adapter/tests/test_base_command.py,sha256=nSIi_mfjux8TL--65pMBfyg91EiLjJhI2P_ASWqyW-U,3779
+mcp_proxy_adapter/tests/test_batch_requests.py,sha256=9-gvhPq48AcEwGlhwgn3DWNhpleLA0f4luZNYMrqlXY,4103
+mcp_proxy_adapter/tests/test_command_registry.py,sha256=ywi5gM7D7NHcNOkdwXOgpJqHjwGADZEaB3ueM3nR0gM,7683
+mcp_proxy_adapter/tests/test_config.py,sha256=i4YbFhB3WI1wWKCxkG6l-UpFv2LAbhh4hmGipmYG1d0,3928
+mcp_proxy_adapter/tests/test_utils.py,sha256=K8DqdWDAV-cXjjeykehHpG5phfq5ydu2HLJzaAL282Y,1653
+mcp_proxy_adapter/tests/api/__init__.py,sha256=QzjeBIhrRLqfUKYmxVSCbMOoni5MAXgyAx9HxxB6JRs,27
+mcp_proxy_adapter/tests/api/test_cmd_endpoint.py,sha256=RFg_N7Ut1l_pncUPMaqVg85XV4KTpVe03yI_VA0Z47o,3843
+mcp_proxy_adapter/tests/api/test_custom_openapi.py,sha256=oSZ61G-CzrlGe7-F5OXMeNR2N2dZnKDH-npS9vumHqE,26404
+mcp_proxy_adapter/tests/api/test_handlers.py,sha256=RjO5yjUwpl9UPX45z9qSSvjU1gl9F7MHDEbnLFYL1GE,18921
+mcp_proxy_adapter/tests/api/test_middleware.py,sha256=3Rgc09VJ7JG6_06oIgAVq6u7qJsaiuhW0KpfDjxk8Ac,12285
+mcp_proxy_adapter/tests/api/test_schemas.py,sha256=QJbo-aWwhe233U9VKBWaTDudmDEkkvcOeX0hoIst1nM,19986
+mcp_proxy_adapter/tests/api/test_tool_integration.py,sha256=zCLztv4OLRKeug_VD2MwqewrhrSE52_Xzto3yOY72wY,21720
+mcp_proxy_adapter/tests/commands/__init__.py,sha256=DZxhtyr__AleyXN1s8Ef887tK5nsoHKfW4QXyzLaP0E,36
+mcp_proxy_adapter/tests/commands/test_config_command.py,sha256=ud0Y57xUhFiyrUKDyA0eBZ8IOKiGDpioijtwY-detC4,6522
+mcp_proxy_adapter/tests/commands/test_echo_command.py,sha256=c2dmqfx3ZfvDedy5vuxArFv7iHsReepMmD2Lchg4l3E,3437
+mcp_proxy_adapter/tests/commands/test_help_command.py,sha256=0kylFDGSYV-YStVCf_j7_4EF8VDaClIZbJz3V2V2-DI,4272
+mcp_proxy_adapter/tests/functional/__init__.py,sha256=muVNR6LD5o7DsDaLrbLTFsavUNcnyM608-mr-dqzgDU,59
+mcp_proxy_adapter/tests/functional/test_api.py,sha256=OaGB-WAWVyX4b0b-mCdXBNhwwYABYeBPO3IDnA3I00c,7114
+mcp_proxy_adapter/tests/integration/__init__.py,sha256=JZpeNG1PBRZ3k5zfq6NH3GyzDc1Yx1ZUgwi6eLBxs1o,60
+mcp_proxy_adapter/tests/integration/test_cmd_integration.py,sha256=BS3lA6ayveMckHcy1WJjyqR7l7WTcjmGiCYSnMjVfO0,3415
+mcp_proxy_adapter/tests/integration/test_integration.py,sha256=Rf8GTxdZOvZzrtgqWN2fp-36qUU5rpHdV9zhN1JxNw8,6619
+mcp_proxy_adapter/tests/performance/__init__.py,sha256=2kHf6g4LmYnFuV4EALXzo7Qk9vHGA9DXZFt7nORRFjM,60
+mcp_proxy_adapter/tests/performance/test_performance.py,sha256=Djrnu-SsXRrc_Prj1Aw8OoPzPUwHJds-Itk3aX6o01w,5730
+mcp_proxy_adapter/tests/stubs/__init__.py,sha256=qJ_gqvLdt68rAfLOeJpjVcLWyWdhEg6RkKheyV2yjJs,178
+mcp_proxy_adapter/tests/stubs/echo_command.py,sha256=Y7SA4IB5Lo_ncn78SDm9iRZvJSKy2pXi2nBQjIUPrvg,2620
+mcp_proxy_adapter/tests/unit/__init__.py,sha256=RS-5UoSCcLKtr2jrAaZw_NG9MquA6BZmxq-P6cTw9ok,53
+mcp_proxy_adapter/tests/unit/test_base_command.py,sha256=iCJzmfcvknS6pnzqu9TSkpgKBGoYCLWu0aQekcj1AME,18183
+mcp_proxy_adapter/tests/unit/test_config.py,sha256=SZ62LXFOv_fsV0fmSIBdHWvapEyexKrioFRQo0I4pkg,5900
+mcp_proxy_adapter-4.1.0.dist-info/licenses/LICENSE,sha256=OkApFEwdgMCt_mbvUI-eIwKMSTe38K3XnU2DT5ub-wI,1072
+mcp_proxy_adapter-4.1.0.dist-info/METADATA,sha256=VI60yNbcWG46NIhvDVcbEP2NvYZZdcCqe8oCwJNw1Do,7544
+mcp_proxy_adapter-4.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-4.1.0.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-4.1.0.dist-info/RECORD,,

{mcp_proxy_adapter-3.1.6.dist-info → mcp_proxy_adapter-4.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any