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

examples/minimal_example/tests/test_integration.py

@@ -0,0 +1,181 @@
+"""
+Integration tests for the minimal example of MCP Proxy Adapter.
+
+These tests start a real server instance and test the API endpoints.
+"""
+
+import os
+import time
+import pytest
+import requests
+from typing import Dict, Any, Callable
+
+from conftest import ServerProcess
+
+
+class TestHelloCommandIntegration:
+    """Integration tests for the HelloCommand API."""
+
+    def test_jsonrpc_hello_default(self, server: ServerProcess, jsonrpc_client: Callable):
+        """Test the hello command via JSON-RPC with default parameters."""
+        # Make JSON-RPC request
+        response = jsonrpc_client("hello", {})
+        
+        # Check response
+        assert "jsonrpc" in response
+        assert response["jsonrpc"] == "2.0"
+        assert "id" in response
+        assert "result" in response
+        assert "message" in response["result"]
+        assert response["result"]["message"] == "Hello, World!"
+    
+    def test_jsonrpc_hello_custom_name(self, server: ServerProcess, jsonrpc_client: Callable):
+        """Test the hello command via JSON-RPC with custom name parameter."""
+        # Make JSON-RPC request
+        response = jsonrpc_client("hello", {"name": "Integration Test"})
+        
+        # Check response
+        assert "result" in response
+        assert "message" in response["result"]
+        assert response["result"]["message"] == "Hello, Integration Test!"
+    
+    def test_cmd_endpoint_hello(self, server: ServerProcess, api_url: str):
+        """Test the hello command via the /cmd endpoint."""
+        # Prepare request
+        payload = {
+            "command": "hello",
+            "params": {"name": "CMD Endpoint"}
+        }
+        
+        # Make request
+        response = requests.post(
+            f"{api_url}/cmd",
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert "result" in data
+        assert "message" in data["result"]
+        assert data["result"]["message"] == "Hello, CMD Endpoint!"
+    
+    def test_api_command_endpoint_hello(self, server: ServerProcess, api_url: str):
+        """Test the hello command via the /api/command/{command_name} endpoint."""
+        # Prepare params
+        params = {"name": "API Command Endpoint"}
+        
+        # Make request
+        response = requests.post(
+            f"{api_url}/api/command/hello",
+            json=params,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert "message" in data
+        assert data["message"] == "Hello, API Command Endpoint!"
+    
+    def test_jsonrpc_batch_request(self, server: ServerProcess, api_url: str):
+        """Test batch JSON-RPC requests with hello command."""
+        # Prepare batch request
+        batch = [
+            {
+                "jsonrpc": "2.0",
+                "method": "hello",
+                "params": {"name": "Batch 1"},
+                "id": 1
+            },
+            {
+                "jsonrpc": "2.0",
+                "method": "hello",
+                "params": {"name": "Batch 2"},
+                "id": 2
+            }
+        ]
+        
+        # Make request
+        response = requests.post(
+            f"{api_url}/api/jsonrpc",
+            json=batch,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, list)
+        assert len(data) == 2
+        
+        # Check first result
+        assert data[0]["id"] == 1
+        assert data[0]["result"]["message"] == "Hello, Batch 1!"
+        
+        # Check second result
+        assert data[1]["id"] == 2
+        assert data[1]["result"]["message"] == "Hello, Batch 2!"
+
+
+class TestServerIntegration:
+    """Integration tests for the server itself."""
+    
+    def test_health_endpoint(self, server: ServerProcess, api_url: str):
+        """Test the /health endpoint."""
+        response = requests.get(f"{api_url}/health")
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        assert "status" in data
+        assert data["status"] == "ok"
+    
+    def test_openapi_schema(self, server: ServerProcess, api_url: str):
+        """Test the OpenAPI schema endpoint."""
+        response = requests.get(f"{api_url}/openapi.json")
+        
+        # Check response
+        assert response.status_code == 200
+        schema = response.json()
+        
+        # Check schema structure
+        assert "openapi" in schema
+        assert "info" in schema
+        assert "paths" in schema
+        
+        # Проверяем наличие основных эндпоинтов
+        assert "/api/jsonrpc" in schema["paths"] or "/cmd" in schema["paths"]
+        assert "/api/commands" in schema["paths"]
+        
+    def test_docs_endpoint(self, server: ServerProcess, api_url: str):
+        """Test the Swagger UI endpoint."""
+        response = requests.get(f"{api_url}/docs")
+        
+        # Check response
+        assert response.status_code == 200
+        assert "text/html" in response.headers["Content-Type"]
+        
+        # Check if swagger UI is in the response
+        assert "swagger-ui" in response.text.lower()
+    
+    def test_commands_list_endpoint(self, server: ServerProcess, api_url: str):
+        """Test the commands list endpoint."""
+        response = requests.get(f"{api_url}/api/commands")
+        
+        # Check response
+        assert response.status_code == 200
+        data = response.json()
+        
+        # Check data structure
+        assert "commands" in data
+        assert isinstance(data["commands"], dict)  # Теперь commands это словарь, а не список
+        
+        # Check if hello command is in the list
+        assert "hello" in data["commands"]
+        
+        # Check hello command details
+        hello_cmd = data["commands"]["hello"]
+        assert "name" in hello_cmd
+        assert hello_cmd["name"] == "hello" 

examples/server.py

@@ -0,0 +1,69 @@
+"""
+Main application module.
+"""
+
+import os
+import sys
+import uvicorn
+import logging
+
+from mcp_proxy_adapter import create_app
+
+app = create_app()
+from mcp_proxy_adapter.config import config
+from mcp_proxy_adapter.core.logging import logger, setup_logging
+
+
+def main():
+    """
+    Main function to run the application.
+    """
+    # Убедимся что логирование настроено
+    logger.info("Initializing logging configuration")
+    
+    try:
+        # Получаем настройки логирования
+        log_level = config.get("logging.level", "INFO")
+        log_file = config.get("logging.file")
+        rotation_type = config.get("logging.rotation.type", "size")
+        
+        # Выводим информацию о настройках логирования
+        logger.info(f"Log level: {log_level}")
+        if log_file:
+            logger.info(f"Log file: {log_file}")
+            logger.info(f"Log rotation type: {rotation_type}")
+            
+            if rotation_type.lower() == "time":
+                when = config.get("logging.rotation.when", "D")
+                interval = config.get("logging.rotation.interval", 1)
+                logger.info(f"Log rotation: every {interval} {when}")
+            else:
+                max_bytes = config.get("logging.rotation.max_bytes", 10 * 1024 * 1024)
+                logger.info(f"Log rotation: when size reaches {max_bytes / (1024*1024):.1f} MB")
+                
+            backup_count = config.get("logging.rotation.backup_count", 5)
+            logger.info(f"Log backups: {backup_count}")
+        else:
+            logger.info("File logging is disabled")
+            
+        # Get server settings
+        host = config.get("server.host", "0.0.0.0")
+        port = config.get("server.port", 8000)
+        
+        logger.info(f"Starting server on {host}:{port}")
+        
+        # Run server
+        uvicorn.run(
+            "mcp_proxy_adapter.api.app:app",
+            host=host,
+            port=port,
+            reload=True if os.environ.get("DEBUG") else False,
+            log_level=log_level.lower()
+        )
+    except Exception as e:
+        logger.exception(f"Error during application startup: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

examples/simple_server.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Простой пример запуска сервера JSON-RPC с использованием MCP Proxy Adapter.
+
+Этот скрипт демонстрирует минимальную конфигурацию для запуска сервера JSON-RPC.
+Он создаёт экземпляр приложения FastAPI с MCP Proxy Adapter и регистрирует пользовательские команды.
+"""
+
+import os
+import argparse
+import sys
+from pathlib import Path
+import uvicorn
+
+# Добавляем родительскую директорию в PYTHONPATH для импорта mcp_proxy_adapter
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from mcp_proxy_adapter import Command, SuccessResult, create_app
+from mcp_proxy_adapter.commands.command_registry import registry
+from typing import Dict, Any, Optional
+
+
+class HelloResult(SuccessResult):
+    """Result of hello command."""
+    
+    def __init__(self, message: str):
+        """
+        Initialize result.
+        
+        Args:
+            message: Hello message
+        """
+        self.message = message
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {"message": self.message}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"}
+            },
+            "required": ["message"]
+        }
+
+
+class HelloCommand(Command):
+    """Command that returns hello message."""
+    
+    name = "hello"
+    result_class = HelloResult
+    
+    async def execute(self, name: str = "World") -> HelloResult:
+        """
+        Execute command.
+        
+        Args:
+            name: Name to greet
+            
+        Returns:
+            Hello result
+        """
+        return HelloResult(f"Hello, {name}!")
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"}
+            },
+            "additionalProperties": False
+        }
+
+
+def main():
+    """
+    Основная функция для запуска сервера.
+    """
+    parser = argparse.ArgumentParser(description="JSON-RPC Microservice Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind server")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind server")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    
+    args = parser.parse_args()
+    
+    # Регистрируем только свою пользовательскую команду
+    # встроенные команды и примеры регистрируются автоматически
+    registry.register(HelloCommand)
+    
+    # Создаем приложение FastAPI
+    app = create_app()
+    
+    # Запускаем сервер
+    uvicorn.run(
+        app,
+        host=args.host,
+        port=args.port,
+        reload=args.reload
+    )
+
+
+if __name__ == "__main__":
+    # Run the simple server example
+    # To test, open http://localhost:8000/docs in your browser
+    # or use curl:
+    # curl -X POST http://localhost:8000/api/cmd -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","method":"hello","params":{"name":"PyPI"},"id":1}'
+    main() 

examples/test_server.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Тестовый скрипт для запуска сервера JSON-RPC с использованием MCP Proxy Adapter.
+Использует только базовую команду для тестирования установки пакета.
+"""
+
+import os
+import argparse
+import sys
+import uvicorn
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Добавляем родительскую директорию в PYTHONPATH для импорта mcp_proxy_adapter
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from mcp_proxy_adapter import Command, SuccessResult, create_app, registry
+from mcp_proxy_adapter.core.logging import setup_logging
+from mcp_proxy_adapter.config import config
+
+
+class HelloResult(SuccessResult):
+    """Result of hello command."""
+    
+    def __init__(self, message: str):
+        """
+        Initialize result.
+        
+        Args:
+            message: Hello message
+        """
+        self.message = message
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation
+        """
+        return {"message": self.message}
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string"}
+            },
+            "required": ["message"]
+        }
+
+
+class HelloCommand(Command):
+    """Command that returns hello message."""
+    
+    name = "hello"
+    result_class = HelloResult
+    
+    async def execute(self, name: str = "World") -> HelloResult:
+        """
+        Execute command.
+        
+        Args:
+            name: Name to greet
+            
+        Returns:
+            Hello result
+        """
+        return HelloResult(f"Hello, {name}!")
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters.
+        
+        Returns:
+            JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"}
+            },
+            "additionalProperties": False
+        }
+
+
+def main():
+    """
+    Основная функция для запуска сервера.
+    """
+    parser = argparse.ArgumentParser(description="Test JSON-RPC Microservice Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind server")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind server")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    parser.add_argument("--config", help="Path to config file")
+    
+    args = parser.parse_args()
+    
+    # Инициализируем конфигурацию
+    if args.config and os.path.exists(args.config):
+        config.load_from_file(args.config)
+    
+    # Настраиваем логирование
+    setup_logging("INFO")
+    
+    # Создаем приложение FastAPI
+    app = create_app()
+    app.title = "Test Microservice"
+    app.description = "Test microservice for package installation verification"
+    app.version = "1.0.0"
+    
+    # Регистрируем только одну команду для тестирования
+    registry.register(HelloCommand)
+    
+    # Запускаем сервер
+    uvicorn.run(
+        app,
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        log_level="info"
+    )
+
+
+if __name__ == "__main__":
+    main() 

examples/tool_description_example.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+"""
+Example of using the API tool description functionality.
+
+This script demonstrates how to use the API tool description functionality
+to generate rich and informative descriptions for API tools.
+"""
+
+import json
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the project root to the Python path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.api.schemas import APIToolDescription
+from mcp_proxy_adapter.api.tools import get_tool_description, TSTCommandExecutor
+from mcp_proxy_adapter.commands.help_command import HelpCommand
+
+
+async def main():
+    """Main function to demonstrate API tool description functionality."""
+    
+    # Register the help command so we have at least one command registered
+    if not registry.command_exists("help"):
+        registry.register(HelpCommand)
+    
+    # Generate description using the APIToolDescription class directly
+    print("Generating tool description using APIToolDescription:")
+    description = APIToolDescription.generate_tool_description("tst_execute_command", registry)
+    print(json.dumps(description, indent=2, ensure_ascii=False))
+    print("\n" + "-" * 80 + "\n")
+    
+    # Generate text description using the APIToolDescription class
+    print("Generating tool description text using APIToolDescription:")
+    description_text = APIToolDescription.generate_tool_description_text("tst_execute_command", registry)
+    print(description_text)
+    print("\n" + "-" * 80 + "\n")
+    
+    # Get tool description using the tools module
+    print("Getting tool description using the tools module:")
+    tool_description = get_tool_description("tst_execute_command")
+    print(json.dumps(tool_description, indent=2, ensure_ascii=False))
+    print("\n" + "-" * 80 + "\n")
+    
+    # Get tool description in markdown format using the tools module
+    print("Getting tool description in markdown format using the tools module:")
+    tool_description_md = get_tool_description("tst_execute_command", "markdown")
+    print(tool_description_md)
+    print("\n" + "-" * 80 + "\n")
+    
+    # Get tool schema directly from the tool class
+    print("Getting tool schema directly from the tool class:")
+    tool_schema = TSTCommandExecutor.get_schema()
+    print(json.dumps(tool_schema, indent=2, ensure_ascii=False))
+    print("\n" + "-" * 80 + "\n")
+    
+    # Get tool description directly from the tool class
+    print("Getting tool description directly from the tool class:")
+    tool_desc = TSTCommandExecutor.get_description("json")
+    print(json.dumps(tool_desc, indent=2, ensure_ascii=False))
+    print("\n" + "-" * 80 + "\n")
+    
+    # Show how this can be used to create informative command-line help
+    print("Example command-line help based on tool description:")
+    help_text = f"""
+    {TSTCommandExecutor.name} - {TSTCommandExecutor.description}
+    
+    Available commands:
+    """
+    
+    for cmd_name in tool_schema["parameters"]["properties"]["command"]["enum"]:
+        cmd_info = description["supported_commands"].get(cmd_name, {})
+        help_text += f"  {cmd_name} - {cmd_info.get('summary', '')}\n"
+    
+    print(help_text)
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

mcp_proxy_adapter/__init__.py

@@ -1 +1,33 @@
- 
+"""MCP Proxy API Service package.
+
+This package provides a framework for creating JSON-RPC-enabled microservices.
+"""
+
+from mcp_proxy_adapter.version import __version__
+from mcp_proxy_adapter.api.app import create_app
+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
+from mcp_proxy_adapter.core.errors import (
+    MicroserviceError, CommandError, ValidationError, 
+    InvalidParamsError, NotFoundError, TimeoutError,
+    InternalError
+)
+
+# Экспортируем основные классы и функции для удобного использования
+__all__ = [
+    "__version__",
+    "create_app",
+    "Command",
+    "CommandResult", 
+    "SuccessResult",
+    "ErrorResult",
+    "registry",
+    "MicroserviceError",
+    "CommandError",
+    "ValidationError",
+    "InvalidParamsError",
+    "NotFoundError",
+    "TimeoutError",
+    "InternalError"
+]