mcp-proxy-adapter 2.1.17__py3-none-any.whl → 3.0.0__py3-none-any.whl

mcp_proxy_adapter/dispatchers/json_rpc_dispatcher.py

@@ -1,262 +0,0 @@
-"""
-Implementation of a JSON-RPC based command dispatcher.
-
-CHANGELOG:
-- 2024-06-13: execute() now always returns awaitable. If handler is sync and for any reason result is not awaitable, it is wrapped in an async function and awaited. This guarantees await-safety for all handler types and fixes 'object ... can't be used in await expression' errors in all environments.
-"""
-from typing import Dict, Any, Callable, List, Optional, Union
-import inspect
-import logging
-import traceback
-from .base_dispatcher import BaseDispatcher
-import asyncio
-
-logger = logging.getLogger("command_registry")
-
-print('[DEBUG] LOADED json_rpc_dispatcher.py')
-
-class CommandError(Exception):
-    """Base class for command errors"""
-    pass
-
-class CommandNotFoundError(CommandError):
-    """Error raised when attempting to execute a non-existent command"""
-    pass
-
-class CommandExecutionError(CommandError):
-    """Error raised during command execution"""
-    pass
-
-class JsonRpcDispatcher(BaseDispatcher):
-    """
-    JSON-RPC based command dispatcher.
-    
-    Implements the BaseDispatcher interface for handling commands in JSON-RPC 2.0 format.
-    Supports registration, execution, and retrieval of command information.
-
-    Best practice:
-    ----------------
-    Register handlers explicitly using register_handler (no decorators!).
-    Both sync and async handlers are supported.
-
-    Example:
-        import asyncio
-        from mcp_proxy_adapter.dispatchers.json_rpc_dispatcher import JsonRpcDispatcher
-
-        def sync_handler(x):
-            return x + 1
-
-        async def async_handler(x):
-            await asyncio.sleep(0.1)
-            return x * 2
-
-        dispatcher = JsonRpcDispatcher()
-        dispatcher.register_handler('sync', sync_handler, description='Sync handler')
-        dispatcher.register_handler('async', async_handler, description='Async handler')
-
-        # Call sync handler
-        result_sync = asyncio.run(dispatcher.execute('sync', x=10))
-        print(result_sync)  # 11
-
-        # Call async handler
-        result_async = asyncio.run(dispatcher.execute('async', x=10))
-        print(result_async)  # 20
-    """
-    
-    def __init__(self):
-        """Initializes a new dispatcher instance"""
-        self._handlers = {}
-        self._metadata = {}
-        
-        # Register the built-in help command
-        self.register_handler(
-            command="help",
-            handler=self._help_command,
-            description=(
-                "Returns information about available commands.\n"
-                "Best practice: Register handlers explicitly using register_handler (no decorators).\n"
-                "Example: dispatcher.register_handler('mycmd', my_handler, description='...')"
-            ),
-            summary="Command help",
-            params={
-                "cmdname": {
-                    "type": "string",
-                    "description": "Command name for detailed information",
-                    "required": False
-                }
-            }
-        )
-    
-    def register_handler(
-        self, 
-        command: str, 
-        handler: Callable, 
-        description: str = "", 
-        summary: str = "", 
-        params: Dict[str, Any] = None
-    ) -> None:
-        """
-        Registers a command handler.
-        
-        Args:
-            command: Command name
-            handler: Command handler function
-            description: Command description
-            summary: Brief command summary
-            params: Command parameters description
-        """
-        if not params:
-            params = {}
-            
-        # Save the handler
-        self._handlers[command] = handler
-        
-        # Save metadata
-        self._metadata[command] = {
-            "description": description,
-            "summary": summary or command.replace("_", " ").title(),
-            "params": params
-        }
-        
-        logger.debug(f"Registered command: {command}")
-    
-    async def _call_handler_always_awaitable(self, handler, kwargs):
-        loop = asyncio.get_running_loop()
-        sig = inspect.signature(handler)
-        params = sig.parameters
-        try:
-            if inspect.iscoroutinefunction(handler):
-                if len(params) == 1 and 'params' in params:
-                    result = handler(params=kwargs)
-                else:
-                    result = handler(**kwargs)
-            else:
-                if len(params) == 1 and 'params' in params:
-                    result = loop.run_in_executor(None, lambda: handler(params=kwargs))
-                else:
-                    result = loop.run_in_executor(None, lambda: handler(**kwargs))
-            if inspect.isawaitable(result):
-                return await result
-            else:
-                async def _return_sync():
-                    return result
-                return await _return_sync()
-        except TypeError as e:
-            # Попробовать вызвать handler(params=kwargs), если ошибка связана с лишними именованными аргументами
-            if (len(params) == 1 and 'params' in params):
-                try:
-                    if inspect.iscoroutinefunction(handler):
-                        result = handler(params=kwargs)
-                    else:
-                        result = loop.run_in_executor(None, lambda: handler(params=kwargs))
-                    if inspect.isawaitable(result):
-                        return await result
-                    else:
-                        async def _return_sync():
-                            return result
-                        return await _return_sync()
-                except Exception:
-                    pass
-            raise e
-
-    async def execute(self, command: str, **kwargs) -> Any:
-        """
-        Executes a command with the specified parameters.
-        """
-        if command not in self._handlers:
-            raise CommandNotFoundError(f"Command '{command}' not found")
-        handler = self._handlers[command]
-        try:
-            return await self._call_handler_always_awaitable(handler, kwargs)
-        except Exception as e:
-            logger.error(f"Error executing command '{command}': {str(e)}")
-            logger.debug(traceback.format_exc())
-            raise CommandExecutionError(f"Error executing command '{command}': {str(e)}")
-    
-    def get_valid_commands(self) -> List[str]:
-        """
-        Returns a list of all registered command names.
-        
-        Returns:
-            List[str]: List of command names
-        """
-        return list(self._handlers.keys())
-    
-    def get_command_info(self, command: str) -> Optional[Dict[str, Any]]:
-        """
-        Returns information about a command.
-        
-        Args:
-            command: Command name
-            
-        Returns:
-            Optional[Dict[str, Any]]: Command information or None if command not found
-        """
-        if command not in self._metadata:
-            return None
-        
-        return self._metadata[command]
-    
-    def get_commands_info(self) -> Dict[str, Dict[str, Any]]:
-        """
-        Returns information about all registered commands.
-        
-        Returns:
-            Dict[str, Dict[str, Any]]: Dictionary {command_name: information}
-        """
-        return self._metadata.copy()
-    
-    def _help_command(self, params: Dict[str, Any] = None) -> Dict[str, Any]:
-        """
-        Built-in help command for getting command information.
-        
-        Args:
-            params: Command parameters
-                cmdname: Command name for detailed information
-                
-        Returns:
-            Dict[str, Any]: Command help information
-        """
-        if not params:
-            params = {}
-        # Если передан неправильный параметр 'command', возвращаем понятную ошибку
-        if "command" in params and params["command"]:
-            return {
-                "error": "Parameter 'command' is not supported. Use 'cmdname' instead.",
-                "hint": "Send params: {\"cmdname\": \"your_command\"}",
-                "example": {"jsonrpc": "2.0", "method": "help", "params": {"cmdname": "your_command"}, "id": 1}
-            }
-        # Если handler вызывается синхронно и возвращает coroutine, возвращаем явную ошибку
-        if inspect.iscoroutinefunction(self._help_command):
-            return {
-                "error": "Help handler must be awaited. Call as await dispatcher.execute('help', ...) in async context.",
-                "hint": "Use async endpoint or await the result in your code.",
-                "example": "result = await dispatcher.execute('help', cmdname='your_command')"
-            }
-        # If specific command is specified, return information only about it
-        if "cmdname" in params and params["cmdname"]:
-            command = params["cmdname"]
-            if command not in self._metadata:
-                return {
-                    "error": f"Command '{command}' not found",
-                    "available_commands": list(self._metadata.keys())
-                }
-            return {
-                "command": command,
-                "info": self._metadata[command]
-            }
-        
-        # Otherwise return brief information about all commands
-        commands_info = {}
-        for cmd, info in self._metadata.items():
-            commands_info[cmd] = {
-                "summary": info["summary"],
-                "description": info["description"],
-                "params_count": len(info["params"])
-            }
-        
-        return {
-            "commands": commands_info,
-            "total": len(commands_info),
-            "note": "Use the 'cmdname' parameter to get detailed information about a specific command"
-        } 

mcp_proxy_adapter/examples/analyze_config.py

@@ -1,141 +0,0 @@
-"""
-Analysis of MCP Proxy configuration generated by the adapter.
-
-This script loads and analyzes the MCP Proxy configuration file
-that was created by MCPProxyAdapter, and outputs structured
-information about routes and tools.
-
-Usage:
-    python examples/analyze_config.py
-"""
-import os
-import json
-import sys
-from typing import Dict, Any, List
-
-
-def load_config_file(config_path: str) -> Dict[str, Any]:
-    """
-    Loads MCP Proxy configuration file.
-    
-    Args:
-        config_path (str): Path to configuration file
-        
-    Returns:
-        Dict[str, Any]: Loaded configuration
-        
-    Raises:
-        FileNotFoundError: If file is not found
-        json.JSONDecodeError: If file is not valid JSON
-    """
-    try:
-        with open(config_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except FileNotFoundError:
-        print(f"Error: Configuration file not found: {config_path}")
-        sys.exit(1)
-    except json.JSONDecodeError as e:
-        print(f"Error: File is not valid JSON: {e}")
-        sys.exit(1)
-
-
-def print_routes(config: Dict[str, Any]) -> None:
-    """
-    Prints route information from configuration.
-    
-    Args:
-        config (Dict[str, Any]): MCP Proxy configuration
-    """
-    if "routes" not in config:
-        print("No routes in configuration")
-        return
-    
-    routes = config["routes"]
-    print(f"=== Routes ({len(routes)}) ===")
-    
-    for i, route in enumerate(routes, 1):
-        print(f"\n{i}. Route:")
-        print(f"   Endpoint: {route.get('endpoint', 'Not specified')}")
-        print(f"   Method: {route.get('method', 'Not specified')}")
-        
-        if "json_rpc" in route:
-            print("   Type: JSON-RPC")
-            if "params" in route["json_rpc"]:
-                print(f"   Parameters: {route['json_rpc'].get('params', 'Not specified')}")
-        else:
-            print("   Type: Regular HTTP")
-
-
-def print_tools(config: Dict[str, Any]) -> None:
-    """
-    Prints tool information from configuration.
-    
-    Args:
-        config (Dict[str, Any]): MCP Proxy configuration
-    """
-    if "tools" not in config:
-        print("No tools in configuration")
-        return
-    
-    tools = config["tools"]
-    print(f"\n=== Tools ({len(tools)}) ===")
-    
-    for i, tool in enumerate(tools, 1):
-        print(f"\n{i}. Tool:")
-        print(f"   Name: {tool.get('name', 'Not specified')}")
-        print(f"   Description: {tool.get('description', 'Not specified')}")
-        
-        if "parameters" in tool:
-            params = tool["parameters"]
-            required_params = params.get("required", [])
-            properties = params.get("properties", {})
-            
-            print(f"   Parameters ({len(properties)}):") 
-            for param_name, param_info in properties.items():
-                required = "Required" if param_name in required_params else "Optional"
-                param_type = param_info.get("type", "Not specified")
-                description = param_info.get("description", "Not specified")
-                
-                print(f"     - {param_name} ({param_type}, {required}):")
-                print(f"       {description}")
-
-
-def analyze_config(config_path: str) -> None:
-    """
-    Analyzes MCP Proxy configuration.
-    
-    Args:
-        config_path (str): Path to configuration file
-    """
-    config = load_config_file(config_path)
-    
-    print("\n=== MCP Proxy Configuration Analysis ===")
-    print(f"File: {config_path}")
-    print(f"Version: {config.get('version', 'Not specified')}")
-    
-    print_routes(config)
-    print_tools(config)
-    
-    print("\n=== Summary ===")
-    num_routes = len(config.get("routes", []))
-    num_tools = len(config.get("tools", []))
-    
-    print(f"Configuration contains {num_routes} routes and {num_tools} tools.")
-    
-    if num_tools > 0 and num_routes > 0:
-        print("MCP Proxy is configured correctly and ready to use.")
-    else:
-        print("WARNING: Configuration may be incomplete or incorrect.")
-
-
-def main():
-    """Main script function."""
-    # Define path to configuration file
-    config_path = os.path.join(os.path.dirname(__file__), "mcp_proxy_config.json")
-    
-    # Analyze configuration
-    analyze_config(config_path)
-
-
-if __name__ == "__main__":
-    main() 

mcp_proxy_adapter/examples/basic_integration.py

@@ -1,155 +0,0 @@
-"""
-Example of basic MCPProxyAdapter integration with an existing FastAPI application.
-"""
-import logging
-import os
-import sys
-from typing import Dict, Any, List, Optional
-
-# Add parent directory to import path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-if parent_dir not in sys.path:
-    sys.path.insert(0, parent_dir)
-
-from fastapi import FastAPI, HTTPException, APIRouter
-from pydantic import BaseModel
-from mcp_proxy_adapter.adapter import MCPProxyAdapter, configure_logger
-from mcp_proxy_adapter.registry import CommandRegistry
-
-# Configure project logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-
-# Create project logger
-project_logger = logging.getLogger("my_project")
-project_logger.setLevel(logging.DEBUG)
-
-# Configure adapter logger using project logger
-adapter_logger = configure_logger(project_logger)
-
-# Create FastAPI application
-app = FastAPI(
-    title="My API with MCP Proxy Integration",
-    description="API with Command Registry integration, supporting MCP Proxy",
-    version="1.0.0"
-)
-
-# Define existing endpoints
-router = APIRouter()
-
-class Item(BaseModel):
-    name: str
-    price: float
-    is_active: bool = True
-
-@router.get("/items", response_model=List[Item])
-async def get_items():
-    """Returns list of items."""
-    return [
-        {"name": "Item 1", "price": 10.5, "is_active": True},
-        {"name": "Item 2", "price": 20.0, "is_active": False},
-        {"name": "Item 3", "price": 30.0, "is_active": True},
-    ]
-
-@router.get("/items/{item_id}", response_model=Item)
-async def get_item(item_id: int):
-    """Returns item information by ID."""
-    items = [
-        {"name": "Item 1", "price": 10.5, "is_active": True},
-        {"name": "Item 2", "price": 20.0, "is_active": False},
-        {"name": "Item 3", "price": 30.0, "is_active": True},
-    ]
-    
-    if item_id < 1 or item_id > len(items):
-        raise HTTPException(status_code=404, detail="Item not found")
-    
-    return items[item_id - 1]
-
-# Add existing endpoints to application
-app.include_router(router)
-
-# Define commands for Command Registry
-def list_items() -> List[Dict[str, Any]]:
-    """
-    Returns list of all items.
-    
-    Returns:
-        List[Dict[str, Any]]: List of items
-    """
-    return [
-        {"name": "Item 1", "price": 10.5, "is_active": True},
-        {"name": "Item 2", "price": 20.0, "is_active": False},
-        {"name": "Item 3", "price": 30.0, "is_active": True},
-    ]
-
-def get_item_by_id(item_id: int) -> Dict[str, Any]:
-    """
-    Returns item information by ID.
-    
-    Args:
-        item_id: Item ID
-        
-    Returns:
-        Dict[str, Any]: Item information
-        
-    Raises:
-        ValueError: If item is not found
-    """
-    items = list_items()
-    
-    if item_id < 1 or item_id > len(items):
-        raise ValueError(f"Item with ID {item_id} not found")
-    
-    return items[item_id - 1]
-
-def search_items(query: str, min_price: Optional[float] = None, max_price: Optional[float] = None) -> List[Dict[str, Any]]:
-    """
-    Searches for items by name and price range.
-    
-    Args:
-        query: Search query for name
-        min_price: Minimum price (optional)
-        max_price: Maximum price (optional)
-        
-    Returns:
-        List[Dict[str, Any]]: List of found items
-    """
-    items = list_items()
-    
-    # Filter by name
-    filtered_items = [item for item in items if query.lower() in item["name"].lower()]
-    
-    # Filter by minimum price
-    if min_price is not None:
-        filtered_items = [item for item in filtered_items if item["price"] >= min_price]
-    
-    # Filter by maximum price
-    if max_price is not None:
-        filtered_items = [item for item in filtered_items if item["price"] <= max_price]
-    
-    return filtered_items
-
-# Create CommandRegistry instance
-registry = CommandRegistry()
-
-# Register commands
-registry.register_command("list_items", list_items)
-registry.register_command("get_item", get_item_by_id)
-registry.register_command("search_items", search_items)
-
-# Create MCP Proxy adapter
-adapter = MCPProxyAdapter(registry)
-
-# Register endpoints in existing application
-adapter.register_endpoints(app)
-
-# Save configuration for MCP Proxy
-adapter.save_config_to_file("mcp_proxy_config.json")
-
-# Entry point for running the application
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000) 

mcp_proxy_adapter/examples/docstring_and_schema_example.py

@@ -1,69 +0,0 @@
-"""
-Docstring and Schema Example for MCPProxyAdapter
-
-- How to write docstrings for commands
-- How docstrings are used in OpenAPI/schema
-- Best practices for documenting parameters and return values
-
-Run:
-    python examples/docstring_and_schema_example.py
-"""
-import os
-import sys
-import asyncio
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
-from mcp_proxy_adapter.adapter import MCPProxyAdapter
-
-class MyRegistry:
-    def __init__(self):
-        self.dispatcher = self
-        self.commands = {"sum": self.sum_numbers}
-        self.commands_info = {
-            "sum": {
-                "description": self.sum_numbers.__doc__,
-                "params": {
-                    "a": {"type": "integer", "description": "First number", "required": True},
-                    "b": {"type": "integer", "description": "Second number", "required": True}
-                }
-            }
-        }
-    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
-    def execute(self, command, **params):
-        if command == "sum":
-            return self.sum_numbers(**params)
-        raise KeyError(f"Unknown command: {command}")
-    def add_generator(self, generator):
-        pass
-    def sum_numbers(self, a: int, b: int) -> int:
-        """
-        Returns the sum of two numbers.
-        
-        Args:
-            a (int): First number
-            b (int): Second number
-        
-        Returns:
-            int: The sum of a and b
-        """
-        return a + b
-
-if __name__ == "__main__":
-    registry = MyRegistry()
-    adapter = MCPProxyAdapter(registry)
-    # Print OpenAPI schema (simulated)
-    schema = adapter.generate_mcp_proxy_config()
-    print("=== Tool description from docstring ===")
-    print(schema.tools[0].description)
-
-    # Call sync handler
-    result_sync = registry.execute('sum', a=10, b=1)
-    print(result_sync)  # 11
-
-    # Call sync handler (ещё раз)
-    result_sync2 = registry.execute('sum', a=10, b=10)
-    print(result_sync2)  # 20 

mcp_proxy_adapter/examples/extension_example.py

@@ -1,72 +0,0 @@
-"""
-Extension Example for MCPProxyAdapter
-
-- How to add custom commands
-- How to extend help logic
-- How to customize error handling
-
-Run:
-    python examples/extension_example.py
-"""
-import os
-import sys
-import asyncio
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
-from mcp_proxy_adapter.adapter import MCPProxyAdapter
-
-class MyRegistry:
-    def __init__(self):
-        self.dispatcher = self
-        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": {"cmdname": {"type": "string", "description": "Command name", "required": False}}}
-        }
-    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
-    def execute(self, *args, **params):
-        if args:
-            command = args[0]
-            params = {k: v for k, v in params.items()}
-        else:
-            command = params.pop("cmdname", None)
-        if command == "ping":
-            return self.ping()
-        if command == "help":
-            return self.help_command(**params)
-        raise KeyError(f"Unknown command: {command}")
-    def add_generator(self, generator):
-        pass
-    def ping(self):
-        """Ping command."""
-        return {"result": "pong"}
-    def help_command(self, cmdname: str = None):
-        """Custom help logic: returns info for command or all commands."""
-        if not cmdname:
-            return {"commands": list(self.commands_info.keys())}
-        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()
-    adapter = MCPProxyAdapter(registry)
-    # Call sync handler
-    result_sync = registry.execute("ping")
-    print(result_sync)  # Ping
-
-    # Call help (all)
-    result_help_all = registry.execute("help")
-    print("Help (all)", result_help_all)
-
-    # Call help (ping)
-    result_help_ping = registry.execute("help", cmdname="ping")
-    print("Help (ping)", result_help_ping)
-
-    # Call help (notfound)
-    result_help_notfound = registry.execute("help", cmdname="notfound")
-    print("Help (notfound)", result_help_notfound)