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

mcp_proxy_adapter/testing_utils.py

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

mcp_proxy_adapter/validators/__init__.py

@@ -1 +0,0 @@
- 

mcp_proxy_adapter/validators/docstring_validator.py

@@ -1,75 +0,0 @@
-"""
-Validator for checking the correspondence between docstrings and function signatures.
-"""
-import inspect
-from typing import Dict, Any, Optional, Callable, List, Tuple, get_type_hints
-import docstring_parser
-
-class DocstringValidator:
-    """
-    Validator for checking the correspondence between docstrings and handler functions.
-    
-    This class verifies that function docstrings match their signatures,
-    contain all necessary sections, and describe all parameters.
-    """
-    
-    def validate(self, handler: Callable, command_name: str, metadata: Dict[str, Any]) -> Tuple[bool, List[str]]:
-        """
-        Validates the function's docstring against its formal parameters.
-        
-        Args:
-            handler: Command handler function
-            command_name: Command name
-            metadata: Command metadata
-            
-        Returns:
-            Tuple[bool, List[str]]: Validity flag and list of errors
-        """
-        errors = []
-        
-        # Get formal parameters of the function
-        sig = inspect.signature(handler)
-        formal_params = list(sig.parameters.keys())
-        
-        # Skip self parameter for methods
-        if formal_params and formal_params[0] == 'self':
-            formal_params = formal_params[1:]
-            
-        # Parse docstring
-        docstring = handler.__doc__ or ""
-        parsed_doc = docstring_parser.parse(docstring)
-        
-        # Check for function description
-        if not parsed_doc.short_description and not parsed_doc.long_description:
-            errors.append(f"Missing function description")
-        
-        # Get parameters from docstring
-        doc_params = {param.arg_name: param for param in parsed_doc.params}
-        
-        # Check that all formal parameters are described in the docstring
-        for param in formal_params:
-            # Skip special parameters
-            if param in ('params', 'kwargs'):
-                continue
-                
-            if param not in doc_params:
-                errors.append(f"Parameter '{param}' is not described in the function docstring")
-        
-        # Check for returns in docstring
-        if not parsed_doc.returns and not any(t.type_name == 'Returns' for t in parsed_doc.meta):
-            errors.append(f"Missing return value description in the function docstring")
-        
-        # Check for type annotations
-        try:
-            type_hints = get_type_hints(handler)
-            for param in formal_params:
-                # Skip special parameters
-                if param in ('params', 'kwargs'):
-                    continue
-                    
-                if param not in type_hints:
-                    errors.append(f"Missing type annotation for parameter '{param}' in function {command_name}")
-        except Exception as e:
-            errors.append(f"Error getting type hints: {str(e)}")
-        
-        return len(errors) == 0, errors 

mcp_proxy_adapter/validators/metadata_validator.py

@@ -1,76 +0,0 @@
-"""
-Validator for checking command metadata against function signatures.
-"""
-import inspect
-from typing import Dict, Any, Optional, Callable, List, Tuple
-
-class MetadataValidator:
-    """
-    Validator for checking handler function metadata.
-    
-    This class verifies that command metadata matches function signatures,
-    and all parameters are correctly described.
-    """
-    
-    def validate(self, handler: Callable, command_name: str, metadata: Dict[str, Any]) -> Tuple[bool, List[str]]:
-        """
-        Checks if metadata matches function's formal parameters.
-        
-        Args:
-            handler: Command handler function
-            command_name: Command name
-            metadata: Command metadata
-            
-        Returns:
-            Tuple[bool, List[str]]: Validity flag and list of errors
-        """
-        errors = []
-        
-        # Check presence of main fields in metadata
-        if not metadata.get('description'):
-            errors.append(f"Missing description for command '{command_name}'")
-            
-        # Get function's formal parameters
-        sig = inspect.signature(handler)
-        formal_params = list(sig.parameters.keys())
-        
-        # Skip self parameter for methods
-        if formal_params and formal_params[0] == 'self':
-            formal_params = formal_params[1:]
-            
-        # Check presence of parameters in metadata
-        if 'parameters' not in metadata or not isinstance(metadata['parameters'], dict):
-            errors.append(f"Parameters are missing or incorrectly defined in metadata for command '{command_name}'")
-            return False, errors
-            
-        meta_params = metadata['parameters']
-        
-        # Check that all formal parameters are in metadata
-        for param in formal_params:
-            # Skip special parameters
-            if param in ('params', 'kwargs'):
-                continue
-                
-            if param not in meta_params:
-                errors.append(f"Parameter '{param}' is not described in metadata for command '{command_name}'")
-                continue
-                
-            param_info = meta_params[param]
-            
-            # Check presence of required fields for parameter
-            if not isinstance(param_info, dict):
-                errors.append(f"Incorrect format for parameter '{param}' description in metadata for command '{command_name}'")
-                continue
-                
-            if 'type' not in param_info:
-                errors.append(f"Type is not specified for parameter '{param}' in metadata for command '{command_name}'")
-                
-            if 'description' not in param_info:
-                errors.append(f"Description is not specified for parameter '{param}' in metadata for command '{command_name}'")
-        
-        # Check that there are no extra parameters in metadata
-        for param in meta_params:
-            if param not in formal_params and param not in ('params', 'kwargs'):
-                errors.append(f"Extra parameter '{param}' in metadata for command '{command_name}'")
-        
-        return len(errors) == 0, errors 

mcp_proxy_adapter-2.1.16.dist-info/METADATA

@@ -1,341 +0,0 @@
-Metadata-Version: 2.4
-Name: mcp-proxy-adapter
-Version: 2.1.16
-Summary: Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy.
-Home-page: https://github.com/vasilyvz/mcp-proxy-adapter
-Author: Vasiliy VZ
-Author-email: Vasiliy VZ <vasilyvz@example.com>
-License: MIT
-Project-URL: Homepage, https://github.com/vasilyvz/mcp-proxy-adapter
-Project-URL: Bug Tracker, https://github.com/vasilyvz/mcp-proxy-adapter/issues
-Project-URL: Documentation, https://github.com/vasilyvz/mcp-proxy-adapter/tree/main/docs
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9, <4
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi<1.0.0,>=0.95.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: uvicorn<1.0.0,>=0.22.0
-Requires-Dist: docstring-parser<1.0.0,>=0.15
-Requires-Dist: typing-extensions<5.0.0,>=4.5.0
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-
-# MCP Proxy Adapter
-
-Adapter for integrating [Command Registry](docs/README.md) with MCP Proxy, allowing you to use commands as tools for AI models.
-
-## Overview
-
-MCP Proxy Adapter transforms commands registered in the Command Registry into a format compatible with MCP Proxy. This enables:
-
-1. Using existing commands as tools for AI models
-2. Creating a hybrid REST/JSON-RPC API for command execution
-3. Automatic generation of OpenAPI schemas optimized for MCP Proxy
-4. Managing tool metadata for better AI system integration
-
-## Installation
-
-```bash
-pip install mcp-proxy-adapter
-```
-
-## Quick Start
-
-```python
-from mcp_proxy_adapter import MCPProxyAdapter, CommandRegistry
-from fastapi import FastAPI
-
-# Create a command registry instance
-registry = CommandRegistry()
-
-# Register commands
-def calculate_total(prices: list[float], discount: float = 0.0) -> float:
-    """
-    Calculates the total price with discount.
-    Args:
-        prices: List of item prices
-        discount: Discount percentage (0-100)
-    Returns:
-        Total price with discount
-    """
-    subtotal = sum(prices)
-    return subtotal * (1 - discount / 100)
-
-registry.register_command("calculate_total", calculate_total)
-
-# Create FastAPI app
-app = FastAPI()
-
-# Create and configure MCP Proxy adapter
-adapter = MCPProxyAdapter(registry)
-
-# Register endpoints in FastAPI app
-adapter.register_endpoints(app)
-
-# Generate and save MCP Proxy config
-adapter.save_config_to_file("mcp_proxy_config.json")
-```
-
-## Supported Request Formats
-
-The adapter supports three request formats for command execution:
-
-### 1. JSON-RPC format
-
-```json
-{
-  "jsonrpc": "2.0",
-  "method": "command_name",
-  "params": {
-    "param1": "value1",
-    "param2": "value2"
-  },
-  "id": 1
-}
-```
-
-Example request to `/cmd` endpoint:
-
-```bash
-curl -X POST -H "Content-Type: application/json" -d '{
-  "jsonrpc": "2.0",
-  "method": "calculate_total",
-  "params": {
-    "prices": [100, 200, 300],
-    "discount": 10
-  },
-  "id": 1
-}' http://localhost:8000/cmd
-```
-
-Response:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "result": 540.0,
-  "id": 1
-}
-```
-
-### 2. MCP Proxy format
-
-```json
-{
-  "command": "command_name",
-  "params": {
-    "param1": "value1",
-    "param2": "value2"
-  }
-}
-```
-
-Example request:
-
-```bash
-curl -X POST -H "Content-Type: application/json" -d '{
-  "command": "calculate_total",
-  "params": {
-    "prices": [100, 200, 300],
-    "discount": 10
-  }
-}' http://localhost:8000/cmd
-```
-
-Response:
-
-```json
-{
-  "result": 540.0
-}
-```
-
-### 3. Params-only format
-
-```json
-{
-  "params": {
-    "command": "command_name",
-    "param1": "value1",
-    "param2": "value2"
-  }
-}
-```
-
-or
-
-```json
-{
-  "params": {
-    "query": "command_name",
-    "param1": "value1",
-    "param2": "value2"
-  }
-}
-```
-
-Example request:
-
-```bash
-curl -X POST -H "Content-Type: application/json" -d '{
-  "params": {
-    "command": "calculate_total",
-    "prices": [100, 200, 300],
-    "discount": 10
-  }
-}' http://localhost:8000/cmd
-```
-
-Response:
-
-```json
-{
-  "result": 540.0
-}
-```
-
-## Full Example: Integration with FastAPI
-
-```python
-import logging
-from fastapi import FastAPI, APIRouter
-from mcp_proxy_adapter import CommandRegistry, MCPProxyAdapter, configure_logger
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-project_logger = logging.getLogger("my_project")
-
-# Create FastAPI app
-app = FastAPI(title="My API with MCP Proxy Integration")
-
-# Create existing API router
-router = APIRouter()
-
-@router.get("/items")
-async def get_items():
-    """Returns a list of items."""
-    return [
-        {"id": 1, "name": "Smartphone X", "price": 999.99},
-        {"id": 2, "name": "Laptop Y", "price": 1499.99},
-    ]
-
-app.include_router(router)
-
-# Register commands
-registry = CommandRegistry()
-
-def get_discounted_price(price: float, discount: float = 0.0) -> float:
-    """
-    Returns the price after applying a discount.
-    """
-    return price * (1 - discount / 100)
-
-registry.register_command("get_discounted_price", get_discounted_price)
-
-# Create and register MCP Proxy adapter
-adapter = MCPProxyAdapter(registry)
-adapter.register_endpoints(app)
-
-# Save MCP Proxy config
-adapter.save_config_to_file("mcp_proxy_config.json")
-```
-
-## Features
-- Universal JSON-RPC endpoint for command execution
-- Automatic OpenAPI schema generation and optimization for MCP Proxy
-- Tool metadata for AI models
-- Customizable endpoints and logging
-- Full test coverage and examples
-
-## FAQ
-
-**Q: Почему не удаётся использовать декоратор @registry.command для регистрации команд?**
-A: В последних версиях пакета декоратор @registry.command больше не поддерживается. Теперь команды регистрируются только явно, через вызов метода:
-
-```python
-registry.register_command("имя_команды", функция)
-```
-
-**Q: Почему не удаётся импортировать CommandRegistry напрямую из mcp_proxy_adapter?**
-A: Класс CommandRegistry находится в подмодуле registry. Используйте:
-
-```python
-from mcp_proxy_adapter.registry import CommandRegistry
-```
-
-**Q: Какой способ импорта MCPProxyAdapter и configure_logger?**
-A: Импортируйте их из подмодуля adapter:
-
-```python
-from mcp_proxy_adapter.adapter import MCPProxyAdapter, configure_logger
-```
-
-**Q: Как добавить свою команду?**
-A: Зарегистрируйте функцию через registry.register_command или декоратор (см. примеры выше).
-
-**Q: Как получить OpenAPI-схему?**
-A: После регистрации адаптера вызовите /openapi.json в вашем FastAPI-приложении.
-
-**Q: Какой формат запроса поддерживается?**
-A: JSON-RPC, MCP Proxy и params-only (см. раздел Supported Request Formats).
-
-## HOWTO
-
-**Как интегрировать MCP Proxy Adapter с FastAPI:**
-1. Установите пакет:
-   ```bash
-   pip install mcp-proxy-adapter
-   ```
-2. Импортируйте нужные классы:
-   ```python
-   from mcp_proxy_adapter.registry import CommandRegistry
-   from mcp_proxy_adapter.adapter import MCPProxyAdapter
-   ```
-3. Зарегистрируйте команды и настройте FastAPI:
-   ```python
-   registry = CommandRegistry()
-   registry.register_command("my_command", my_function)
-   app = FastAPI()
-   adapter = MCPProxyAdapter(registry)
-   adapter.register_endpoints(app)
-   ```
-4. (Опционально) Сохраните конфиг для MCP Proxy:
-   ```python
-   adapter.save_config_to_file("mcp_proxy_config.json")
-   ```
-
-**Как добавить поддержку кастомного логгера:**
-```python
-import logging
-from mcp_proxy_adapter.adapter import configure_logger
-logger = logging.getLogger("my_project")
-adapter_logger = configure_logger(logger)
-```
-
-**Как получить список всех команд через API:**
-Вызовите GET `/api/commands` на вашем сервере FastAPI.
-
-## License
-MIT
-
-## Documentation
-See [docs/](docs/) for detailed guides, architecture, and examples.
-
-## CI/CD & PyPI automation
-
-This project uses GitHub Actions for continuous integration and automated publishing to PyPI.
-
-- All tests are run on every push and pull request.
-- On push of a new tag (vX.Y.Z), the package is built and published to PyPI automatically.
-
-See `.github/workflows/publish.yml` for details. 

mcp_proxy_adapter-2.1.16.dist-info/RECORD

@@ -1,30 +0,0 @@
-mcp_proxy_adapter/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-mcp_proxy_adapter/adapter.py,sha256=76dkVeDuqLsJ5AhuftzLlwy2M6yr_PfNbmNfo9dXVhc,28844
-mcp_proxy_adapter/models.py,sha256=8zVWU6ly18pWozOnKQ2gsGpmTgL37-fFE_Fr1SDW-Nk,2530
-mcp_proxy_adapter/registry.py,sha256=jgC4TKaPbMbAsoxvGp2ToaOE4drD-VfZug7WJbm4IW4,15853
-mcp_proxy_adapter/schema.py,sha256=HZM0TTQTSi8ha1TEeVevdCyGZOUPoT1soB7Nex0hV50,10947
-mcp_proxy_adapter/testing_utils.py,sha256=RWjQFNSUtVkeP0qNzp6_jrT6_tub3w_052DrRmvxVk0,4243
-mcp_proxy_adapter/analyzers/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-mcp_proxy_adapter/analyzers/docstring_analyzer.py,sha256=T3FLJEo_uChShfiEKRl8GpVoHvh5HiudZkxnj4KixfA,7541
-mcp_proxy_adapter/analyzers/type_analyzer.py,sha256=6Wac7osKwF03waFSwQ8ZM0Wqn_zAP2D-I4WMEpR0hQM,5230
-mcp_proxy_adapter/dispatchers/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-mcp_proxy_adapter/dispatchers/base_dispatcher.py,sha256=S5_Xri058jAmOWeit1tedB_GMZQ9RLcNcYabA83ZF6k,2288
-mcp_proxy_adapter/dispatchers/json_rpc_dispatcher.py,sha256=HO3RY5AzCQF3UPqnOIauB7Sq9rJC9jv7h7FTM1eDR90,8054
-mcp_proxy_adapter/examples/analyze_config.py,sha256=vog7TNHDw5ZoYhQLbAvZvEoufmQwH54KJzQBJrSq5w4,4283
-mcp_proxy_adapter/examples/basic_integration.py,sha256=mtRval4VSUgTb_C2p8U_DPPSEKA08dZYKZk-bOrE4H4,4470
-mcp_proxy_adapter/examples/docstring_and_schema_example.py,sha256=wFg3Cf2Jgve0J5kFzApvFSII8JOsOGaych64hIC7FqQ,2183
-mcp_proxy_adapter/examples/extension_example.py,sha256=W5fcvPHjpDSPQnmhAWDJqZtLoUfY7h58ZzFoFXDF3Fc,2525
-mcp_proxy_adapter/examples/help_best_practices.py,sha256=ByHMDiBT9V-cHoSMr2q0PmbteKELY8mTGeJrvAxOWpY,2646
-mcp_proxy_adapter/examples/help_usage.py,sha256=pEwb8-QhiWuBPCK9cbHW-oMKxk4WMo345SHIAl-dosg,2577
-mcp_proxy_adapter/examples/mcp_proxy_client.py,sha256=z4IzFlGigVTQSb8TpcrQ_a0migsmC58LnNwc8wZmTfw,3811
-mcp_proxy_adapter/examples/openapi_server.py,sha256=HUcnv_XEEur1kLuAotHuwwAhykApVXgVj4miOgk8DYA,13229
-mcp_proxy_adapter/examples/project_structure_example.py,sha256=sswTo6FZb1F5juHa0FYG3cgvrh3wfgGfJu2bBy5tCm4,1460
-mcp_proxy_adapter/examples/testing_example.py,sha256=OxFUhGP9OXiu9eWjSpytpQ5MzoR9uww3M4jYb0_v7dc,2004
-mcp_proxy_adapter/validators/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-mcp_proxy_adapter/validators/docstring_validator.py,sha256=Onpq2iNJ1qF4ejkJJIlBkLROuSNIVALHVmXIgkCpaFI,2934
-mcp_proxy_adapter/validators/metadata_validator.py,sha256=uCrn38-VYYn89l6f5CC_GoTAHAweaOW2Z6Esro1rtGw,3155
-mcp_proxy_adapter-2.1.16.dist-info/licenses/LICENSE,sha256=OkApFEwdgMCt_mbvUI-eIwKMSTe38K3XnU2DT5ub-wI,1072
-mcp_proxy_adapter-2.1.16.dist-info/METADATA,sha256=ww2i2m0f6txplRMYCb65rU1h9tDAm-FL-4hq2ZBzlUE,8886
-mcp_proxy_adapter-2.1.16.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-mcp_proxy_adapter-2.1.16.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-2.1.16.dist-info/RECORD,,