mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.29__py3-none-any.whl

mcp_proxy_adapter/examples/bugfix_certificate_config.py

@@ -89,31 +89,8 @@ class FixedCertificateConfig(BaseModel):
 
     @field_validator("hash_algorithm")
     @classmethod
-    def validate_hash_algorithm(cls, v):
-        """Validate hash algorithm."""
-        valid_algorithms = ["sha1", "sha256", "sha384", "sha512"]
-        if v not in valid_algorithms:
-            raise ValueError(
-                f"Invalid hash algorithm. Must be one of: {valid_algorithms}"
-            )
-        return v
 
     @model_validator(mode="after")
-    def validate_certificate_configuration(self):
-        """Validate certificate configuration consistency."""
-        if self.enabled:
-            # BUGFIX: Only require CA paths if not in CA creation mode
-            if not self.ca_creation_mode:
-                if not self.ca_cert_path or not self.ca_key_path:
-                    raise ValueError(
-                        "Certificate management enabled but CA certificate and key paths are required. "
-                        "Set ca_creation_mode=True if you are creating a CA certificate."
-                    )
-
-        if self.crl_enabled and not self.crl_path:
-            raise ValueError("CRL enabled but CRL path is required")
-
-        return self
 
 
 def create_patch_file():

mcp_proxy_adapter/examples/check_config.py

@@ -12,13 +12,11 @@ import json
 import sys
 import os
 from pathlib import Path
-from typing import Dict, Any, List, Optional
 
 # Add the project root to the path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
 from mcp_proxy_adapter.config import Config
-from mcp_proxy_adapter.examples.config_builder import ConfigBuilder, Protocol, AuthMethod
 
 
 class ConfigChecker:

mcp_proxy_adapter/examples/client_usage_example.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Example of using JsonRpcClient library for MCP Proxy Adapter.
+
+This example demonstrates:
+- Basic client initialization
+- Using built-in commands (echo, help, long_task, job_status)
+- Using queue management commands (queue_add_job, queue_start_job, etc.)
+- Error handling
+
+Usage:
+    # Make sure server is running, then:
+    python -m mcp_proxy_adapter.examples.client_usage_example
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+
+from mcp_proxy_adapter.client.jsonrpc_client import JsonRpcClient
+
+
+def example_builtin_commands(client: JsonRpcClient) -> None:
+    """Example of using built-in commands."""
+    print("\n" + "=" * 60)
+    print("📋 Example: Built-in Commands")
+    print("=" * 60)
+
+    # Echo command
+    print("\n1. Echo command:")
+    result = client.echo(message="Hello from client!")
+    print(f"   Result: {json.dumps(result, ensure_ascii=False, indent=2)}")
+
+    # Help command
+    print("\n2. Help command:")
+    result = client.help()
+    print(f"   Commands available: {len(result.get('data', {}).get('commands', []))}")
+
+    # Long task
+    print("\n3. Starting long task (5 seconds):")
+    result = client.long_task(seconds=5)
+    job_id = result.get("data", {}).get("job_id")
+    print(f"   Job ID: {job_id}")
+
+    # Check job status
+    print("\n4. Checking job status:")
+    time.sleep(2)
+    result = client.job_status(job_id=job_id)
+    print(f"   Status: {json.dumps(result, ensure_ascii=False, indent=2)}")
+
+    # Wait for completion
+    print("\n5. Waiting for task completion...")
+    time.sleep(4)
+    result = client.job_status(job_id=job_id)
+    status = result.get("data", {}).get("status")
+    print(f"   Final status: {status}")
+
+
+def example_queue_commands(client: JsonRpcClient) -> None:
+    """Example of using queue management commands."""
+    print("\n" + "=" * 60)
+    print("📋 Example: Queue Management Commands")
+    print("=" * 60)
+
+    job_id = f"example-{uuid.uuid4().hex[:8]}"
+
+    # Queue health
+    print("\n1. Queue health:")
+    try:
+        result = client.queue_health()
+        print(f"   Result: {json.dumps(result, ensure_ascii=False, indent=2)}")
+    except RuntimeError as e:
+        print(f"   ⚠️  Queue commands not available: {e}")
+        return
+
+    # Add job
+    print(f"\n2. Adding job (job_id={job_id}):")
+    result = client.queue_add_job(
+        job_type="long_running",
+        job_id=job_id,
+        params={"duration": 5, "task_type": "example_task"},
+    )
+    print(f"   Result: {json.dumps(result, ensure_ascii=False, indent=2)}")
+
+    # Get job status (should be pending)
+    print("\n3. Getting job status (should be pending):")
+    result = client.queue_get_job_status(job_id=job_id)
+    print(f"   Status: {json.dumps(result, ensure_ascii=False, indent=2)}")
+
+    # List jobs
+    print("\n4. Listing all jobs:")
+    result = client.queue_list_jobs()
+    print(f"   Jobs count: {len(result.get('data', {}).get('jobs', []))}")
+
+    # Start job
+    print("\n5. Starting job:")
+    result = client.queue_start_job(job_id=job_id)
+    print(f"   Result: {json.dumps(result, ensure_ascii=False, indent=2)}")
+
+    # Check status (should be running)
+    print("\n6. Checking status (should be running):")
+    time.sleep(1)
+    result = client.queue_get_job_status(job_id=job_id)
+    print(f"   Status: {json.dumps(result, ensure_ascii=False, indent=2)}")
+
+    # Wait for completion
+    print("\n7. Waiting for job completion...")
+    time.sleep(6)
+    result = client.queue_get_job_status(job_id=job_id)
+    status = result.get("data", {}).get("status")
+    print(f"   Final status: {status}")
+
+    # Delete job
+    print("\n8. Deleting job:")
+    result = client.queue_delete_job(job_id=job_id)
+    print(f"   Result: {json.dumps(result, ensure_ascii=False, indent=2)}")
+
+
+def main() -> None:
+    """Main example function."""
+    print("🚀 JsonRpcClient Usage Example")
+    print("=" * 60)
+
+    # Initialize client (adjust protocol, host, port as needed)
+    client = JsonRpcClient(
+        protocol="http",
+        host="127.0.0.1",
+        port=8080,
+    )
+
+    # Check server health
+    print("\n📡 Checking server health...")
+    try:
+        health = client.health()
+        print(f"✅ Server is healthy: {json.dumps(health, ensure_ascii=False)}")
+    except Exception as e:
+        print(f"❌ Server is not available: {e}")
+        print("   Make sure the server is running on http://127.0.0.1:8080")
+        return
+
+    # Run examples
+    try:
+        example_builtin_commands(client)
+    except Exception as e:
+        print(f"\n❌ Error in built-in commands example: {e}")
+
+    try:
+        example_queue_commands(client)
+    except Exception as e:
+        print(f"\n❌ Error in queue commands example: {e}")
+
+    print("\n" + "=" * 60)
+    print("✅ Examples completed")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()
+

mcp_proxy_adapter/examples/config_builder.py

@@ -67,7 +67,8 @@ def generate_complete_config(host: str = "0.0.0.0", port: int = 8000) -> Dict[st
         },
         "proxy_registration": {
             "enabled": False,
-            "proxy_url": "http://localhost:3004",
+            "protocol": "mtls",
+            "proxy_url": "https://172.28.0.10:3004",
             "server_id": "mcp_proxy_adapter",
             "server_name": "MCP Proxy Adapter",
             "description": "JSON-RPC API for interacting with MCP Proxy",
@@ -76,7 +77,17 @@ def generate_complete_config(host: str = "0.0.0.0", port: int = 8000) -> Dict[st
             "retry_attempts": 3,
             "retry_delay": 5,
             "auto_register_on_startup": True,
-            "auto_unregister_on_shutdown": True
+            "auto_unregister_on_shutdown": True,
+            "verify_ssl": True,
+            "verify_hostname": False,
+            "heartbeat": {
+                "enabled": True,
+                "interval": 30,
+                "timeout": 10,
+                "retry_attempts": 3,
+                "retry_delay": 5,
+                "url": "/heartbeat"
+            }
         },
         "debug": {
             "enabled": False,

mcp_proxy_adapter/examples/config_cli.py

@@ -10,7 +10,6 @@ import argparse
 import json
 import sys
 from pathlib import Path
-from typing import Dict, Any, List, Optional
 
 from config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
 

mcp_proxy_adapter/examples/create_test_configs.py

@@ -6,9 +6,7 @@ Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
 import json
-import uuid
 from pathlib import Path
-from typing import Dict, Any, Optional
 
 from config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
 
@@ -158,50 +156,6 @@ class TestConfigGenerator:
             json.dump(roles_config, f, indent=2, ensure_ascii=False)
         print(f"✅ Created roles.json: {roles_path}")
 
-    def create_custom_config(self, name: str, protocol: str, auth: str = "none", 
-                           port: int = 8000, **kwargs) -> Path:
-        """
-        Create a custom configuration.
-        
-        Args:
-            name: Configuration name
-            protocol: Protocol (http, https, mtls)
-            auth: Authentication method (none, token, basic)
-            port: Server port
-            **kwargs: Additional configuration parameters
-            
-        Returns:
-            Path to created configuration file
-        """
-        builder = ConfigBuilder()
-        
-        # Set basic server configuration
-        builder.set_server(port=port, **kwargs.get('server', {}))
-        
-        # Set protocol
-        protocol_enum = Protocol(protocol.lower())
-        cert_dir = kwargs.get('cert_dir', str(self.output_dir.parent / "certs"))
-        key_dir = kwargs.get('key_dir', str(self.output_dir.parent / "keys"))
-        builder.set_protocol(protocol_enum, cert_dir=cert_dir, key_dir=key_dir)
-        
-        # Set authentication
-        auth_enum = AuthMethod(auth.lower())
-        api_keys = kwargs.get('api_keys')
-        roles = kwargs.get('roles')
-        builder.set_auth(auth_enum, api_keys=api_keys, roles=roles)
-        
-        # Set proxy registration if specified
-        if kwargs.get('proxy_registration', False):
-            proxy_url = kwargs.get('proxy_url', 'https://127.0.0.1:20005')
-            server_id = kwargs.get('server_id', f'{name}_server')
-            builder.set_proxy_registration(enabled=True, proxy_url=proxy_url, server_id=server_id, cert_dir=cert_dir)
-        
-        # Set debug if specified
-        if kwargs.get('debug', False):
-            builder.set_debug(enabled=True)
-        
-        config = builder.build()
-        return self._save_config(name, config)
 
 
 def main():

mcp_proxy_adapter/examples/debug_request_state.py

@@ -13,7 +13,6 @@ from pathlib import Path
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
-from fastapi import FastAPI, Request
 from fastapi.testclient import TestClient
 from mcp_proxy_adapter.api.app import create_app
 

mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py

@@ -5,7 +5,6 @@ Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
 
-from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
 
@@ -18,27 +17,7 @@ class CustomEchoResult(CommandResult):
         self.timestamp = timestamp
         self.echo_count = echo_count
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert result to dictionary."""
-        return {
-            "message": self.message,
-            "timestamp": self.timestamp,
-            "echo_count": self.echo_count,
-            "command_type": "custom_echo",
-        }
 
-    def get_schema(self) -> Dict[str, Any]:
-        """Get result schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "message": {"type": "string", "description": "Echoed message"},
-                "timestamp": {"type": "string", "description": "Timestamp of echo"},
-                "echo_count": {"type": "integer", "description": "Number of echoes"},
-                "command_type": {"type": "string", "description": "Command type"},
-            },
-            "required": ["message", "timestamp", "echo_count", "command_type"],
-        }
 
 
 class CustomEchoCommand(BaseCommand):
@@ -48,34 +27,8 @@ class CustomEchoCommand(BaseCommand):
         super().__init__()
         self.echo_count = 0
 
-    def get_name(self) -> str:
-        """Get command name."""
-        return "custom_echo"
 
-    def get_description(self) -> str:
-        """Get command description."""
-        return "Custom echo command with enhanced features"
 
-    def get_schema(self) -> Dict[str, Any]:
-        """Get command schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "message": {
-                    "type": "string",
-                    "description": "Message to echo",
-                    "default": "Hello from custom echo!",
-                },
-                "repeat": {
-                    "type": "integer",
-                    "description": "Number of times to repeat",
-                    "default": 1,
-                    "minimum": 1,
-                    "maximum": 10,
-                },
-            },
-            "required": ["message"],
-        }
 
     async def execute(self, params: Dict[str, Any]) -> CustomEchoResult:
         """Execute the custom echo command."""

mcp_proxy_adapter/examples/full_application/commands/dynamic_calculator_command.py

@@ -5,7 +5,6 @@ Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
 
-from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
 
@@ -18,58 +17,14 @@ class CalculatorResult(CommandResult):
         self.result = result
         self.expression = expression
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert result to dictionary."""
-        return {
-            "operation": self.operation,
-            "result": self.result,
-            "expression": self.expression,
-            "command_type": "dynamic_calculator",
-        }
 
-    def get_schema(self) -> Dict[str, Any]:
-        """Get result schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "operation": {
-                    "type": "string",
-                    "description": "Mathematical operation",
-                },
-                "result": {"type": "number", "description": "Calculation result"},
-                "expression": {"type": "string", "description": "Full expression"},
-                "command_type": {"type": "string", "description": "Command type"},
-            },
-            "required": ["operation", "result", "expression", "command_type"],
-        }
 
 
 class DynamicCalculatorCommand(BaseCommand):
     """Dynamic calculator command implementation."""
 
-    def get_name(self) -> str:
-        """Get command name."""
-        return "dynamic_calculator"
 
-    def get_description(self) -> str:
-        """Get command description."""
-        return "Dynamic calculator with basic mathematical operations"
 
-    def get_schema(self) -> Dict[str, Any]:
-        """Get command schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "operation": {
-                    "type": "string",
-                    "description": "Mathematical operation (add, subtract, multiply, divide)",
-                    "enum": ["add", "subtract", "multiply", "divide"],
-                },
-                "a": {"type": "number", "description": "First number"},
-                "b": {"type": "number", "description": "Second number"},
-            },
-            "required": ["operation", "a", "b"],
-        }
 
     async def execute(self, params: Dict[str, Any]) -> CalculatorResult:
         """Execute the calculator command."""

mcp_proxy_adapter/examples/full_application/commands/echo_command.py

@@ -14,18 +14,6 @@ class EchoCommand(BaseCommand):
         self.description = "Echo command that returns the input message"
         self.version = "1.0.0"
     
-    def get_schema(self):
-        """Get command schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "message": {
-                    "type": "string",
-                    "description": "Message to echo back"
-                }
-            },
-            "required": ["message"]
-        }
     
     async def execute(self, params: dict) -> dict:
         """Execute echo command."""

mcp_proxy_adapter/examples/full_application/commands/help_command.py

@@ -14,18 +14,6 @@ class HelpCommand(BaseCommand):
         self.description = "Get help information"
         self.version = "1.0.0"
     
-    def get_schema(self):
-        """Get command schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "command": {
-                    "type": "string",
-                    "description": "Command name to get help for (optional)"
-                }
-            },
-            "required": []
-        }
     
     async def execute(self, params: dict) -> dict:
         """Execute help command."""

mcp_proxy_adapter/examples/full_application/commands/list_command.py

@@ -14,13 +14,6 @@ class ListCommand(BaseCommand):
         self.description = "List available commands"
         self.version = "1.0.0"
     
-    def get_schema(self):
-        """Get command schema."""
-        return {
-            "type": "object",
-            "properties": {},
-            "required": []
-        }
     
     async def execute(self, params: dict) -> dict:
         """Execute list command."""

mcp_proxy_adapter/examples/full_application/hooks/__init__.py

@@ -3,5 +3,3 @@
 Application and command hooks for the full application example.
 """
 
-from .application_hooks import ApplicationHooks
-from .builtin_command_hooks import BuiltinCommandHooks

mcp_proxy_adapter/examples/full_application/hooks/application_hooks.py

@@ -6,7 +6,6 @@ email: vasilyvz@gmail.com
 """
 
 import logging
-from typing import Dict, Any, Optional
 from datetime import datetime
 
 logger = logging.getLogger(__name__)
@@ -16,73 +15,15 @@ class ApplicationHooks:
     """Application-level hooks."""
 
     @staticmethod
-    def on_startup():
-        """Hook executed on application startup."""
-        get_global_logger().info("🚀 Application startup hook executed")
-        # Initialize application-specific resources
-        get_global_logger().info("📊 Initializing application metrics")
-        get_global_logger().info("🔐 Loading security configurations")
-        get_global_logger().info("📝 Setting up logging")
 
     @staticmethod
-    def on_shutdown():
-        """Hook executed on application shutdown."""
-        get_global_logger().info("🛑 Application shutdown hook executed")
-        # Cleanup application resources
-        get_global_logger().info("🧹 Cleaning up resources")
-        get_global_logger().info("💾 Saving application state")
-        get_global_logger().info("📊 Finalizing metrics")
 
     @staticmethod
-    def before_request(request_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed before processing any request."""
-        get_global_logger().info(f"🔧 Application hook: before_request with data: {request_data}")
-        # Add request metadata
-        request_data["app_metadata"] = {
-            "request_id": f"req_{datetime.now().timestamp()}",
-            "timestamp": datetime.now().isoformat(),
-            "application": "full_application_example",
-        }
-        return request_data
 
     @staticmethod
-    def after_request(result: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed after processing any request."""
-        get_global_logger().info(f"🔧 Application hook: after_request with result: {result}")
-        # Add response metadata
-        result["app_response_metadata"] = {
-            "processed_at": datetime.now().isoformat(),
-            "application": "full_application_example",
-            "version": "1.0.0",
-        }
-        return result
 
     @staticmethod
-    def on_error(error: Exception, context: Dict[str, Any]):
-        """Hook executed when an error occurs."""
-        get_global_logger().error(f"🔧 Application hook: on_error - {error} in context: {context}")
-        # Log error details
-        get_global_logger().error(f"Error type: {type(error).__name__}")
-        get_global_logger().error(f"Error message: {str(error)}")
-        get_global_logger().error(f"Context: {context}")
 
     @staticmethod
-    def on_command_registered(command_name: str, command_info: Dict[str, Any]):
-        """Hook executed when a command is registered."""
-        get_global_logger().info(f"🔧 Application hook: on_command_registered - {command_name}")
-        get_global_logger().info(f"Command info: {command_info}")
-        # Track registered commands
-        get_global_logger().info(f"📝 Command '{command_name}' registered successfully")
 
     @staticmethod
-    def on_command_executed(command_name: str, execution_time: float, success: bool):
-        """Hook executed when a command is executed."""
-        get_global_logger().info(f"🔧 Application hook: on_command_executed - {command_name}")
-        get_global_logger().info(f"Execution time: {execution_time}s, Success: {success}")
-        # Track command execution metrics
-        if success:
-            get_global_logger().info(
-                f"✅ Command '{command_name}' executed successfully in {execution_time}s"
-            )
-        else:
-            get_global_logger().warning(f"⚠️ Command '{command_name}' failed after {execution_time}s")

mcp_proxy_adapter/examples/full_application/hooks/builtin_command_hooks.py

@@ -6,7 +6,6 @@ email: vasilyvz@gmail.com
 """
 
 import logging
-from typing import Dict, Any, Optional
 from datetime import datetime
 
 logger = logging.getLogger(__name__)
@@ -16,66 +15,13 @@ class BuiltinCommandHooks:
     """Hooks for built-in commands."""
 
     @staticmethod
-    def before_echo_command(params: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed before echo command."""
-        get_global_logger().info(f"🔧 Built-in hook: before_echo_command with params: {params}")
-        # Add timestamp to message
-        if "message" in params:
-            timestamp = datetime.now().isoformat()
-            params["message"] = f"[{timestamp}] {params['message']}"
-        return params
 
     @staticmethod
-    def after_echo_command(result: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed after echo command."""
-        get_global_logger().info(f"🔧 Built-in hook: after_echo_command with result: {result}")
-        # Add hook metadata
-        result["hook_metadata"] = {
-            "hook_type": "builtin_after_echo",
-            "timestamp": datetime.now().isoformat(),
-            "processed": True,
-        }
-        return result
 
     @staticmethod
-    def before_health_command(params: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed before health command."""
-        get_global_logger().info(f"🔧 Built-in hook: before_health_command with params: {params}")
-        # Add custom health check parameters
-        params["include_detailed_info"] = True
-        params["check_dependencies"] = True
-        return params
 
     @staticmethod
-    def after_health_command(result: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed after health command."""
-        get_global_logger().info(f"🔧 Built-in hook: after_health_command with result: {result}")
-        # Add custom health metrics
-        if "status" in result and result["status"] == "healthy":
-            result["custom_metrics"] = {
-                "uptime": "24h",
-                "memory_usage": "45%",
-                "cpu_usage": "12%",
-            }
-        return result
 
     @staticmethod
-    def before_config_command(params: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed before config command."""
-        get_global_logger().info(f"🔧 Built-in hook: before_config_command with params: {params}")
-        # Add configuration validation
-        params["validate_config"] = True
-        params["include_secrets"] = False
-        return params
 
     @staticmethod
-    def after_config_command(result: Dict[str, Any]) -> Dict[str, Any]:
-        """Hook executed after config command."""
-        get_global_logger().info(f"🔧 Built-in hook: after_config_command with result: {result}")
-        # Add configuration metadata
-        result["config_metadata"] = {
-            "last_modified": datetime.now().isoformat(),
-            "version": "1.0.0",
-            "environment": "development",
-        }
-        return result