mcp-proxy-adapter 6.7.2__py3-none-any.whl → 6.8.1__py3-none-any.whl

{mcp_proxy_adapter-6.7.2.dist-info → mcp_proxy_adapter-6.8.1.dist-info}/RECORD

@@ -2,11 +2,11 @@ mcp_proxy_adapter/__init__.py,sha256=iH0EBBsRj_cfZJpAIsgN_8tTdfefhnl6uUKHjLHhWDQ
 mcp_proxy_adapter/__main__.py,sha256=sq3tANRuTd18euamt0Bmn1sJeAyzXENZ5VvsMwbrDFA,579
 mcp_proxy_adapter/config.py,sha256=QpoPaUKcWJ-eu6HYphhIZmkc2M-p1JgpLFAgolf_l5s,20161
 mcp_proxy_adapter/custom_openapi.py,sha256=XRviX-C-ZkSKdBhORhDTdeN_1FWyEfXZADiASft3t9I,28149
-mcp_proxy_adapter/main.py,sha256=ILdGeikcZls2y9Uro0bQLi53FPSuJv_yZBio-3WD2zM,9233
+mcp_proxy_adapter/main.py,sha256=NFcSW7WaEnimRWe5zj28D0CH9otHlRZ92d2Um6XiGjE,10399
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=8BW2GJtsmlLZwL8XRvuPQimNVnKFme-0iHrLwWsvEpM,74
+mcp_proxy_adapter/version.py,sha256=-XyUUimtSI9hGbSPyEYlJ4Xr-Gug_CLJLv0ilk_TFeE,74
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_proxy_adapter/api/app.py,sha256=GGhA5X7HQPLJFxeaWHu5YUwi2ldPvPvJD2YcaL9Nbo0,37874
+mcp_proxy_adapter/api/app.py,sha256=PQ1Ch5ydJIHp3Z6gcMCzKkTsXPQAuZ9weHtQ-EXnNGY,37134
 mcp_proxy_adapter/api/handlers.py,sha256=X-hcMNVeTAu4yVkKJEChEsj2bFptUS6sLNN-Wysjkow,10011
 mcp_proxy_adapter/api/schemas.py,sha256=mevUvQnYgWQfkJAs3-vq3HalBzh6-Saa-Au1VVf0peE,12377
 mcp_proxy_adapter/api/tool_integration.py,sha256=AeUyvJVN-c3FrX5fHdagHL51saRH5d1ZKqc2YEx0rTE,10147
@@ -54,9 +54,8 @@ mcp_proxy_adapter/commands/token_management_command.py,sha256=tCVjhWqAQ3KhcwSsZU
 mcp_proxy_adapter/commands/transport_management_command.py,sha256=HEnUyL4S014jheyBwO90u9gnzk0qxBlOJdC_0Sxhq9E,4585
 mcp_proxy_adapter/commands/unload_command.py,sha256=6CUM9B9c-mNxw7uvt2vcvZSnxMySfoMT5UmDhzNXq38,4984
 mcp_proxy_adapter/core/__init__.py,sha256=3yt0CFZdsIG8Ln4bg-r4ISYzipm3ZUAxTn0twYTs9FI,867
-mcp_proxy_adapter/core/app_factory.py,sha256=Ywq-RN2o5B86nJpqImnaXNf_g366lVK1fXeIbIr49DM,21625
+mcp_proxy_adapter/core/app_factory.py,sha256=OuxUjGpOp5mOPIQ5iumBW42bxAD0H6o2HM8UICgpUvA,20492
 mcp_proxy_adapter/core/app_runner.py,sha256=n8_rBojzKUpHLN5ksiXcR8UWoBYk6Tt5OtWk-X2kVPc,11868
-mcp_proxy_adapter/core/async_proxy_registration.py,sha256=hM_ZV2YoKM8n0MakVMBd2KnYTJBh1igDeb4DYutfHnE,11387
 mcp_proxy_adapter/core/auth_validator.py,sha256=q8TNkdolvP-gM6Bvecc6nrVG9al5J31pocdwhguhTBk,19742
 mcp_proxy_adapter/core/certificate_utils.py,sha256=yeDwi-j42CxK_g-r5_ragGFY_HdSgDfTWHVUjDHF6nI,38480
 mcp_proxy_adapter/core/client.py,sha256=qIbPl8prEwK2U65kl-vGJW2_imo1E4i6HxG_VpPeWpQ,21168
@@ -70,7 +69,7 @@ mcp_proxy_adapter/core/logging.py,sha256=gNI6vfPQC7jrUtVu6NeDsmU72JPlrRRBhtJipL1
 mcp_proxy_adapter/core/mtls_asgi.py,sha256=tvk0P9024s18dcCHY9AaQIecT4ojOTv21EuQWXwooU0,5200
 mcp_proxy_adapter/core/mtls_asgi_app.py,sha256=DT_fTUH1RkvBa3ThbyCyNb-XUHyCb4DqaKA1gcZC6z4,6538
 mcp_proxy_adapter/core/mtls_proxy.py,sha256=5APlWs0ImiHGEC65W_7F-PbVO3NZ2BVSj9r14AcUtTE,6011
-mcp_proxy_adapter/core/mtls_server.py,sha256=_hj6QWuExKX2LRohYvjPGFC2qTutS7ObegpEc09QijM,10117
+mcp_proxy_adapter/core/mtls_server.py,sha256=GBNhLezDYSXFP1xcNaThEhBqZlxXUGp0q0OT2Ibb2M0,10366
 mcp_proxy_adapter/core/protocol_manager.py,sha256=iaXWsfm1XSfemz5QQBesMluc4cwf-LtuZVi9bm1uj28,14680
 mcp_proxy_adapter/core/proxy_client.py,sha256=CB6KBhV3vH2GU5nZ27VZ_xlNbYTAU_tnYFrkuK5He58,6094
 mcp_proxy_adapter/core/proxy_registration.py,sha256=QlQFHnjIN8ETWcasPDUXNMfMsU_-KdrvLTYJiDua_wI,41237
@@ -81,11 +80,11 @@ mcp_proxy_adapter/core/security_integration.py,sha256=-5I4i9so_yMjc-zuGO-7zzIsMX
 mcp_proxy_adapter/core/server_adapter.py,sha256=jz8ztIfe82N5DE3XHRYpD6CwNcJy7ksh0l8l-towHBE,9755
 mcp_proxy_adapter/core/server_engine.py,sha256=qmxdkBv-YsQsvxVVQ-_xiAyDshxtnrKBquPJoUjo2fw,9471
 mcp_proxy_adapter/core/settings.py,sha256=D6cF4R_5gJ0XFGxzXUIzeqe-_muu6HL561TAei9wwZ0,10521
-mcp_proxy_adapter/core/signal_handler.py,sha256=ryL4bLzV6ERrXPx19K4ApFGMzFI8iwlI0timj-GQ1YI,5324
+mcp_proxy_adapter/core/signal_handler.py,sha256=TwBftsPAkMNcCSrE1ZA5qKnazcCVRpt_UGQzn6ITDHQ,5327
 mcp_proxy_adapter/core/ssl_utils.py,sha256=Rjl79d5LdhDzxiMtaIRd9OFh0hTeRANItYFXk-7c5pA,9498
 mcp_proxy_adapter/core/transport_manager.py,sha256=eJbGa3gDVFUBFUzMK5KEmpbUDXOOShtzszUIEf7Jk0A,9292
 mcp_proxy_adapter/core/unified_config_adapter.py,sha256=zBGYdLDZ3G8f3Y9tmtm0Ne0UXIfEaNHR4Ik2W3ErkLc,22814
-mcp_proxy_adapter/core/utils.py,sha256=wBdDYBDWQ6zbwrnl9tykHjo0FjJVsLT_x8Bjk1lZX60,3270
+mcp_proxy_adapter/core/utils.py,sha256=StTL44fNXYcQfIwc68LTNTDgjyQ0feGCsYSBI0ly6qE,8047
 mcp_proxy_adapter/examples/__init__.py,sha256=k1F-EotAFbJ3JvK_rNgiH4bUztmxIWtYn0AfbAZ1ZGs,450
 mcp_proxy_adapter/examples/bugfix_certificate_config.py,sha256=YGBE_SI6wYZUJLWl7-fP1OWXiSH4mHJAZHApgQWvG7s,10529
 mcp_proxy_adapter/examples/cert_manager_bugfix.py,sha256=UWUwItjqHqSnOMHocsz40_3deoZE8-vdROLW9y2fEns,7259
@@ -96,7 +95,6 @@ mcp_proxy_adapter/examples/create_test_configs.py,sha256=9TrvLa4-bWLPu0SB1JXwWuC
 mcp_proxy_adapter/examples/debug_request_state.py,sha256=Z3Gy2-fWtu7KIV9OkzGDLVz7TpL_h9V_99ica40uQBU,4489
 mcp_proxy_adapter/examples/debug_role_chain.py,sha256=GLVXC2fJUwP8UJnXHchd1t-H53cjWLJI3RqTPrKmaak,8750
 mcp_proxy_adapter/examples/demo_client.py,sha256=en2Rtb70B1sQmhL-vdQ4PDpKNNl_mfll2YCFT_jFCAg,10191
-mcp_proxy_adapter/examples/generate_certificates.py,sha256=cIfTHBziGiOTy9vldAmaULD6bXBpl2a5KfB8MLIRSww,16391
 mcp_proxy_adapter/examples/generate_config.py,sha256=9zImMfIM88OQz12mE5k0_RnVV5ZmhlIKO2fRldiNCok,12709
 mcp_proxy_adapter/examples/proxy_registration_example.py,sha256=vemRhftnjbiOBCJkmtDGqlWQ8syTG0a8755GCOnaQsg,12503
 mcp_proxy_adapter/examples/required_certificates.py,sha256=YW9-V78oFiZ-FmHlGP-8FQFS569VdDVyq9hfvCv31pk,7133
@@ -117,12 +115,12 @@ mcp_proxy_adapter/examples/test_protocol_examples.py,sha256=yCZzZrJ9ICXMkF1bAMoz
 mcp_proxy_adapter/examples/universal_client.py,sha256=n1-cBPOiCipA86Zcc_mI_jMywDMZS1p3u5JT3AqTsrQ,27577
 mcp_proxy_adapter/examples/update_config_certificates.py,sha256=ObGF5oNQ9OStryUvFDXxrN-olRMKdSOrl5KSwARF7EY,4608
 mcp_proxy_adapter/examples/basic_framework/__init__.py,sha256=4aYD--R6hy9n9CUxj7Osb9HcdVUMJ6_cfpu4ujkbCwI,345
-mcp_proxy_adapter/examples/basic_framework/main.py,sha256=XdGrD_52hhCVHwqx4XmfVmd7tlfp6WE-qZ0gw05SyB0,1792
+mcp_proxy_adapter/examples/basic_framework/main.py,sha256=2bpT-zrekpzzbhOx6wOOYXYE1mejWXkT617zpSN7m70,1790
 mcp_proxy_adapter/examples/basic_framework/commands/__init__.py,sha256=_VQNLUEdsxUG-4yt9BZI_vtOxHAdGG0OUSsP6Wj-Vz4,76
 mcp_proxy_adapter/examples/basic_framework/hooks/__init__.py,sha256=IE_EIXMnkdXuakZn7wLD9kBFyfDF5lYi56ejgiBeb-A,70
 mcp_proxy_adapter/examples/commands/__init__.py,sha256=zvY_OpH_B1bVc_khrNIl6O8vqCw1FH6gGMAsJAkGWGY,170
 mcp_proxy_adapter/examples/full_application/__init__.py,sha256=xGiPYhRAzs1Fh9wA8HoowV-Gg9QMLaMZn-OamExq1TI,320
-mcp_proxy_adapter/examples/full_application/main.py,sha256=ogL3Bil_5puGnwvMh3YNOjrW76FIzzoggKEp-04HSfo,7855
+mcp_proxy_adapter/examples/full_application/main.py,sha256=ZJmXe6WU-4q-U0AKIAdDm9HNREBgWwZz26ohY511xHs,5603
 mcp_proxy_adapter/examples/full_application/proxy_endpoints.py,sha256=Kt_WAsG61HLTMkKQ1mQqjvlX9I4TcfwYq0NaRR9HKvM,6179
 mcp_proxy_adapter/examples/full_application/commands/__init__.py,sha256=yQHxVSFkAyFLUOdk42QOebUODPlQV9IbydPgF3UKsGM,217
 mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py,sha256=H7FPJmVJNWT61rPWxep06-7hsYRt8XYBUSBiwqpBurU,3096
@@ -134,8 +132,8 @@ mcp_proxy_adapter/schemas/base_schema.json,sha256=v9G9cGMd4dRhCZsOQ_FMqOi5VFyVbI
 mcp_proxy_adapter/schemas/openapi_schema.json,sha256=C3yLkwmDsvnLW9B5gnKKdBGl4zxkeU-rEmjTrNVsQU0,8405
 mcp_proxy_adapter/schemas/roles.json,sha256=pgf_ZyqKyXbfGUxvobpiLiSJz9zzxrMuoVWEkEpz3N8,764
 mcp_proxy_adapter/schemas/roles_schema.json,sha256=deHgI7L6GwfBXacOlNtDgDJelDThppClC3Ti4Eh8rJY,5659
-mcp_proxy_adapter-6.7.2.dist-info/METADATA,sha256=Xg6ENQrj-kv2GZ0TXmwW3OBxzje9tBsWKclciTZDjnE,8510
-mcp_proxy_adapter-6.7.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.7.2.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
-mcp_proxy_adapter-6.7.2.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.7.2.dist-info/RECORD,,
+mcp_proxy_adapter-6.8.1.dist-info/METADATA,sha256=UBdAIcl991nJLgTUGFiYNu73PxbGb-j6a0phDbMzreE,8510
+mcp_proxy_adapter-6.8.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.8.1.dist-info/entry_points.txt,sha256=Bf-O5Aq80n22Ayu9fI9BgidzWqwzIVaqextAddTuHZw,563
+mcp_proxy_adapter-6.8.1.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-6.8.1.dist-info/RECORD,,

mcp_proxy_adapter/core/async_proxy_registration.py

@@ -1,285 +0,0 @@
-"""
-Asynchronous proxy registration with heartbeat functionality.
-
-This module provides automatic proxy registration in a separate thread
-with continuous heartbeat monitoring and automatic re-registration on failures.
-
-Author: Vasiliy Zdanovskiy
-email: vasilyvz@gmail.com
-"""
-
-import asyncio
-import time
-import threading
-from typing import Dict, Any, Optional
-from dataclasses import dataclass
-from enum import Enum
-
-from mcp_proxy_adapter.core.logging import logger
-from mcp_proxy_adapter.core.proxy_registration import ProxyRegistrationManager
-
-
-class RegistrationState(Enum):
-    """Registration state enumeration."""
-    DISABLED = "disabled"
-    NOT_REGISTERED = "not_registered"
-    REGISTERING = "registering"
-    REGISTERED = "registered"
-    HEARTBEAT_FAILED = "heartbeat_failed"
-    ERROR = "error"
-
-
-@dataclass
-class RegistrationStatus:
-    """Registration status information."""
-    state: RegistrationState
-    server_key: Optional[str] = None
-    last_attempt: Optional[float] = None
-    last_success: Optional[float] = None
-    last_error: Optional[str] = None
-    attempt_count: int = 0
-    success_count: int = 0
-
-
-class AsyncProxyRegistrationManager:
-    """
-    Asynchronous proxy registration manager with heartbeat functionality.
-    
-    Runs registration and heartbeat in a separate thread, automatically
-    handling re-registration on failures and continuous monitoring.
-    """
-    
-    def __init__(self, config: Dict[str, Any]):
-        """
-        Initialize the async proxy registration manager.
-        
-        Args:
-            config: Application configuration
-        """
-        self.config = config
-        self.registration_manager = ProxyRegistrationManager(config)
-        self.status = RegistrationStatus(state=RegistrationState.NOT_REGISTERED)
-        self._thread: Optional[threading.Thread] = None
-        self._stop_event = threading.Event()
-        self._loop: Optional[asyncio.AbstractEventLoop] = None
-        
-        # Get heartbeat configuration
-        heartbeat_config = config.get("registration", {}).get("heartbeat", {})
-        self.heartbeat_enabled = heartbeat_config.get("enabled", True)
-        self.heartbeat_interval = heartbeat_config.get("interval", 30)
-        self.heartbeat_timeout = heartbeat_config.get("timeout", 10)
-        self.retry_attempts = heartbeat_config.get("retry_attempts", 3)
-        self.retry_delay = heartbeat_config.get("retry_delay", 5)
-        
-        logger.info(f"AsyncProxyRegistrationManager initialized: heartbeat_enabled={self.heartbeat_enabled}, interval={self.heartbeat_interval}s")
-    
-    def is_enabled(self) -> bool:
-        """Check if proxy registration is enabled."""
-        return self.registration_manager.is_enabled()
-    
-    def set_server_url(self, server_url: str):
-        """Set the server URL for registration."""
-        self.registration_manager.set_server_url(server_url)
-        logger.info(f"Server URL set for async registration: {server_url}")
-    
-    def start(self):
-        """Start the async registration and heartbeat thread."""
-        if not self.is_enabled():
-            logger.info("Proxy registration is disabled, not starting async manager")
-            self.status.state = RegistrationState.DISABLED
-            return
-        
-        if self._thread and self._thread.is_alive():
-            logger.warning("Async registration thread is already running")
-            return
-        
-        logger.info("Starting async proxy registration and heartbeat thread")
-        self._stop_event.clear()
-        self._thread = threading.Thread(target=self._run_async_loop, daemon=True)
-        self._thread.start()
-    
-    def stop(self):
-        """Stop the async registration and heartbeat thread."""
-        if not self._thread or not self._thread.is_alive():
-            return
-        
-        logger.info("Stopping async proxy registration and heartbeat thread")
-        self._stop_event.set()
-        
-        # Unregister if registered
-        if self.status.state == RegistrationState.REGISTERED:
-            try:
-                # Run unregistration in the thread's event loop
-                if self._loop and not self._loop.is_closed():
-                    future = asyncio.run_coroutine_threadsafe(
-                        self.registration_manager.unregister_server(), 
-                        self._loop
-                    )
-                    future.result(timeout=10)
-                    logger.info("Successfully unregistered from proxy during shutdown")
-            except Exception as e:
-                logger.error(f"Failed to unregister during shutdown: {e}")
-        
-        self._thread.join(timeout=5)
-        if self._thread.is_alive():
-            logger.warning("Async registration thread did not stop gracefully")
-    
-    def _run_async_loop(self):
-        """Run the async event loop in the thread."""
-        try:
-            self._loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(self._loop)
-            self._loop.run_until_complete(self._async_main())
-        except Exception as e:
-            logger.error(f"Async registration loop error: {e}")
-        finally:
-            if self._loop and not self._loop.is_closed():
-                self._loop.close()
-    
-    async def _async_main(self):
-        """Main async loop for registration and heartbeat."""
-        logger.info("Async registration loop started")
-        
-        # Initial registration attempt
-        await self._attempt_registration()
-        
-        # Main loop
-        while not self._stop_event.is_set():
-            try:
-                if self.status.state == RegistrationState.REGISTERED:
-                    if self.heartbeat_enabled:
-                        # Perform heartbeat
-                        await self._perform_heartbeat()
-                    else:
-                        # Just wait if heartbeat is disabled
-                        await asyncio.sleep(self.heartbeat_interval)
-                else:
-                    # Try to register
-                    await self._attempt_registration()
-                    # Wait before retry
-                    await asyncio.sleep(self.retry_delay)
-                    
-            except Exception as e:
-                logger.error(f"Error in async registration loop: {e}")
-                self.status.state = RegistrationState.ERROR
-                self.status.last_error = str(e)
-                await asyncio.sleep(self.retry_delay)
-        
-        logger.info("Async registration loop stopped")
-    
-    async def _attempt_registration(self):
-        """Attempt to register with the proxy."""
-        if self.status.state == RegistrationState.REGISTERING:
-            return  # Already registering
-        
-        self.status.state = RegistrationState.REGISTERING
-        self.status.attempt_count += 1
-        self.status.last_attempt = time.time()
-        
-        logger.info(f"Attempting proxy registration (attempt #{self.status.attempt_count})")
-        
-        try:
-            success = await self.registration_manager.register_server()
-            
-            if success:
-                self.status.state = RegistrationState.REGISTERED
-                self.status.last_success = time.time()
-                self.status.success_count += 1
-                self.status.last_error = None
-                logger.info(f"✅ Proxy registration successful (attempt #{self.status.attempt_count})")
-            else:
-                self.status.state = RegistrationState.NOT_REGISTERED
-                self.status.last_error = "Registration returned False"
-                logger.warning(f"❌ Proxy registration failed (attempt #{self.status.attempt_count}): Registration returned False")
-                
-        except Exception as e:
-            self.status.state = RegistrationState.NOT_REGISTERED
-            self.status.last_error = str(e)
-            logger.error(f"❌ Proxy registration failed (attempt #{self.status.attempt_count}): {e}")
-    
-    async def _perform_heartbeat(self):
-        """Perform heartbeat to the proxy."""
-        try:
-            # Use the registration manager's heartbeat functionality
-            success = await self.registration_manager.heartbeat()
-            
-            if success:
-                logger.debug("💓 Heartbeat successful")
-                self.status.last_success = time.time()
-            else:
-                logger.warning("💓 Heartbeat failed")
-                self.status.state = RegistrationState.HEARTBEAT_FAILED
-                self.status.last_error = "Heartbeat failed"
-                
-                # Try to re-register after heartbeat failure
-                logger.info("Attempting re-registration after heartbeat failure")
-                await self._attempt_registration()
-                
-        except Exception as e:
-            logger.error(f"💓 Heartbeat error: {e}")
-            self.status.state = RegistrationState.HEARTBEAT_FAILED
-            self.status.last_error = str(e)
-            
-            # Try to re-register after heartbeat error
-            logger.info("Attempting re-registration after heartbeat error")
-            await self._attempt_registration()
-        
-        # Wait for next heartbeat
-        await asyncio.sleep(self.heartbeat_interval)
-    
-    def get_status(self) -> Dict[str, Any]:
-        """Get current registration status."""
-        return {
-            "state": self.status.state.value,
-            "server_key": self.status.server_key,
-            "last_attempt": self.status.last_attempt,
-            "last_success": self.status.last_success,
-            "last_error": self.status.last_error,
-            "attempt_count": self.status.attempt_count,
-            "success_count": self.status.success_count,
-            "heartbeat_enabled": self.heartbeat_enabled,
-            "heartbeat_interval": self.heartbeat_interval,
-            "thread_alive": self._thread.is_alive() if self._thread else False
-        }
-
-
-# Global instance
-_async_registration_manager: Optional[AsyncProxyRegistrationManager] = None
-
-
-def get_async_registration_manager() -> Optional[AsyncProxyRegistrationManager]:
-    """Get the global async registration manager instance."""
-    return _async_registration_manager
-
-
-def initialize_async_registration(config: Dict[str, Any]) -> AsyncProxyRegistrationManager:
-    """Initialize the global async registration manager."""
-    global _async_registration_manager
-    _async_registration_manager = AsyncProxyRegistrationManager(config)
-    return _async_registration_manager
-
-
-def start_async_registration(server_url: str):
-    """Start async registration with the given server URL."""
-    global _async_registration_manager
-    if _async_registration_manager:
-        _async_registration_manager.set_server_url(server_url)
-        _async_registration_manager.start()
-    else:
-        logger.error("Async registration manager not initialized")
-
-
-def stop_async_registration():
-    """Stop async registration."""
-    global _async_registration_manager
-    if _async_registration_manager:
-        _async_registration_manager.stop()
-
-
-def get_registration_status() -> Dict[str, Any]:
-    """Get current registration status."""
-    global _async_registration_manager
-    if _async_registration_manager:
-        return _async_registration_manager.get_status()
-    else:
-        return {"state": "not_initialized"}