mcp-proxy-adapter 3.0.3__py3-none-any.whl → 3.1.0__py3-none-any.whl

examples/commands/echo_command_di.py

@@ -0,0 +1,152 @@
+"""
+Example command with dependency injection.
+
+This module demonstrates how to use dependency injection in commands.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from mcp_proxy_adapter.commands import Command, SuccessResult
+from mcp_proxy_adapter.commands.result import CommandResult
+
+
+class EchoCommandResult(SuccessResult):
+    """
+    Result of echo command execution.
+    """
+    
+    def __init__(self, message: str, timestamp: str, **kwargs):
+        """
+        Initializes echo command result.
+        
+        Args:
+            message: Echoed message
+            timestamp: Time of execution
+            **kwargs: Additional parameters
+        """
+        data = {"message": message, "timestamp": timestamp}
+        data.update(kwargs)
+        super().__init__(data=data, message=f"Echo response: {message}")
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for result validation.
+        
+        Returns:
+            Dictionary with JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "success": {"type": "boolean"},
+                "data": {
+                    "type": "object",
+                    "properties": {
+                        "message": {"type": "string"},
+                        "timestamp": {"type": "string", "format": "date-time"}
+                    },
+                    "required": ["message", "timestamp"]
+                },
+                "message": {"type": "string"}
+            },
+            "required": ["success", "data"]
+        }
+
+
+class TimeService:
+    """
+    Service for time-related operations.
+    
+    This is a dependency that will be injected into the EchoCommand.
+    """
+    
+    def get_current_time(self) -> str:
+        """
+        Get current time formatted as ISO string.
+        
+        Returns:
+            Current time as ISO formatted string
+        """
+        from datetime import datetime
+        return datetime.now().isoformat()
+
+
+class EchoCommand(Command):
+    """
+    Command that echoes back a message with timestamp.
+    
+    This command demonstrates how to use dependency injection in commands
+    by accepting a service dependency in the constructor.
+    """
+    
+    # Command name for JSON-RPC endpoint
+    name = "echo_di"
+    # Command result class
+    result_class = EchoCommandResult
+    
+    def __init__(self, time_service: TimeService):
+        """
+        Initialize command with dependencies.
+        
+        Args:
+            time_service: Service for getting the current time
+        """
+        self.time_service = time_service
+    
+    async def execute(self, message: str = "Hello, World!") -> CommandResult:
+        """
+        Executes echo command.
+        
+        Args:
+            message: Message to echo back
+            
+        Returns:
+            Command execution result with message and timestamp
+        """
+        timestamp = self.time_service.get_current_time()
+        return EchoCommandResult(message=message, timestamp=timestamp)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Returns JSON schema for command parameters validation.
+        
+        Returns:
+            Dictionary with JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Message to echo back"
+                }
+            },
+            "additionalProperties": False
+        }
+
+
+# Example of registering the command with dependency injection
+def register_echo_command():
+    """
+    Register echo command with dependencies.
+    
+    This function shows how to:
+    1. Create a service dependency
+    2. Create a command instance with the dependency
+    3. Register the command instance in the registry
+    """
+    from mcp_proxy_adapter.commands import registry, container
+    
+    # Create and register service in the container
+    time_service = TimeService()
+    container.register("time_service", time_service)
+    
+    # Create command with dependencies
+    echo_command = EchoCommand(time_service)
+    
+    # Register command instance
+    registry.register(echo_command)
+    
+    return echo_command 

examples/di_example/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

examples/di_example/server.py

@@ -0,0 +1,249 @@
+"""
+Example of using dependency injection in a microservice.
+
+This example demonstrates how to:
+1. Create service dependencies
+2. Configure a dependency container
+3. Register commands with dependencies
+4. Run a microservice with dependency injection
+"""
+
+import asyncio
+import logging
+import os
+from typing import Dict, List, Any
+
+import uvicorn
+from fastapi import FastAPI
+
+from mcp_proxy_adapter import create_app
+from mcp_proxy_adapter.commands import registry, container
+from examples.commands.echo_command_di import EchoCommand, TimeService
+
+
+class DatabaseService:
+    """
+    Mock database service as an example dependency.
+    """
+    
+    def __init__(self, connection_string: str):
+        """
+        Initialize database service.
+        
+        Args:
+            connection_string: Database connection string
+        """
+        self.connection_string = connection_string
+        self.is_connected = False
+        self.data = {}
+        
+    async def connect(self):
+        """Connect to the database."""
+        # Simulate connection delay
+        await asyncio.sleep(0.1)
+        self.is_connected = True
+        print(f"Connected to database: {self.connection_string}")
+        
+    async def disconnect(self):
+        """Disconnect from the database."""
+        if self.is_connected:
+            # Simulate disconnection delay
+            await asyncio.sleep(0.1)
+            self.is_connected = False
+            print("Disconnected from database")
+    
+    def get_item(self, key: str) -> Any:
+        """Get item from the database."""
+        if not self.is_connected:
+            raise RuntimeError("Not connected to database")
+        return self.data.get(key)
+    
+    def set_item(self, key: str, value: Any):
+        """Set item in the database."""
+        if not self.is_connected:
+            raise RuntimeError("Not connected to database")
+        self.data[key] = value
+
+
+class ConfigService:
+    """
+    Configuration service as an example dependency.
+    """
+    
+    def __init__(self, config_path: str = None):
+        """
+        Initialize configuration service.
+        
+        Args:
+            config_path: Path to config file (optional)
+        """
+        self.config_path = config_path
+        self.config = {
+            "app_name": "DI Example",
+            "version": "1.0.0",
+            "debug": True
+        }
+        
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value."""
+        return self.config.get(key, default)
+        
+    def set(self, key: str, value: Any):
+        """Set configuration value."""
+        self.config[key] = value
+
+
+class DataCommand(EchoCommand):
+    """
+    Command that uses multiple dependencies.
+    
+    This command demonstrates using multiple injected dependencies.
+    """
+    
+    name = "data"
+    
+    def __init__(self, time_service: TimeService, db_service: DatabaseService, config: ConfigService):
+        """
+        Initialize command with multiple dependencies.
+        
+        Args:
+            time_service: Service for time operations
+            db_service: Service for database operations
+            config: Service for configuration
+        """
+        super().__init__(time_service)
+        self.db_service = db_service
+        self.config = config
+        
+    async def execute(self, action: str = "get", key: str = "data", value: str = None) -> Any:
+        """
+        Execute data command.
+        
+        Args:
+            action: Operation to perform (get or set)
+            key: Data key
+            value: Data value (for set operation)
+            
+        Returns:
+            Command result
+        """
+        timestamp = self.time_service.get_current_time()
+        
+        if action == "get":
+            result = self.db_service.get_item(key)
+            return EchoCommand.result_class(
+                message=f"Got {key}: {result}",
+                timestamp=timestamp,
+                data=result
+            )
+        elif action == "set" and value is not None:
+            self.db_service.set_item(key, value)
+            return EchoCommand.result_class(
+                message=f"Set {key} to {value}",
+                timestamp=timestamp,
+                data={key: value}
+            )
+        else:
+            return EchoCommand.result_class(
+                message=f"Invalid action: {action}",
+                timestamp=timestamp,
+                error="invalid_action"
+            )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Returns JSON schema for command parameters."""
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["get", "set"],
+                    "description": "Action to perform on data"
+                },
+                "key": {
+                    "type": "string",
+                    "description": "Data key"
+                },
+                "value": {
+                    "type": ["string", "null"],
+                    "description": "Data value (for set action)"
+                }
+            },
+            "required": ["action", "key"]
+        }
+
+
+async def setup_services():
+    """Set up and register all services in the container."""
+    # Create services
+    time_service = TimeService()
+    db_service = DatabaseService("sqlite://:memory:")
+    config_service = ConfigService()
+    
+    # Connect to database
+    await db_service.connect()
+    
+    # Register in container
+    container.register("time_service", time_service)
+    container.register("db_service", db_service)
+    container.register("config", config_service)
+    
+    return {
+        "time_service": time_service,
+        "db_service": db_service,
+        "config": config_service
+    }
+
+
+def register_commands(services):
+    """Register commands with dependencies."""
+    # Create command instances with dependencies
+    echo_command = EchoCommand(services["time_service"])
+    data_command = DataCommand(
+        services["time_service"],
+        services["db_service"],
+        services["config"]
+    )
+    
+    # Register commands
+    registry.register(echo_command)
+    registry.register(data_command)
+
+
+async def main():
+    """Run the example server with dependency injection."""
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    
+    # Setup services
+    services = await setup_services()
+    
+    # Register commands with their dependencies
+    register_commands(services)
+    
+    # Create FastAPI app with MCP adapter
+    app = create_app()
+    
+    # Add startup and shutdown events
+    @app.on_event("shutdown")
+    async def shutdown_event():
+        # Disconnect database on shutdown
+        await services["db_service"].disconnect()
+    
+    # Run the server
+    config = uvicorn.Config(
+        app=app,
+        host="0.0.0.0",
+        port=8000,
+        log_level="info"
+    )
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

mcp_proxy_adapter/api/handlers.py

@@ -37,12 +37,15 @@ async def execute_command(command_name: str, params: Dict[str, Any], request_id:
     log = RequestLogger(__name__, request_id) if request_id else logger
     
     try:
-        # Get command class from registry
-        command_class = registry.get_command(command_name)
+        log.info(f"Executing command: {command_name}")
         
-        # Execute command
+        # Get command class from registry and execute with parameters
         start_time = time.time()
+        
+        # Use Command.run that handles instances with dependencies properly
+        command_class = registry.get_command(command_name)
         result = await command_class.run(**params)
+        
         execution_time = time.time() - start_time
         
         log.info(f"Command '{command_name}' executed in {execution_time:.3f} sec")

mcp_proxy_adapter/commands/__init__.py

@@ -1,10 +1,11 @@
 """
-Package with command implementation.
+Commands module initialization file.
 """
 
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
 from mcp_proxy_adapter.commands.command_registry import registry, CommandRegistry
+from mcp_proxy_adapter.commands.dependency_container import container, DependencyContainer
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
 
 # Automatically discover and register commands
 registry.discover_commands()
@@ -12,8 +13,10 @@ registry.discover_commands()
 __all__ = [
     "Command",
     "CommandResult",
-    "SuccessResult", 
+    "SuccessResult",
     "ErrorResult",
     "registry",
-    "CommandRegistry"
+    "CommandRegistry",
+    "container",
+    "DependencyContainer"
 ]

mcp_proxy_adapter/commands/base.py

@@ -100,14 +100,29 @@ class Command(ABC):
         try:
             logger.debug(f"Running command {cls.__name__} with params: {kwargs}")
             
+            # Import registry here to avoid circular imports
+            from mcp_proxy_adapter.commands.command_registry import registry
+            
+            # Get command name
+            if not hasattr(cls, "name") or not cls.name:
+                command_name = cls.__name__.lower()
+                if command_name.endswith("command"):
+                    command_name = command_name[:-7]
+            else:
+                command_name = cls.name
+                
             # Parameters validation
             validated_params = cls.validate_params(kwargs)
             
-            # Create command instance
-            command = cls()
-            
-            # Execute command
-            result = await command.execute(**validated_params)
+            # Check if we have a registered instance for this command
+            if registry.has_instance(command_name):
+                # Use existing instance with dependencies
+                command = registry.get_command_instance(command_name)
+                result = await command.execute(**validated_params)
+            else:
+                # Create new instance for commands without dependencies
+                command = cls()
+                result = await command.execute(**validated_params)
             
             logger.debug(f"Command {cls.__name__} executed successfully")
             return result
@@ -248,53 +263,81 @@ class Command(ABC):
         # Example with all required parameters
         required_params = {k: v for k, v in params.items() if v.get("required", False)}
         if required_params:
-            example_params = {}
+            sample_params = {}
             for param_name, param_info in required_params.items():
-                # Generate suitable example value based on parameter type
+                # Try to generate sample value based on type
                 param_type = param_info.get("type", "")
-                if "str" in param_type.lower():
-                    example_params[param_name] = f"example_{param_name}"
-                elif "int" in param_type.lower():
-                    example_params[param_name] = 123
-                elif "float" in param_type.lower():
-                    example_params[param_name] = 123.45
-                elif "bool" in param_type.lower():
-                    example_params[param_name] = True
+                
+                if "str" in param_type:
+                    sample_params[param_name] = f"sample_{param_name}"
+                elif "int" in param_type:
+                    sample_params[param_name] = 1
+                elif "float" in param_type:
+                    sample_params[param_name] = 1.0
+                elif "bool" in param_type:
+                    sample_params[param_name] = True
+                elif "list" in param_type or "List" in param_type:
+                    sample_params[param_name] = []
+                elif "dict" in param_type or "Dict" in param_type:
+                    sample_params[param_name] = {}
                 else:
-                    example_params[param_name] = f"value_for_{param_name}"
+                    sample_params[param_name] = "..."
             
             examples.append({
                 "command": cls.name,
-                "params": example_params,
+                "params": sample_params,
                 "description": f"Call {cls.name} command with required parameters"
             })
-        
-        # Add example with all parameters, if there are optional ones
-        optional_params = {k: v for k, v in params.items() if not v.get("required", False)}
-        if optional_params and required_params:
-            full_example_params = dict(example_params) if 'example_params' in locals() else {}
             
-            for param_name, param_info in optional_params.items():
-                # Get default value or generate suitable example
-                if "default" in param_info:
-                    full_example_params[param_name] = param_info["default"]
-                else:
-                    # Generate suitable example value based on parameter type
+        # Example with all parameters (including optional ones)
+        if len(params) > len(required_params):
+            all_params = {}
+            for param_name, param_info in params.items():
+                # For required parameters, use the same values as above
+                if param_info.get("required", False):
+                    # Try to generate sample value based on type
                     param_type = param_info.get("type", "")
-                    if "str" in param_type.lower():
-                        full_example_params[param_name] = f"optional_{param_name}"
-                    elif "int" in param_type.lower():
-                        full_example_params[param_name] = 456
-                    elif "float" in param_type.lower():
-                        full_example_params[param_name] = 45.67
-                    elif "bool" in param_type.lower():
-                        full_example_params[param_name] = False
+                    
+                    if "str" in param_type:
+                        all_params[param_name] = f"sample_{param_name}"
+                    elif "int" in param_type:
+                        all_params[param_name] = 1
+                    elif "float" in param_type:
+                        all_params[param_name] = 1.0
+                    elif "bool" in param_type:
+                        all_params[param_name] = True
+                    elif "list" in param_type or "List" in param_type:
+                        all_params[param_name] = []
+                    elif "dict" in param_type or "Dict" in param_type:
+                        all_params[param_name] = {}
+                    else:
+                        all_params[param_name] = "..."
+                # For optional parameters, use their default values or a sample value
+                else:
+                    if "default" in param_info:
+                        all_params[param_name] = param_info["default"]
                     else:
-                        full_example_params[param_name] = f"optional_value_for_{param_name}"
+                        # Generate based on type
+                        param_type = param_info.get("type", "")
+                        
+                        if "str" in param_type:
+                            all_params[param_name] = f"optional_{param_name}"
+                        elif "int" in param_type:
+                            all_params[param_name] = 42
+                        elif "float" in param_type:
+                            all_params[param_name] = 3.14
+                        elif "bool" in param_type:
+                            all_params[param_name] = False
+                        elif "list" in param_type or "List" in param_type:
+                            all_params[param_name] = ["sample"]
+                        elif "dict" in param_type or "Dict" in param_type:
+                            all_params[param_name] = {"key": "value"}
+                        else:
+                            all_params[param_name] = "sample_value"
             
             examples.append({
                 "command": cls.name,
-                "params": full_example_params,
+                "params": all_params,
                 "description": f"Call {cls.name} command with all parameters"
             })
         

mcp_proxy_adapter/commands/command_registry.py

@@ -6,7 +6,7 @@ import importlib
 import inspect
 import os
 import pkgutil
-from typing import Any, Dict, List, Optional, Type, TypeVar, cast
+from typing import Any, Dict, List, Optional, Type, TypeVar, Union, cast
 
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.core.errors import NotFoundError
@@ -25,17 +25,29 @@ class CommandRegistry:
         Initialize command registry.
         """
         self._commands: Dict[str, Type[Command]] = {}
+        self._instances: Dict[str, Command] = {}
     
-    def register(self, command_class: Type[Command]) -> None:
+    def register(self, command: Union[Type[Command], Command]) -> None:
         """
-        Registers command class in the registry.
+        Registers command class or instance in the registry.
 
         Args:
-            command_class: Command class to register.
+            command: Command class or instance to register.
 
         Raises:
             ValueError: If command with the same name is already registered.
         """
+        # Determine if this is a class or an instance
+        if isinstance(command, type) and issubclass(command, Command):
+            command_class = command
+            command_instance = None
+        elif isinstance(command, Command):
+            command_class = command.__class__
+            command_instance = command
+        else:
+            raise ValueError(f"Invalid command type: {type(command)}. Expected Command class or instance.")
+            
+        # Get command name
         if not hasattr(command_class, "name") or not command_class.name:
             # Use class name if name attribute is not set
             command_name = command_class.__name__.lower()
@@ -50,6 +62,11 @@ class CommandRegistry:
             
         logger.debug(f"Registering command: {command_name}")
         self._commands[command_name] = command_class
+        
+        # Store instance if provided
+        if command_instance:
+            logger.debug(f"Storing instance for command: {command_name}")
+            self._instances[command_name] = command_instance
     
     def unregister(self, command_name: str) -> None:
         """
@@ -66,6 +83,10 @@ class CommandRegistry:
             
         logger.debug(f"Unregistering command: {command_name}")
         del self._commands[command_name]
+        
+        # Remove instance if exists
+        if command_name in self._instances:
+            del self._instances[command_name]
     
     def command_exists(self, command_name: str) -> bool:
         """
@@ -96,6 +117,47 @@ class CommandRegistry:
             raise NotFoundError(f"Command '{command_name}' not found")
             
         return self._commands[command_name]
+        
+    def get_command_instance(self, command_name: str) -> Command:
+        """
+        Gets command instance by name. If instance doesn't exist, creates new one.
+        
+        Args:
+            command_name: Command name
+            
+        Returns:
+            Command instance
+            
+        Raises:
+            NotFoundError: If command is not found
+        """
+        if command_name not in self._commands:
+            raise NotFoundError(f"Command '{command_name}' not found")
+            
+        # Return existing instance if available
+        if command_name in self._instances:
+            return self._instances[command_name]
+            
+        # Otherwise create new instance without dependencies
+        # (this will raise error if command requires dependencies)
+        try:
+            command_class = self._commands[command_name]
+            return command_class()
+        except Exception as e:
+            logger.error(f"Failed to create instance of '{command_name}': {e}")
+            raise ValueError(f"Command '{command_name}' requires dependencies but was registered as class. Register an instance instead.") from e
+    
+    def has_instance(self, command_name: str) -> bool:
+        """
+        Checks if command instance exists in registry.
+        
+        Args:
+            command_name: Command name
+            
+        Returns:
+            True if command instance exists, False otherwise
+        """
+        return command_name in self._instances
     
     def get_all_commands(self) -> Dict[str, Type[Command]]:
         """
@@ -225,6 +287,7 @@ class CommandRegistry:
         """
         logger.debug("Clearing command registry")
         self._commands.clear()
+        self._instances.clear()
 
 
 # Global command registry instance

mcp_proxy_adapter/commands/dependency_container.py

@@ -0,0 +1,110 @@
+"""
+Module for dependency injection container implementation.
+
+This module provides a container for registering and resolving dependencies
+for command instances in the microservice.
+"""
+
+from typing import Any, Dict, Optional, Type, TypeVar, cast
+
+T = TypeVar('T')
+
+
+class DependencyContainer:
+    """
+    Container for managing dependencies.
+    
+    This class provides functionality to register, resolve, and manage
+    dependencies that can be injected into command instances.
+    """
+    
+    def __init__(self):
+        """Initialize dependency container."""
+        self._dependencies: Dict[str, Any] = {}
+        self._factories: Dict[str, callable] = {}
+        self._singletons: Dict[str, Any] = {}
+    
+    def register(self, name: str, instance: Any) -> None:
+        """
+        Register a dependency instance with a given name.
+        
+        Args:
+            name: The name to register the dependency under
+            instance: The dependency instance
+        """
+        self._dependencies[name] = instance
+    
+    def register_factory(self, name: str, factory: callable) -> None:
+        """
+        Register a factory function that will be called to create the dependency.
+        
+        Args:
+            name: The name to register the factory under
+            factory: A callable that creates the dependency
+        """
+        self._factories[name] = factory
+    
+    def register_singleton(self, name: str, factory: callable) -> None:
+        """
+        Register a singleton factory that will create the instance only once.
+        
+        Args:
+            name: The name to register the singleton under
+            factory: A callable that creates the singleton instance
+        """
+        self._factories[name] = factory
+        # Mark as singleton but don't create until requested
+        self._singletons[name] = None
+    
+    def get(self, name: str) -> Any:
+        """
+        Get a dependency by name.
+        
+        Args:
+            name: The name of the dependency to get
+            
+        Returns:
+            The dependency instance
+            
+        Raises:
+            KeyError: If the dependency is not registered
+        """
+        # Check for direct instance
+        if name in self._dependencies:
+            return self._dependencies[name]
+            
+        # Check for singleton
+        if name in self._singletons:
+            # Create singleton if doesn't exist
+            if self._singletons[name] is None:
+                self._singletons[name] = self._factories[name]()
+            return self._singletons[name]
+            
+        # Check for factory
+        if name in self._factories:
+            return self._factories[name]()
+            
+        raise KeyError(f"Dependency '{name}' not registered")
+        
+    def clear(self) -> None:
+        """Clear all registered dependencies."""
+        self._dependencies.clear()
+        self._factories.clear()
+        self._singletons.clear()
+        
+    def has(self, name: str) -> bool:
+        """
+        Check if a dependency is registered.
+        
+        Args:
+            name: The name of the dependency
+            
+        Returns:
+            True if the dependency is registered, False otherwise
+        """
+        return (name in self._dependencies or 
+                name in self._factories)
+
+
+# Global dependency container instance
+container = DependencyContainer() 

mcp_proxy_adapter/tests/api/test_middleware.py

@@ -1,5 +1,7 @@
 """
 Tests for middleware components.
+
+These tests verify that middleware components work as expected.
 """
 
 import pytest
@@ -19,39 +21,38 @@ from mcp_proxy_adapter.api.middleware.auth import AuthMiddleware
 from mcp_proxy_adapter.api.middleware.rate_limit import RateLimitMiddleware
 from mcp_proxy_adapter.api.middleware.error_handling import ErrorHandlingMiddleware
 from mcp_proxy_adapter.api.middleware.performance import PerformanceMiddleware
-from mcp_proxy_adapter.core.errors import MicroserviceError, CommandError, ValidationError
+from mcp_proxy_adapter.core.errors import MicroserviceError, CommandError, ValidationError, InvalidRequestError
 
 
 # Helper functions
 @pytest.mark.asyncio
 async def test_endpoint(request):
-    """Test endpoint that returns a simple JSON response."""
-    return JSONResponse({"message": "test"})
+    """Test endpoint for middleware tests."""
+    return Response(content="Test response", media_type="text/plain")
 
 @pytest.mark.asyncio
 async def error_endpoint(request):
-    """Test endpoint that raises an error."""
-    # Используем новый формат JSON-RPC ошибки
+    """Test endpoint that raises CommandError."""
     raise CommandError("Test error")
 
 @pytest.mark.asyncio
 async def validation_error_endpoint(request):
-    """Test endpoint that raises a validation error."""
-    # Изменяем параметр details на data в соответствии с новой структурой
+    """Test endpoint that raises ValidationError."""
+    # Вместо создания pydantic-модели напрямую вызываем нашу ValidationError
     raise ValidationError("Validation error", data={"field": "error"})
 
 @pytest.mark.asyncio
 async def json_rpc_error_endpoint(request):
-    """Test endpoint that emulates JSON-RPC error handling."""
-    # Сразу возвращаем готовый JSON-RPC ответ с ошибкой
+    """Test endpoint that raises InvalidRequestError."""
+    # Возвращаем заранее сформированный JSON-RPC ответ с ошибкой
     return JSONResponse(
         status_code=400,
         content={
             "jsonrpc": "2.0",
             "error": {
-                "code": -32000,  # JSON-RPC код ошибки
-                "message": "Test error",
-                "data": {"test": "data"}
+                "code": -32000,
+                "message": "Invalid JSON-RPC request",
+                "data": {}
             },
             "id": 1
         }
@@ -59,21 +60,24 @@ async def json_rpc_error_endpoint(request):
 
 # Test applications
 def create_test_app():
-    """Create a test application with routes for testing."""
-    routes = [
-        Route("/test", test_endpoint),
-        Route("/error", error_endpoint),
-        Route("/validation", validation_error_endpoint),
-        Route("/api/jsonrpc", json_rpc_error_endpoint),
-    ]
-    return Starlette(routes=routes)
+    """Create a test app with test endpoints."""
+    app = FastAPI()
+    app.add_route("/test", test_endpoint)
+    app.add_route("/error", error_endpoint)
+    app.add_route("/validation_error", validation_error_endpoint)
+    app.add_route("/json_rpc_error", json_rpc_error_endpoint)
+    # Добавим маршрут, имитирующий документацию
+    @app.get("/docs")
+    async def docs():
+        return Response(content="API Documentation", media_type="text/plain")
+    return app
 
 
 # Tests for BaseMiddleware
 def test_base_middleware():
     """Test that base middleware works correctly."""
     # Create a middleware that overrides methods
-    class TestMiddleware(BaseMiddleware):
+    class MockMiddleware(BaseMiddleware):
         async def before_request(self, request):
             request.state.before_called = True
         
@@ -83,7 +87,7 @@ def test_base_middleware():
     
     # Create app with middleware
     app = create_test_app()
-    app.add_middleware(TestMiddleware)
+    app.add_middleware(MockMiddleware)
     
     # Test
     client = TestClient(app)
@@ -176,7 +180,7 @@ def test_auth_middleware_public_path():
     response = client.get("/docs")  # Public path
     
     # Verify
-    assert response.status_code == 404  # 404 because path doesn't exist, but auth should pass
+    assert response.status_code == 200  # Путь существует и должен быть доступен
 
 
 def test_auth_middleware_disabled():
@@ -270,7 +274,7 @@ def test_error_handling_middleware_validation_error():
     
     # Test
     client = TestClient(app)
-    response = client.get("/validation")
+    response = client.get("/validation_error")
     
     # Verify
     assert response.status_code == 400
@@ -292,15 +296,15 @@ def test_error_handling_middleware_jsonrpc_error():
     client = TestClient(app)
     
     # Выполняем запрос к JSON-RPC эндпоинту
-    response = client.get("/api/jsonrpc")
+    response = client.get("/json_rpc_error")
     
     # Verify
     assert response.status_code == 400
     assert response.json()["jsonrpc"] == "2.0"
     assert "error" in response.json()
     assert response.json()["error"]["code"] == -32000  # Обновленный код JSON-RPC
-    assert response.json()["error"]["message"] == "Test error"
-    assert response.json()["error"]["data"] == {"test": "data"}  # data вместо details
+    assert response.json()["error"]["message"] == "Invalid JSON-RPC request"
+    assert response.json()["error"]["data"] == {}  # data вместо details
     assert response.json()["id"] == 1
 
 

mcp_proxy_adapter/tests/test_base_command.py

@@ -29,7 +29,7 @@ class MockResultClass(CommandResult):
         }
 
 
-class TestCommand(Command):
+class MockCommand(Command):
     """Test command for testing."""
     
     name = "test_command"
@@ -83,13 +83,13 @@ def test_error_result():
     assert result2.details == {"field": "invalid"}
 
 
-class TestCommandClass:
+class CommandClassTests:
     """Test command class."""
     
     @pytest.mark.asyncio
     async def test_execute(self):
         """Test execute method."""
-        command = TestCommand()
+        command = MockCommand()
         result = await command.execute(value="test_value")
         assert isinstance(result, MockResultClass)
         assert result.value == "test_value"
@@ -97,27 +97,27 @@ class TestCommandClass:
     @pytest.mark.asyncio
     async def test_run(self):
         """Test run method (with validation)."""
-        result = await TestCommand.run(value="test_value")
+        result = await MockCommand.run(value="test_value")
         assert isinstance(result, MockResultClass)
         assert result.value == "test_value"
     
     def test_get_schema(self):
         """Test get_schema method."""
-        schema = TestCommand.get_schema()
+        schema = MockCommand.get_schema()
         assert schema["type"] == "object"
         assert "value" in schema["properties"]
         assert schema["additionalProperties"] is False
     
     def test_get_result_schema(self):
         """Test get_result_schema method."""
-        schema = TestCommand.get_result_schema()
+        schema = MockCommand.get_result_schema()
         assert schema["type"] == "object"
         assert "value" in schema["properties"]
         assert "value" in schema["required"]
     
     def test_get_param_info(self):
         """Test get_param_info method."""
-        params = TestCommand.get_param_info()
+        params = MockCommand.get_param_info()
         assert "value" in params
         assert params["value"]["required"] is False
         assert params["value"]["default"] == "default" 

mcp_proxy_adapter/version.py

@@ -1,3 +1,3 @@
 """Version information for MCP Microservice."""
 
-__version__ = "3.0.3" 
+__version__ = "3.1.0" 

{mcp_proxy_adapter-3.0.3.dist-info → mcp_proxy_adapter-3.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 3.0.3
+Version: 3.1.0
 Summary: Reliable microservice with unified JSON-RPC endpoint
 Home-page: https://github.com/yourusername/mcp-proxy-adapter
 Author: MCP Team

{mcp_proxy_adapter-3.0.3.dist-info → mcp_proxy_adapter-3.1.0.dist-info}/RECORD

@@ -20,6 +20,7 @@ examples/basic_example/docs/EN/README.md,sha256=grOp0Adr3h9m-XZLCgLO6haBdUOjc4_V
 examples/basic_example/docs/RU/README.md,sha256=8jBObIj_3-eDmFt35ufIRw6mm41FyUXJD7olHmKS2QM,6736
 examples/basic_example/tests/conftest.py,sha256=6e85QRE50P9PMV1RXXVgtBQxy49hVLbevZ6dHFBrxRU,5917
 examples/commands/echo_command.py,sha256=7RuUZfP0YlKl9gks02NiuiYEiiNPa_8lk9CAZmzijyo,1569
+examples/commands/echo_command_di.py,sha256=RMumhS6uKFjbvyjlW8IG24HB8UdOEVk-8WLD3xLfCS8,4307
 examples/commands/echo_result.py,sha256=q5IUEeFoi4PunzOhYD0zju2ZwETdGl35yj4DVXZfX68,1635
 examples/commands/get_date_command.py,sha256=ePQzZCV-n3tLf4IYv6Gn75t0AXXplXtikCDmrIMD2Q4,2537
 examples/commands/new_uuid4_command.py,sha256=lJQiPuVHtKCnOEUQukji6dwe0VOkddJ7sZXZ7XUsY6Y,2240
@@ -34,6 +35,8 @@ examples/complete_example/commands/__init__.py,sha256=cZDiwz3nLaeSCwR4oK7xlGgVsX
 examples/complete_example/commands/system_command.py,sha256=CwcBRWMODG7Ynr9Syaildu3APuuUdJ_yvQOggAAidg8,10717
 examples/complete_example/configs/config.dev.yaml,sha256=ASIwU8xzB-kinAsLGghv8-LCER1SUC1ed6K8BktOYPQ,1282
 examples/complete_example/configs/config.docker.yaml,sha256=DZWxauz5fcaiVFaphvf7zpvLI3oXjUUiXdX_bGlcBds,1389
+examples/di_example/server.py,sha256=SRcKa_50L6Es7nDYSyTY3zzKQjlCdkAMAEjbwRe8esQ,7144
+examples/di_example/.pytest_cache/README.md,sha256=c_1vzN2ALEGaay2YPWwxc7fal1WKxLWJ7ewt_kQ9ua0,302
 examples/minimal_example/README.md,sha256=VFKjDgpNjFowYNLD3sHHGsc1CVhCm30BWPGBqpLFKAc,2569
 examples/minimal_example/__init__.py,sha256=EloOqdgVLp7YA2DJOWMw0ZxFbVUCH2LqvZVq5RSfSbg,165
 examples/minimal_example/config.json,sha256=FSL0q_dAyGHJXp37bLesUvvNgrCiFXkQ8_P7nuUhIcQ,250
@@ -47,10 +50,10 @@ mcp_proxy_adapter/config.py,sha256=MjgZAld6TiD0F5oCyEaJhYhfEXVZxc5G5ke2SLKCV9A,5
 mcp_proxy_adapter/custom_openapi.py,sha256=a8DidORiO2sxMnRHlgSD0C6_6lZi3K56-PzF2p_t4NE,6316
 mcp_proxy_adapter/openapi.py,sha256=jyl5EPXcFhzFKEEMXxHeqF1U-SsYvtdlaKGU2QrekpU,13889
 mcp_proxy_adapter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_proxy_adapter/version.py,sha256=n1SIxB1BUfUjywGxxK6RFEDs6vMuHouqenqqD9oFKfg,71
+mcp_proxy_adapter/version.py,sha256=udZyygpuqFCo_l08d6MC6yACDv6doZddjSPjgE-ghpQ,71
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_proxy_adapter/api/app.py,sha256=q3yYsNEBFXYr2TOJFxfh6bbF53NkmmgfzSFOtVq7xdc,14353
-mcp_proxy_adapter/api/handlers.py,sha256=4oAkc-szU3tggkLehqvTW2P5c3HTLIiqXQMwCY0ua2Q,7043
+mcp_proxy_adapter/api/handlers.py,sha256=lc_4eakQgQVlnGjnVkOY-mIMkfyLk4iRfwdrWTyvuvM,7194
 mcp_proxy_adapter/api/schemas.py,sha256=xOmiSwHaapY6myEFnLu7o-LWVPM7vwmLYZXFo2c6NfE,12381
 mcp_proxy_adapter/api/tool_integration.py,sha256=mQNFiCkd4plY_A3fkG6auaM8D_1XiC9Jxp4Zrm1ngYE,10161
 mcp_proxy_adapter/api/tools.py,sha256=nSDXD4rGlFV_NlB91Y0x3N8WeWvWZ76B32-s-VAFARw,8084
@@ -61,10 +64,11 @@ mcp_proxy_adapter/api/middleware/error_handling.py,sha256=ShguFRn9GBBprevKO7n77E
 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=cbds-RqRNyF-BM1PMa_j6OfyTENXzh54Z1aI2b3XpCU,475
-mcp_proxy_adapter/commands/base.py,sha256=NF7Xvssc6T3rb0s-LcDzjxG4IisNR0911EQpc-LbDyk,10670
-mcp_proxy_adapter/commands/command_registry.py,sha256=fNPsD1fQGDCp6qMnG3uMa-bDkPTAEw-GgFfoW0Sfwd8,8015
+mcp_proxy_adapter/commands/__init__.py,sha256=Zxm-hw0rQGdlRAfhNVWaLvgqIYc3w8DYQS9hLUbjuSE,609
+mcp_proxy_adapter/commands/base.py,sha256=zjDD7OwQN4wBrsJs1Xq3H1tZg0kUMBiRy8lpItzrqyU,12743
+mcp_proxy_adapter/commands/command_registry.py,sha256=x55k4guzOlm7fVRolJ_iSFPRx2Snq4yBaMQdzVmsK0A,10460
 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=UguKpvnmyW6qXZZyzdcJSVqKzLYi-AvaXo_UKyLR8js,6836
 mcp_proxy_adapter/commands/result.py,sha256=2WjftiAuhlyzOKmPJlQHo_b08ZCzWoK7cquUHFLVE-E,5534
@@ -78,14 +82,14 @@ mcp_proxy_adapter/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 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=Oa-W3Z_758hLobsUcWMdZU2YxTueLusrzzRY1ZwSRY4,3778
+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=o5HHxlQ-D2ML0ufJK-lXQv-qYWccvalOHGVvpc8QFTU,6285
 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_middleware.py,sha256=A_-rpW0Kifg4SgjV3NxjQhOhFUSbnUWJjVJAAQWjEeQ,12063
+mcp_proxy_adapter/tests/api/test_middleware.py,sha256=3Rgc09VJ7JG6_06oIgAVq6u7qJsaiuhW0KpfDjxk8Ac,12285
 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
@@ -102,8 +106,8 @@ mcp_proxy_adapter/tests/stubs/echo_command.py,sha256=Y7SA4IB5Lo_ncn78SDm9iRZvJSK
 mcp_proxy_adapter/tests/unit/__init__.py,sha256=RS-5UoSCcLKtr2jrAaZw_NG9MquA6BZmxq-P6cTw9ok,53
 mcp_proxy_adapter/tests/unit/test_base_command.py,sha256=ldDXQYk2eijbTgZioSBAhHzSAa_SuBKYqCutCEzUYTE,3924
 mcp_proxy_adapter/tests/unit/test_config.py,sha256=SZ62LXFOv_fsV0fmSIBdHWvapEyexKrioFRQo0I4pkg,5900
-mcp_proxy_adapter-3.0.3.dist-info/licenses/LICENSE,sha256=OkApFEwdgMCt_mbvUI-eIwKMSTe38K3XnU2DT5ub-wI,1072
-mcp_proxy_adapter-3.0.3.dist-info/METADATA,sha256=kyCCy5J9i92A38ew7UbqT4Tsy0KAKwPkLu0v00CnfFI,7537
-mcp_proxy_adapter-3.0.3.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-mcp_proxy_adapter-3.0.3.dist-info/top_level.txt,sha256=kxq3OC7vBtsFdy9dDVse4cOl-SV_QlvcTeSkuw_jw3I,27
-mcp_proxy_adapter-3.0.3.dist-info/RECORD,,
+mcp_proxy_adapter-3.1.0.dist-info/licenses/LICENSE,sha256=OkApFEwdgMCt_mbvUI-eIwKMSTe38K3XnU2DT5ub-wI,1072
+mcp_proxy_adapter-3.1.0.dist-info/METADATA,sha256=igXpT1nZAiVx9DOZu1yG4-HKgpfZ2Ej-68zkt5xaDtI,7537
+mcp_proxy_adapter-3.1.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+mcp_proxy_adapter-3.1.0.dist-info/top_level.txt,sha256=kxq3OC7vBtsFdy9dDVse4cOl-SV_QlvcTeSkuw_jw3I,27
+mcp_proxy_adapter-3.1.0.dist-info/RECORD,,

{mcp_proxy_adapter-3.0.3.dist-info → mcp_proxy_adapter-3.1.0.dist-info}/WHEEL

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