mcp-proxy-adapter 6.3.28__py3-none-any.whl → 6.3.29__py3-none-any.whl

mcp_proxy_adapter/core/proxy_client.py

@@ -1,662 +1,185 @@
 """
-Proxy Client Module
-
-This module provides a client for registering with MCP proxy servers
-using mcp_security_framework for secure authentication and connections.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
-"""
-
-import asyncio
-import json
-import time
-import ssl
-from typing import Dict, Any, Optional, Tuple, List
-from urllib.parse import urljoin, urlparse
-from pathlib import Path
-
-import aiohttp
-from aiohttp import ClientTimeout, TCPConnector
-
-# Import framework components
-try:
-    from mcp_security_framework.core.client_security import ClientSecurityManager
-    from mcp_security_framework.schemas.config import ClientSecurityConfig
-    from mcp_security_framework.schemas.models import AuthResult, ValidationResult
-    from mcp_security_framework.utils.crypto_utils import (
-        generate_api_key,
-        create_jwt_token,
-    )
-    from mcp_security_framework.utils.cert_utils import validate_certificate_format
-
-    SECURITY_FRAMEWORK_AVAILABLE = True
-except ImportError:
-    SECURITY_FRAMEWORK_AVAILABLE = False
-    ClientSecurityManager = None
-    ClientSecurityConfig = None
-    AuthResult = None
-    ValidationResult = None
-
-from mcp_proxy_adapter.core.logging import logger
-
-
-class ProxyClientError(Exception):
-    """Exception raised when proxy client operations fail."""
-
-    pass
-
-
-class ProxyClient:
-    """
-    Client for registering with MCP proxy servers.
-
-    Provides secure registration, heartbeat, and discovery functionality
-    using mcp_security_framework for authentication and SSL/TLS.
-    """
-
-    def __init__(self, config: Dict[str, Any]):
-        """
-        Initialize proxy client.
-
-        Args:
-            config: Client configuration
-        """
-        self.config = config
-        # Try both registration and proxy_registration for backward compatibility
-        self.registration_config = config.get(
-            "registration", config.get("proxy_registration", {})
-        )
-
-        # Basic settings
-        self.proxy_url = self.registration_config.get(
-            "proxy_url", self.registration_config.get("server_url")
-        )
-        self.server_id = self.registration_config.get(
-            "server_id",
-            self.registration_config.get("proxy_info", {}).get(
-                "name", "mcp_proxy_adapter"
-            ),
-        )
-        self.server_name = self.registration_config.get(
-            "server_name",
-            self.registration_config.get("proxy_info", {}).get(
-                "name", "MCP Proxy Adapter"
-            ),
-        )
-        self.description = self.registration_config.get(
-            "description",
-            self.registration_config.get("proxy_info", {}).get("description", ""),
-        )
-        self.version = self.registration_config.get(
-            "version",
-            self.registration_config.get("proxy_info", {}).get("version", "1.0.0"),
-        )
-
-        # Authentication settings
-        self.auth_method = self.registration_config.get("auth_method", "none")
-        self.auth_config = self._get_auth_config()
-
-        # Heartbeat settings
-        heartbeat_config = self.registration_config.get("heartbeat", {})
-        self.heartbeat_interval = heartbeat_config.get("interval", 300)
-        self.heartbeat_timeout = heartbeat_config.get("timeout", 30)
-        self.retry_attempts = heartbeat_config.get("retry_attempts", 3)
-        self.retry_delay = heartbeat_config.get("retry_delay", 60)
-
-        # Auto discovery settings
-        discovery_config = self.registration_config.get("auto_discovery", {})
-        self.discovery_enabled = discovery_config.get("enabled", False)
-        self.discovery_urls = discovery_config.get("discovery_urls", [])
-        self.discovery_interval = discovery_config.get("discovery_interval", 3600)
-
-        # Initialize security manager
-        self.security_manager = self._create_security_manager()
-
-        # State
-        self.registered = False
-        self.server_key: Optional[str] = None
-        self.server_url: Optional[str] = None
-        self.heartbeat_task: Optional[asyncio.Task] = None
-        self.discovery_task: Optional[asyncio.Task] = None
-
-        logger.info("Proxy client initialized with security framework integration")
-
-    def _get_auth_config(self) -> Dict[str, Any]:
-        """Get authentication configuration based on auth method."""
-        if self.auth_method == "certificate":
-            return self.registration_config.get("certificate", {})
-        elif self.auth_method == "token":
-            return self.registration_config.get("token", {})
-        elif self.auth_method == "api_key":
-            return self.registration_config.get("api_key", {})
-        else:
-            return {}
-
-    def _create_security_manager(self) -> Optional[ClientSecurityManager]:
-        """Create client security manager."""
-        if not SECURITY_FRAMEWORK_AVAILABLE:
-            logger.warning("mcp_security_framework not available, using basic client")
-            return None
-
-        try:
-            # Create client security configuration
-            client_security_config = self.registration_config.get("client_security", {})
-
-            if not client_security_config.get("enabled", False):
-                logger.info("Client security disabled in configuration")
-                return None
 
-            # Create security config
-            security_config = {
-                "security": {
-                    "ssl": {
-                        "enabled": client_security_config.get("ssl_enabled", False),
-                        "client_cert_file": client_security_config.get(
-                            "certificate_auth", {}
-                        ).get("cert_file"),
-                        "client_key_file": client_security_config.get(
-                            "certificate_auth", {}
-                        ).get("key_file"),
-                        "ca_cert_file": client_security_config.get(
-                            "certificate_auth", {}
-                        ).get("ca_cert_file"),
-                        "verify_mode": "CERT_REQUIRED",
-                        "min_tls_version": "TLSv1.2",
-                        "check_hostname": True,
-                        "check_expiry": True,
-                    },
-                    "auth": {
-                        "enabled": True,
-                        "methods": client_security_config.get(
-                            "auth_methods", ["api_key"]
-                        ),
-                        "api_keys": {
-                            client_security_config.get("api_key_auth", {}).get(
-                                "key", "default"
-                            ): {
-                                "roles": ["proxy_client"],
-                                "permissions": ["register", "heartbeat", "discover"],
-                            }
-                        },
-                    },
-                }
-            }
+Core mTLS Proxy Client.
 
-            return ClientSecurityManager(security_config)
+Provides an asynchronous client for communicating with a proxy-like server over
+mutual TLS. Designed to be used by services built on this framework to:
+- perform health/heartbeat checks
+- register themselves with the proxy
 
-        except Exception as e:
-            logger.error(f"Failed to create security manager: {e}")
-            return None
-
-    def set_server_url(self, server_url: str) -> None:
-        """
-        Set the server URL for registration.
-
-        Args:
-            server_url: The URL where this server is accessible.
-        """
-        self.server_url = server_url
-        logger.info(f"Proxy client server URL set to: {server_url}")
-
-    def _get_auth_headers(self) -> Dict[str, str]:
-        """
-        Get authentication headers for requests.
-
-        Returns:
-            Dictionary of authentication headers
-        """
-        headers = {"Content-Type": "application/json"}
-
-        if not self.security_manager:
-            return headers
-
-        try:
-            if self.auth_method == "certificate":
-                return self.security_manager.get_client_auth_headers("certificate")
-            elif self.auth_method == "token":
-                token = self.auth_config.get("token")
-                return self.security_manager.get_client_auth_headers("jwt", token=token)
-            elif self.auth_method == "api_key":
-                api_key = self.auth_config.get("key")
-                return self.security_manager.get_client_auth_headers(
-                    "api_key", api_key=api_key
-                )
-            else:
-                return headers
-        except Exception as e:
-            logger.error(f"Failed to get auth headers: {e}")
-            return headers
-
-    def _create_ssl_context(self) -> Optional[ssl.SSLContext]:
-        """
-        Create SSL context for secure connections.
+This client intentionally avoids framework-specific configuration objects and
+accepts explicit parameters for clarity and portability.
+"""
+from __future__ import annotations
 
-        Returns:
-            SSL context or None if SSL not needed
-        """
-        if not self.security_manager:
-            return None
+import json
+import ssl
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple
+from urllib.parse import urljoin
 
-        try:
-            return self.security_manager.create_client_ssl_context()
-        except Exception as e:
-            logger.error(f"Failed to create SSL context: {e}")
-            return None
+import aiohttp  # type: ignore[import]
 
-    async def register(self) -> bool:
-        """
-        Register with the proxy server.
 
-        Returns:
-            True if registration was successful, False otherwise.
-        """
-        if not self.proxy_url:
-            logger.error("Proxy URL not configured")
-            return False
+@dataclass(frozen=True)
+class RegistrationRequest:
+    """Data payload for registration calls to the proxy server."""
 
-        if not self.server_url:
-            logger.error("Server URL not set")
-            return False
+    server_id: str
+    server_name: str
+    description: Optional[str] = None
+    extra: Optional[Dict[str, Any]] = None
 
-        # Prepare registration data
-        proxy_info = self.registration_config.get("proxy_info", {})
-        registration_data = {
+    def to_dict(self) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
             "server_id": self.server_id,
-            "server_url": self.server_url,
             "server_name": self.server_name,
-            "description": self.description,
-            "version": self.version,
-            "capabilities": proxy_info.get("capabilities", ["jsonrpc", "rest"]),
-            "endpoints": proxy_info.get(
-                "endpoints",
-                {"jsonrpc": "/api/jsonrpc", "rest": "/cmd", "health": "/health"},
-            ),
-            "auth_method": self.auth_method,
-            "security_enabled": self.security_manager is not None,
         }
+        if self.description is not None:
+            payload["description"] = self.description
+        if self.extra:
+            payload.update(self.extra)
+        return payload
 
-        logger.info(f"Attempting to register with proxy at {self.proxy_url}")
-        logger.debug(f"Registration data: {registration_data}")
-
-        for attempt in range(self.retry_attempts):
-            try:
-                success, result = await self._make_request(
-                    "/register", registration_data
-                )
-
-                if success:
-                    self.registered = True
-                    self.server_key = result.get("server_key")
-                    logger.info(
-                        f"✅ Successfully registered with proxy. Server key: {self.server_key}"
-                    )
-
-                    # Start heartbeat and discovery
-                    await self._start_background_tasks()
-
-                    return True
-                else:
-                    error_msg = result.get("error", {}).get("message", "Unknown error")
-                    logger.warning(
-                        f"❌ Registration attempt {attempt + 1} failed: {error_msg}"
-                    )
-
-                    if attempt < self.retry_attempts - 1:
-                        logger.info(f"Retrying in {self.retry_delay} seconds...")
-                        await asyncio.sleep(self.retry_delay)
 
-            except Exception as e:
-                logger.error(
-                    f"❌ Registration attempt {attempt + 1} failed with exception: {e}"
-                )
-
-                if attempt < self.retry_attempts - 1:
-                    logger.info(f"Retrying in {self.retry_delay} seconds...")
-                    await asyncio.sleep(self.retry_delay)
-
-        logger.error(
-            f"❌ Failed to register with proxy after {self.retry_attempts} attempts"
-        )
-        return False
-
-    async def unregister(self) -> bool:
-        """
-        Unregister from the proxy server.
-
-        Returns:
-            True if unregistration was successful, False otherwise.
-        """
-        if not self.registered or not self.server_key:
-            logger.info("Not registered with proxy, skipping unregistration")
-            return True
-
-        # Stop background tasks
-        await self._stop_background_tasks()
-
-        # Extract copy_number from server_key
-        try:
-            copy_number = int(self.server_key.split("_")[-1])
-        except (ValueError, IndexError):
-            copy_number = 1
-
-        unregistration_data = {"server_id": self.server_id, "copy_number": copy_number}
-
-        logger.info(f"Attempting to unregister from proxy at {self.proxy_url}")
-
-        try:
-            success, result = await self._make_request(
-                "/unregister", unregistration_data
+class ProxyClient:
+    """Asynchronous mTLS HTTP client for communicating with a proxy server.
+
+    Usage:
+        async with ProxyClient(
+            base_url="https://127.0.0.1:3004",
+            ca_cert_path="/path/to/ca.crt",
+            client_cert_path="/path/to/client.crt",
+            client_key_path="/path/to/client.key",
+        ) as client:
+            status, health = await client.health()
+            status, hb = await client.heartbeat()
+            status, reg = await client.register(
+                RegistrationRequest(...)
             )
+    """
 
-            if success:
-                unregistered = result.get("unregistered", False)
-                if unregistered:
-                    logger.info("✅ Successfully unregistered from proxy")
-                else:
-                    logger.warning("⚠️ Server was not found in proxy registry")
-
-                self.registered = False
-                self.server_key = None
-                return True
-            else:
-                error_msg = result.get("error", {}).get("message", "Unknown error")
-                logger.error(f"❌ Failed to unregister from proxy: {error_msg}")
-                return False
-
-        except Exception as e:
-            logger.error(f"❌ Unregistration failed with exception: {e}")
-            return False
-
-    async def send_heartbeat(self) -> bool:
-        """
-        Send heartbeat to proxy server.
-
-        Returns:
-            True if heartbeat was successful, False otherwise.
-        """
-        if not self.server_key:
-            return False
-
-        heartbeat_data = {
-            "server_id": self.server_id,
-            "server_key": self.server_key,
-            "timestamp": int(time.time()),
-            "status": "healthy",
-        }
-
-        try:
-            success, result = await self._make_request("/heartbeat", heartbeat_data)
-
-            if success:
-                logger.debug("Heartbeat sent successfully")
-                return True
-            else:
-                logger.warning(
-                    f"Heartbeat failed: {result.get('error', {}).get('message', 'Unknown error')}"
-                )
-                return False
-
-        except Exception as e:
-            logger.error(f"Heartbeat error: {e}")
-            return False
-
-    async def discover_proxies(self) -> List[Dict[str, Any]]:
-        """
-        Discover available proxy servers.
-
-        Returns:
-            List of discovered proxy servers.
-        """
-        if not self.discovery_enabled:
-            return []
-
-        discovered_proxies = []
-
-        for discovery_url in self.discovery_urls:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        ca_cert_path: str,
+        client_cert_path: str,
+        client_key_path: str,
+        request_timeout_s: float = 5.0,
+        min_tls_version: ssl.TLSVersion = ssl.TLSVersion.TLSv1_2,
+        verify_mode: ssl.VerifyMode = ssl.CERT_REQUIRED,
+    ) -> None:
+        if not base_url.startswith("http"):
+            raise ValueError("base_url must start with http/https")
+        self._base_url: str = base_url.rstrip("/")
+        self._ca_cert_path: str = ca_cert_path
+        self._client_cert_path: str = client_cert_path
+        self._client_key_path: str = client_key_path
+        self._request_timeout_s: float = request_timeout_s
+        self._min_tls_version: ssl.TLSVersion = min_tls_version
+        self._verify_mode: ssl.VerifyMode = verify_mode
+
+        self._ssl_context: Optional[ssl.SSLContext] = None
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    async def __aenter__(self) -> "ProxyClient":
+        await self._ensure_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.close()
+
+    async def _ensure_session(self) -> None:
+        if self._session is not None:
+            return
+        ssl_context = self._build_ssl_context()
+        timeout = aiohttp.ClientTimeout(total=self._request_timeout_s)
+        connector = aiohttp.TCPConnector(ssl=ssl_context)
+        self._session = aiohttp.ClientSession(
+            timeout=timeout,
+            connector=connector,
+        )
+        self._ssl_context = ssl_context
+
+    async def close(self) -> None:
+        if self._session is not None:
+            await self._session.close()
+        self._session = None
+        self._ssl_context = None
+
+    def _build_ssl_context(self) -> ssl.SSLContext:
+        ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        ctx.minimum_version = self._min_tls_version
+        ctx.verify_mode = self._verify_mode
+        ctx.load_verify_locations(self._ca_cert_path)
+        ctx.load_cert_chain(self._client_cert_path, self._client_key_path)
+        return ctx
+
+    async def _get_json(self, path: str) -> Tuple[int, Dict[str, Any]]:
+        await self._ensure_session()
+        assert self._session is not None
+        url = urljoin(self._base_url + "/", path.lstrip("/"))
+        async with self._session.get(url) as resp:
+            status = resp.status
+            body_text = await resp.text()
             try:
-                success, result = await self._make_request(
-                    "/discover", {}, base_url=discovery_url
+                data: Dict[str, Any] = (
+                    json.loads(body_text) if body_text else {}
                 )
-
-                if success:
-                    proxies = result.get("proxies", [])
-                    discovered_proxies.extend(proxies)
-                    logger.info(
-                        f"Discovered {len(proxies)} proxies from {discovery_url}"
-                    )
-                else:
-                    logger.warning(f"Discovery failed for {discovery_url}")
-
-            except Exception as e:
-                logger.error(f"Discovery error for {discovery_url}: {e}")
-
-        return discovered_proxies
-
-    async def _make_request(
-        self, endpoint: str, data: Dict[str, Any], base_url: Optional[str] = None
-    ) -> Tuple[bool, Dict[str, Any]]:
-        """
-        Make HTTP request to proxy server.
-
-        Args:
-            endpoint: API endpoint
-            data: Request data
-            base_url: Base URL (optional, uses self.proxy_url if not provided)
-
-        Returns:
-            Tuple of (success, result)
-        """
-        url = urljoin(base_url or self.proxy_url, endpoint)
-
-        # Get authentication headers
-        headers = self._get_auth_headers()
-
-        # Create SSL context if needed
-        ssl_context = self._create_ssl_context()
-
-        # Create connector with SSL context
-        connector = None
-        if ssl_context:
-            connector = TCPConnector(ssl=ssl_context)
-
-        try:
-            timeout = ClientTimeout(total=self.heartbeat_timeout)
-
-            async with aiohttp.ClientSession(connector=connector) as session:
-                async with session.post(
-                    url, json=data, headers=headers, timeout=timeout
-                ) as response:
-                    result = await response.json()
-
-                    # Validate response if security manager available
-                    if self.security_manager:
-                        self.security_manager.validate_server_response(
-                            dict(response.headers)
-                        )
-
-                    return response.status == 200, result
-        except Exception as e:
-            logger.error(f"Request failed: {e}")
-            return False, {"error": {"message": str(e)}}
-        finally:
-            if connector:
-                await connector.close()
-
-    async def _start_background_tasks(self) -> None:
-        """Start heartbeat and discovery background tasks."""
-        # Start heartbeat
-        if self.registration_config.get("heartbeat", {}).get("enabled", True):
-            self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
-            logger.info("Heartbeat task started")
-
-        # Start discovery
-        if self.discovery_enabled:
-            self.discovery_task = asyncio.create_task(self._discovery_loop())
-            logger.info("Discovery task started")
-
-    async def _stop_background_tasks(self) -> None:
-        """Stop background tasks."""
-        # Stop heartbeat
-        if self.heartbeat_task and not self.heartbeat_task.done():
-            self.heartbeat_task.cancel()
-            try:
-                await self.heartbeat_task
-            except asyncio.CancelledError:
-                pass
-            logger.info("Heartbeat task stopped")
-
-        # Stop discovery
-        if self.discovery_task and not self.discovery_task.done():
-            self.discovery_task.cancel()
-            try:
-                await self.discovery_task
-            except asyncio.CancelledError:
-                pass
-            logger.info("Discovery task stopped")
-
-    async def _heartbeat_loop(self) -> None:
-        """Heartbeat loop to keep registration alive."""
-        while self.registered:
-            try:
-                await asyncio.sleep(self.heartbeat_interval)
-
-                if not self.registered:
-                    break
-
-                # Send heartbeat
-                success = await self.send_heartbeat()
-                if not success:
-                    logger.warning("Heartbeat failed, attempting to re-register")
-                    await self.register()
-
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.error(f"Heartbeat error: {e}")
-
-    async def _discovery_loop(self) -> None:
-        """Discovery loop to find new proxy servers."""
-        while self.registered:
+            except json.JSONDecodeError:
+                data = {"raw": body_text}
+            return status, data
+
+    async def _post_json(
+        self,
+        path: str,
+        payload: Dict[str, Any],
+    ) -> Tuple[int, Dict[str, Any]]:
+        await self._ensure_session()
+        assert self._session is not None
+        url = urljoin(self._base_url + "/", path.lstrip("/"))
+        headers = {"Content-Type": "application/json"}
+        async with self._session.post(
+            url,
+            headers=headers,
+            json=payload,
+        ) as resp:
+            status = resp.status
+            body_text = await resp.text()
             try:
-                await asyncio.sleep(self.discovery_interval)
-
-                if not self.registered:
-                    break
-
-                # Discover proxies
-                proxies = await self.discover_proxies()
-                if proxies:
-                    logger.info(f"Discovered {len(proxies)} proxy servers")
-
-                    # Register with new proxies if configured
-                    if self.registration_config.get("auto_discovery", {}).get(
-                        "register_on_discovery", False
-                    ):
-                        for proxy in proxies:
-                            proxy_url = proxy.get("url")
-                            if proxy_url and proxy_url != self.proxy_url:
-                                logger.info(
-                                    f"Attempting to register with discovered proxy: {proxy_url}"
-                                )
-                                # Store original URL and try to register with new proxy
-                                original_url = self.proxy_url
-                                self.proxy_url = proxy_url
-                                await self.register()
-                                self.proxy_url = original_url
-
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.error(f"Discovery error: {e}")
-
-    def get_status(self) -> Dict[str, Any]:
-        """
-        Get current client status.
-
-        Returns:
-            Dictionary with client status information.
-        """
-        status = {
-            "enabled": self.registration_config.get("enabled", False),
-            "registered": self.registered,
-            "server_key": self.server_key,
-            "server_url": self.server_url,
-            "proxy_url": self.proxy_url,
-            "server_id": self.server_id,
-            "auth_method": self.auth_method,
-            "heartbeat_active": self.heartbeat_task is not None
-            and not self.heartbeat_task.done(),
-            "discovery_active": self.discovery_task is not None
-            and not self.discovery_task.done(),
-        }
-
-        # Add security information
-        if self.security_manager:
-            status["security_enabled"] = True
-            status["ssl_enabled"] = self.security_manager.is_ssl_enabled()
-            status["auth_methods"] = self.security_manager.get_supported_auth_methods()
-        else:
-            status["security_enabled"] = False
-
-        return status
-
-
-# Global proxy client instance
-proxy_client: Optional[ProxyClient] = None
-
-
-def initialize_proxy_client(config: Dict[str, Any]) -> None:
-    """
-    Initialize global proxy client.
-
-    Args:
-        config: Application configuration
-    """
-    global proxy_client
-    proxy_client = ProxyClient(config)
-
-
-async def register_with_proxy(server_url: str) -> bool:
-    """
-    Register with proxy server.
-
-    Args:
-        server_url: The URL where this server is accessible.
-
-    Returns:
-        True if registration was successful, False otherwise.
-    """
-    if not proxy_client:
-        logger.error("Proxy client not initialized")
-        return False
-
-    proxy_client.set_server_url(server_url)
-    return await proxy_client.register()
-
-
-async def unregister_from_proxy() -> bool:
-    """
-    Unregister from proxy server.
-
-    Returns:
-        True if unregistration was successful, False otherwise.
-    """
-    if not proxy_client:
-        logger.error("Proxy client not initialized")
-        return False
-
-    return await proxy_client.unregister()
-
-
-def get_proxy_client_status() -> Dict[str, Any]:
-    """
-    Get proxy client status.
-
-    Returns:
-        Dictionary with client status information.
-    """
-    if not proxy_client:
-        return {"error": "Proxy client not initialized"}
-
-    return proxy_client.get_status()
+                data: Dict[str, Any] = (
+                    json.loads(body_text) if body_text else {}
+                )
+            except json.JSONDecodeError:
+                data = {"raw": body_text}
+            return status, data
+
+    async def health(
+        self,
+        path: str = "/health",
+    ) -> Tuple[int, Dict[str, Any]]:
+        """Perform a health check against the proxy."""
+        return await self._get_json(path)
+
+    async def heartbeat(
+        self,
+        path: str = "/heartbeat",
+    ) -> Tuple[int, Dict[str, Any]]:
+        """Perform a heartbeat (liveness) check against the proxy."""
+        return await self._get_json(path)
+
+    async def register(
+        self,
+        request: RegistrationRequest,
+        *,
+        path: str = "/register",
+    ) -> Tuple[int, Dict[str, Any]]:
+        """Register the current service on the proxy server."""
+        payload = request.to_dict()
+        return await self._post_json(
+            path,
+            payload,
+        )