@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/web/server.py

@@ -11,6 +11,7 @@ import logging
 import os
 import time
 import uuid
+import random
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -48,26 +49,36 @@ SYSTEM_BROADCAST_EVENTS = {
     "module.crashed", "module.exiting", "module.offline",
     "module.shutdown.ack", "module.shutdown.ready",
     "system.ready", "registry.updated",
+    "system.instance.started", "system.instance.stopped",
 }
 
 
 class WebServer:
 
     def __init__(self, token: str = "", kernel_port: int = 0,
-                 host: str = "0.0.0.0", port: int = 0, boot_t0: float = 0):
+                 host: str = "0.0.0.0", port: int = 0, boot_t0: float = 0,
+                 max_connections: int = 1,
+                 gateway_url: str = "", kite_token: str = ""):
         self.token = token
         self.kernel_port = kernel_port
         self.host = host
         self.port = port
         self.boot_t0 = boot_t0
+        self.max_connections = max_connections
+        self.gateway_url = gateway_url
+        self.kite_token = kite_token
+        self._extra_ws: dict = {}           # slot → WebSocket
+        self._extra_ws_tasks: dict = {}     # slot → recv loop Task
         self._ws_task: asyncio.Task | None = None
         self._test_task: asyncio.Task | None = None
         self._ws: object | None = None
         self._shutting_down = False
         self._exit_code = 0  # Exit code for main() to use
+        self._auth_failed = False
         self._uvicorn_server = None  # set by entry.py for graceful shutdown
         self._start_time = time.time()
-        self._rpc_futures = {}  # Store pending RPC request futures
+        self._pending_rpc: dict[str, asyncio.Future] = {}  # 等待响应的 RPC futures
+        self._has_registered = False
         self.bt_manager: BluetoothManager | None = None
         self.task_manager: TaskManager | None = None
         self.app = self._create_app()
@@ -78,6 +89,21 @@ class WebServer:
 
         @app.on_event("startup")
         async def _startup():
+            # Token already set in entry.py, no need to read from stdin
+            if not server.token:
+                print("[web] ERROR: Missing token, cannot connect to Kernel")
+                return
+
+            # Start Kernel WS connection (module.ready depends on this)
+            if server.kernel_port:
+                server._ws_task = asyncio.create_task(server._ws_loop())
+            server._test_task = asyncio.create_task(server._test_event_loop())
+
+            # Business initialization in background (does not block module.ready)
+            asyncio.create_task(_deferred_init())
+
+        async def _deferred_init():
+            """Business initialization that runs after WS connection starts."""
             # Load business configurations
             module_dir = Path(__file__).parent
             business_configs = load_business_configs(str(module_dir))
@@ -148,11 +174,6 @@ class WebServer:
 
             logger.info("Web Management: managers initialized")
 
-            # Start background tasks directly
-            if server.kernel_port:
-                server._ws_task = asyncio.create_task(server._ws_loop())
-            server._test_task = asyncio.create_task(server._test_event_loop())
-
         @app.on_event("shutdown")
         async def _shutdown():
             if server._ws_task:
@@ -254,142 +275,200 @@ class WebServer:
 
         return app
 
+    # ── system.require_init 处理 ──
+
+    async def _do_init(self, ws):
+        """收到 system.require_init 后执行：订阅 + 注册 + module.ready"""
+        reason = "startup" if not self._has_registered else "recovery"
+        print(f"[web] Received system.require_init (reason={reason})")
+
+        try:
+            # Subscribe to events
+            await self._rpc_call(ws, "event.subscribe", {
+                "events": [
+                    "module.started",
+                    "module.stopped",
+                    "module.crashed",
+                    "module.ready",
+                    "module.exiting",
+                    "module.shutdown",
+                    "module.shutdown.ack",
+                    "module.shutdown.ready",
+                ],
+            })
+
+            # Register to Kernel Registry via RPC
+            await self._rpc_call(ws, "registry.register", {
+                "module_id": "web",
+                "module_type": "service",
+                "base_url": f"http://127.0.0.1:{self.port}",
+                "health_path": "/health",
+                "display": {
+                    "urls": {
+                        "Web 管理后台": f"http://127.0.0.1:{self.port}"
+                    }
+                },
+                "tools": {
+                    "rpc": {
+                        "module": {
+                            "health": {"method": "health", "description": "健康检查"},
+                            "status": {"method": "status", "description": "状态查询"}
+                        },
+                        "web": {
+                            "list_tokens": {"method": "list_tokens", "description": "列出所有令牌"},
+                            "revoke_token": {"method": "revoke_token", "description": "撤销令牌"}
+                        }
+                    }
+                },
+                "events_publish": {
+                    "web": {
+                        "test": {"description": "Test event from web module"},
+                        "started": {"description": "Web UI started with access URL"},
+                    }
+                },
+                "events_subscribe": [
+                    "module.started",
+                    "module.stopped",
+                    "module.crashed",
+                    "module.ready",
+                    "module.exiting",
+                    "module.shutdown",
+                    "module.shutdown.ack",
+                    "module.shutdown.ready",
+                ],
+            })
+            elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
+            elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
+            print(f"[web] Registered to Kernel{elapsed_str}")
+
+            # Send module.ready
+            if not self._shutting_down:
+                startup_time = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
+                await self._publish_event(ws, "module.ready", {
+                    "module_id": "web",
+                    "graceful_shutdown": True,
+                    "startup_time": startup_time,
+                    "reason": reason,
+                })
+                elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
+                if elapsed < 1:
+                    elapsed_str = f"{elapsed * 1000:.0f}ms"
+                elif elapsed < 10:
+                    elapsed_str = f"{elapsed:.1f}s"
+                else:
+                    elapsed_str = f"{elapsed:.0f}s"
+                print(f"[web] module.ready published ({elapsed_str})")
+
+                # Publish web.started event with access URL
+                display_host = "localhost" if self.host == "0.0.0.0" else self.host
+                access_url = f"http://{display_host}:{self.port}"
+                await self._publish_event(ws, "web.started", {
+                    "module_id": "web",
+                    "url": access_url,
+                    "host": self.host,
+                    "port": self.port,
+                })
+
+            self._has_registered = True
+
+        except Exception as e:
+            print(f"[web] _do_init failed: {e}")
+
     # ── Kernel WebSocket client ──
 
     async def _ws_loop(self):
         """Connect to Kernel, subscribe, register, and listen. Reconnect on failure."""
-        retry_delay = 0.3
-        max_delay = 5.0
-        max_retries = 10
+        retry_delay = 0.5
+        max_delay = 10.0
         attempt = 0
+        cooldown_attempts = 0
+
         while not self._shutting_down:
             try:
                 await self._ws_connect()
-                retry_delay = 0.3  # reset on successful connection
+                retry_delay = 0.5
                 attempt = 0
+                cooldown_attempts = 0
             except asyncio.CancelledError:
                 print(f"[web] WS loop cancelled")
                 return
             except Exception as e:
-                attempt += 1
-                # Auth failure — don't retry
-                if hasattr(e, 'rcvd') and e.rcvd is not None:
-                    code = e.rcvd.code if hasattr(e.rcvd, 'code') else 0
-                    if code in (4001, 4003):
-                        print(f"[web] Kernel 认证失败 (code {code})，退出")
-                        self._exit_code = 1
-                        self._shutting_down = True
-                        if self._uvicorn_server:
-                            self._uvicorn_server.should_exit = True
-                        return
-                if attempt >= max_retries:
-                    print(f"[web] Kernel 重连失败 {max_retries} 次，退出")
+                if self._shutting_down:
+                    print(f"[web] Shutting down, not retrying connection")
+                    return
+
+                code = self._get_close_code(e)
+
+                # never: 永不重连
+                if code in (4001, 4003, 4004, 1008, 4010):
+                    print(f"[web] 致命错误 (code {code})，退出")
                     self._exit_code = 1
+                    self._auth_failed = True
                     self._shutting_down = True
                     if self._uvicorn_server:
                         self._uvicorn_server.should_exit = True
                     return
-                if self._shutting_down:
-                    print(f"[web] Shutting down, not retrying connection")
-                    return
-                print(f"[web] Kernel connection error: {e}, retrying in {retry_delay:.1f}s ({attempt}/{max_retries})")
+
+                # cooldown: 速率限制
+                if code == 4020:
+                    cooldown_attempts += 1
+                    if cooldown_attempts >= 5:
+                        print(f"[web] 速率限制重试 5 次，退出")
+                        self._exit_code = 1
+                        self._shutting_down = True
+                        if self._uvicorn_server:
+                            self._uvicorn_server.should_exit = True
+                        return
+                    print(f"[web] 速率限制，10.0s 后重试 ({cooldown_attempts}/5)")
+                    await asyncio.sleep(10.0)
+                    continue
+
+                # standard: 指数退避 + jitter
+                attempt += 1
+                jitter = retry_delay * 0.2 * random.random()
+                sleep_time = retry_delay + jitter
+                print(f"[web] Kernel connection error: {e}, retrying in {sleep_time:.1f}s (attempt {attempt})")
+
             self._ws = None
             if self._shutting_down:
                 print(f"[web] Shutting down, exiting WS loop")
                 return
-            await asyncio.sleep(retry_delay)
+            await asyncio.sleep(sleep_time if 'sleep_time' in locals() else retry_delay)
             retry_delay = min(retry_delay * 2, max_delay)
 
+    def _get_close_code(self, e: Exception) -> int:
+        """从 websockets 异常中提取关闭码"""
+        if hasattr(e, 'rcvd') and e.rcvd is not None:
+            return getattr(e.rcvd, 'code', 0)
+        return 0
+
     async def _ws_connect(self):
         """Single WebSocket session: connect, register, subscribe, receive loop."""
-        url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={self.token}&id=web"
+        url = f"ws://127.0.0.1:{self.kernel_port}/ws?id=web"
         print(f"[web] WS connecting to Kernel")
         try:
-            async with websockets.connect(url, open_timeout=5, ping_interval=20, ping_timeout=20, close_timeout=10) as ws:
+            async with websockets.connect(url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
+                # Send auth message first
+                auth_req = {
+                    "jsonrpc": "2.0",
+                    "id": "auth",
+                    "method": "auth",
+                    "params": {"token": self.token}
+                }
+                await ws.send(json.dumps(auth_req))
+
+                # Wait for auth response
+                auth_resp_raw = await asyncio.wait_for(ws.recv(), timeout=5)
+                auth_resp = json.loads(auth_resp_raw)
+                if "error" in auth_resp:
+                    raise Exception(f"Auth failed: {auth_resp['error']}")
+
                 self._ws = ws
                 elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
                 print(f"[web] Connected to Kernel{elapsed_str}")
 
-                # Subscribe to events
-                await self._rpc_call(ws, "event.subscribe", {
-                    "events": [
-                        "module.started",
-                        "module.stopped",
-                        "module.crashed",
-                        "module.ready",
-                        "module.exiting",
-                        "module.shutdown",
-                        "module.shutdown.ack",
-                        "module.shutdown.ready",
-                    ],
-                })
-
-                # Register to Kernel Registry via RPC
-                await self._rpc_call(ws, "registry.register", {
-                    "module_id": "web",
-                    "module_type": "service",
-                    "api_endpoint": f"http://127.0.0.1:{self.port}",
-                    "health_endpoint": "/health",
-                    "tools": {
-                        "rpc": {
-                            "module": {
-                                "health": {"method": "health", "description": "健康检查"},
-                                "status": {"method": "status", "description": "状态查询"}
-                            },
-                            "web": {
-                                "list_tokens": {"method": "list_tokens", "description": "列出所有令牌"},
-                                "revoke_token": {"method": "revoke_token", "description": "撤销令牌"}
-                            }
-                        }
-                    },
-                    "events_publish": {
-                        "web": {
-                            "test": {"description": "Test event from web module"},
-                            "started": {"description": "Web UI started with access URL"},
-                        }
-                    },
-                    "events_subscribe": [
-                        "module.started",
-                        "module.stopped",
-                        "module.crashed",
-                        "module.ready",
-                        "module.exiting",
-                        "module.shutdown",
-                        "module.shutdown.ack",
-                        "module.shutdown.ready",
-                    ],
-                })
-                print(f"[web] Registered to Kernel{elapsed_str}")
-
-                # Send module.ready (every reconnect, not just first time)
-                if not self._shutting_down:
-                    await self._rpc_call(ws, "event.publish", {
-                        "event_id": str(uuid.uuid4()),
-                        "event": "module.ready",
-                        "data": {
-                            "module_id": "web",
-                            "graceful_shutdown": True,
-                        },
-                    })
-                    elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
-                    elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
-                    print(f"[web] module.ready sent{elapsed_str}")
-
-                    # Publish web.started event with access URL
-                    display_host = "localhost" if self.host == "0.0.0.0" else self.host
-                    access_url = f"http://{display_host}:{self.port}"
-                    await self._publish_event({
-                        "event": "web.started",
-                        "data": {
-                            "module_id": "web",
-                            "url": access_url,
-                            "host": self.host,
-                            "port": self.port,
-                        },
-                    })
-
-                # Receive loop
+                # Receive loop (system.require_init will trigger _do_init)
                 # CRITICAL: RPC 死锁防范
                 # - 入站 RPC 请求必须用 create_task() 异步执行，不可 await
                 # - 原因：如果 handler 内部调用 rpc_call() 发出站请求，出站响应需要本接收循环来分发
@@ -397,9 +476,6 @@ class WebServer:
                 # - 事件通知和 RPC 响应可以同步处理（它们不会反向调用 rpc_call）
                 print(f"[web] Entering receive loop")
 
-                # Start heartbeat loop
-                heartbeat_task = asyncio.create_task(self._heartbeat_loop(ws))
-
                 try:
                     async for raw in ws:
                         try:
@@ -413,16 +489,20 @@ class WebServer:
                             has_result_or_error = "result" in msg or "error" in msg
 
                             if has_method and not has_id:
-                                # Event Notification
-                                await self._handle_event_notification(msg)
+                                # 检测 system.require_init 事件
+                                params = msg.get("params", {})
+                                event_type = params.get("event", "")
+                                if event_type == "system.require_init":
+                                    asyncio.create_task(self._do_init(ws))
+                                    continue
+                                # Event Notification — run in background to prevent deadlock
+                                asyncio.create_task(self._handle_event_notification(msg))
                             elif has_method and has_id:
                                 # Incoming RPC request — run in background to prevent deadlock
                                 asyncio.create_task(self._handle_rpc_request(ws, msg))
                             elif has_id and has_result_or_error:
                                 # RPC response — resolve pending future
-                                rpc_id = msg.get("id")
-                                if rpc_id in self._rpc_futures:
-                                    self._rpc_futures[rpc_id].set_result(msg)
+                                self._handle_rpc_response(msg)
                         except Exception as e:
                             print(f"[web] 消息处理异常（已忽略）: {e}")
                 except Exception as e:
@@ -435,24 +515,49 @@ class WebServer:
         finally:
             print(f"[web] WebSocket connection closed")
             self._ws = None
-
-    async def _rpc_call(self, ws, method: str, params: dict = None):
-        """Send a JSON-RPC 2.0 request (fire-and-forget, no response awaited)."""
-        msg = {"jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": method}
+            # 清理所有 pending RPC futures（连接断开，不会再收到响应）
+            for rpc_id, future in self._pending_rpc.items():
+                if not future.done():
+                    future.set_exception(ConnectionError("WebSocket disconnected"))
+            self._pending_rpc.clear()
+
+    async def _rpc_call(self, ws, method: str, params: dict = None,
+                        wait_response: bool = True, timeout: float = 3.0) -> dict:
+        """JSON-RPC 2.0 request。默认等待响应。"""
+        rpc_id = str(uuid.uuid4())
+        msg = {"jsonrpc": "2.0", "id": rpc_id, "method": method}
         if params:
             msg["params"] = params
+        if not wait_response:
+            await ws.send(json.dumps(msg))
+            return {}
+        future = asyncio.get_event_loop().create_future()
+        self._pending_rpc[rpc_id] = future
         await ws.send(json.dumps(msg))
-
-    async def _heartbeat_loop(self, ws):
-        """Send registry.heartbeat every 30 seconds to prevent TTL expiration."""
-        while True:
-            try:
-                await asyncio.sleep(30)
-                if not self._shutting_down:
-                    await self._rpc_call(ws, "registry.heartbeat", {"module_id": "web"})
-            except Exception as e:
-                print(f"[web] Heartbeat error: {e}")
-                break
+        try:
+            return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError:
+            self._pending_rpc.pop(rpc_id, None)
+            return {"error": {"code": -32000, "message": f"RPC timeout: {method} ({timeout}s)"}}
+
+    def _handle_rpc_response(self, msg: dict):
+        """分发 RPC 响应到对应的 pending future。"""
+        rpc_id = msg.get("id")
+        future = self._pending_rpc.pop(rpc_id, None)
+        if future and not future.done():
+            future.set_result(msg)
+
+    async def _handle_ping_event(self, data: dict):
+        """Handle system.ping event and reply with system.pong."""
+        import time
+        t1 = data.get("ping_time")
+        t2 = time.time()
+
+        await self._publish_event(self._ws, "system.pong", {
+            "module_id": "web",
+            "ping_time": t1,
+            "pong_time": t2,
+        })
 
     async def _handle_event_notification(self, msg: dict):
         """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
@@ -460,6 +565,19 @@ class WebServer:
         event_type = params.get("event", "")
         data = params.get("data", {})
 
+        # Handle system.ping event
+        if event_type == "system.ping":
+            await self._handle_ping_event(data)
+            return
+
+        # 弹性连接 offer/release
+        if event_type == "system.connection.offer":
+            asyncio.create_task(self._handle_connection_offer(data))
+            return
+        if event_type == "system.connection.release":
+            asyncio.create_task(self._handle_connection_release(data))
+            return
+
         # Log all events for debugging
         print(f"[web] Event received: {event_type}, data: {data}")
 
@@ -532,10 +650,15 @@ class WebServer:
 
     async def _rpc_health(self) -> dict:
         """RPC handler for web.health."""
+        # 获取 WebSocket 连接数
+        from routes.routes_management_ws import _management_clients
+        active_connections = len(_management_clients)
+
         return {
             "status": "healthy",
+            "uptime_seconds": round(time.time() - self._start_time),
             "details": {
-                "uptime_seconds": round(time.time() - self._start_time),
+                "active_ws_connections": active_connections,
             },
         }
 
@@ -617,6 +740,74 @@ class WebServer:
 
         return {"success": True, "message": "Token revoked successfully"}
 
+    async def _handle_connection_offer(self, data):
+        """处理 Kernel 下发的 slot token，建立附加连接。"""
+        slots = data.get("slots", {})
+        for slot_str, info in slots.items():
+            slot = int(slot_str)
+            token = info.get("token", "")
+            if not token or slot in self._extra_ws:
+                continue
+            asyncio.create_task(self._connect_slot(slot, token))
+
+    async def _connect_slot(self, slot, token):
+        """建立单个 slot 附加连接。"""
+        ws_url = f"ws://127.0.0.1:{self.kernel_port}/ws"
+        try:
+            ws = await websockets.connect(ws_url, open_timeout=5, ping_interval=None, close_timeout=5)
+            auth_req = {"jsonrpc": "2.0", "id": f"auth-slot-{slot}", "method": "auth", "params": {"token": token}}
+            await ws.send(json.dumps(auth_req))
+            resp = json.loads(await asyncio.wait_for(ws.recv(), timeout=5))
+            if "error" in resp:
+                await ws.close()
+                return
+            self._extra_ws[slot] = ws
+            self._extra_ws_tasks[slot] = asyncio.create_task(self._slot_recv_loop(slot, ws))
+            print(f"[web] Slot {slot} connected")
+        except Exception as e:
+            print(f"[web] Slot {slot} connect failed: {e}")
+
+    async def _slot_recv_loop(self, slot, ws):
+        """附加 slot 接收循环：与主连接平等处理所有消息。"""
+        try:
+            async for raw in ws:
+                try:
+                    msg = json.loads(raw)
+                except (json.JSONDecodeError, TypeError):
+                    continue
+
+                try:
+                    has_method = "method" in msg
+                    has_id = "id" in msg
+                    has_result_or_error = "result" in msg or "error" in msg
+
+                    if has_method and not has_id:
+                        asyncio.create_task(self._handle_event_notification(msg))
+                    elif has_method and has_id:
+                        asyncio.create_task(self._handle_rpc_request(ws, msg))
+                    elif has_id and has_result_or_error:
+                        self._handle_rpc_response(msg)
+                except Exception as e:
+                    print(f"[web] Slot {slot} 消息处理异常: {e}")
+        except Exception as e:
+            print(f"[web] Slot {slot} recv loop exited: {e}")
+        finally:
+            self._extra_ws.pop(slot, None)
+            self._extra_ws_tasks.pop(slot, None)
+
+    async def _handle_connection_release(self, data):
+        """Kernel 请求释放 slot，优雅关闭。"""
+        for slot in data.get("slots", []):
+            ws = self._extra_ws.pop(slot, None)
+            task = self._extra_ws_tasks.pop(slot, None)
+            if ws:
+                try:
+                    await ws.close(code=1000, reason="release")
+                except Exception:
+                    pass
+            if task:
+                task.cancel()
+
     async def _handle_shutdown(self):
         """Handle module.shutdown: ack → exiting → cleanup → ready → close connections → exit."""
         print("[web] ========== SHUTDOWN STARTED ==========")
@@ -625,25 +816,21 @@ class WebServer:
 
         # Step 1: Send ack (立即确认收到)
         print("[web] Sending shutdown ack...")
-        await self._publish_event({
-            "event": "module.shutdown.ack",
-            "data": {"module_id": "web"},
+        await self._publish_event(self._ws, "module.shutdown.ack", {
+            "module_id": "web",
         })
         print("[web] shutdown ack sent")
 
         # Step 2: Send module.exiting (开始清理)
         print("[web] Sending module.exiting...")
-        await self._publish_event({
-            "event": "module.exiting",
-            "data": {
-                "module_id": "web",
-                "type": "passive",
-                "reason": "shutdown_requested",
-                "restart": "auto",
-                "action": "none",
-                "timeout": 3.0,
-                "restart_delay": 0.0,
-            },
+        await self._publish_event(self._ws, "module.exiting", {
+            "module_id": "web",
+            "type": "passive",
+            "reason": "shutdown_requested",
+            "restart": "auto",
+            "action": "none",
+            "timeout": 3.0,
+            "restart_delay": 0.0,
         })
         print("[web] module.exiting sent")
 
@@ -669,15 +856,36 @@ class WebServer:
 
         print("[web] All WebSocket connections closed")
 
-        # Step 4: Send ready (after closing connections)
+        # Step 4: Send ready（必须在关闭连接之前发送）
         print("[web] Sending shutdown ready...")
-        await self._publish_event({
-            "event": "module.shutdown.ready",
-            "data": {"module_id": "web"},
+        await self._publish_event(self._ws, "module.shutdown.ready", {
+            "module_id": "web",
         })
         print("[web] shutdown ready sent")
 
-        # Step 5: Trigger uvicorn graceful shutdown
+        # 等待 Kernel 处理 shutdown.ready
+        await asyncio.sleep(0.01)
+
+        # Step 5: 关闭所有附加连接
+        for _s, _w in list(self._extra_ws.items()):
+            try:
+                await _w.close(code=1000, reason="shutdown")
+            except Exception:
+                pass
+        for _t in self._extra_ws_tasks.values():
+            _t.cancel()
+        self._extra_ws.clear()
+        self._extra_ws_tasks.clear()
+
+        # Step 5: Close Kernel WebSocket connection gracefully
+        if self._ws:
+            try:
+                await self._ws.close(code=1000, reason="Graceful shutdown")
+                print("[web] Kernel WebSocket closed")
+            except Exception as e:
+                print(f"[web] Failed to close Kernel WebSocket: {e}")
+
+        # Step 6: Trigger uvicorn graceful shutdown
         print("[web] Triggering uvicorn graceful shutdown...")
         if self._uvicorn_server:
             self._uvicorn_server.should_exit = True
@@ -685,37 +893,28 @@ class WebServer:
 
         print("[web] ========== SHUTDOWN COMPLETE ==========")
 
-        # Give uvicorn a moment to start shutdown, then force exit
-        # This prevents hanging on lingering connections
-        await asyncio.sleep(0.5)
-        import sys
-        sys.exit(0)
+        # Note: Do NOT call sys.exit() in async context
+        # Let uvicorn naturally complete its shutdown
 
-    async def _publish_event(self, event: dict):
-        """Publish an event via RPC event.publish."""
-        if not self._ws:
-            print(f"[web] WARNING: Cannot publish event {event.get('event')}, WebSocket not connected")
-            return
-        try:
-            await self._rpc_call(self._ws, "event.publish", {
-                "event_id": str(uuid.uuid4()),
-                "event": event.get("event", ""),
-                "data": event.get("data", {}),
-            })
-        except Exception as e:
-            print(f"[web] ERROR: Failed to publish event {event.get('event')}: {e}")
+    async def _publish_event(self, ws, event: str, data: dict = None):
+        """通过 RPC event.publish 发布事件（fire-and-forget）。"""
+        await self._rpc_call(ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
+            "event": event,
+            "data": data or {},
+        }, wait_response=False)
 
     # ── Test event loop ──
 
     async def _test_event_loop(self):
         """Publish a test event every 10 seconds."""
-        while True:
-            await asyncio.sleep(10)
-            await self._publish_event({
-                "event": "web.test",
-                "data": {
-                    "message": "test event from web",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                },
-            })
-            print("[web] test event published")
+        try:
+            while True:
+                await asyncio.sleep(10)
+                if self._ws:
+                    await self._publish_event(self._ws, "web.test", {
+                        "message": "test event from web",
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                    })
+        except Exception:
+            pass