@agentunion/kite 1.0.7 → 1.3.0

package/extensions/services/watchdog/monitor.py

@@ -9,8 +9,6 @@ import json
 import time
 from datetime import datetime, timezone
 
-import httpx
-
 
 # Module health states
 HEALTHY = "healthy"
@@ -68,56 +66,56 @@ class HealthMonitor:
     # Check intervals per resource state
     INTERVALS = {NORMAL: 15, WARNING: 5, CRITICAL: 2}
 
-    def __init__(self, own_token: str, registry_url: str, launcher_url: str,
-                 publish_event=None):
+    def __init__(self, own_token: str, kernel_port: int, publish_event=None):
         self.own_token = own_token
-        self.registry_url = registry_url
-        self.launcher_url = launcher_url
+        self.kernel_port = kernel_port
         self.publish_event = publish_event  # async callable(event_dict)
+        self.rpc_call = None  # set by entry.py: async callable(method, params)
         self.modules: dict[str, ModuleStatus] = {}
         self._running = False
         self._psutil = None  # lazy import
 
+        # Restart decision state (module.exiting / module.stopped / module.ready)
+        self._exit_intents: dict[str, str] = {}        # module_id -> action from module.exiting
+        self._graceful_modules: dict[str, bool] = {     # module_id -> supports graceful shutdown
+            "kernel": True,                                # started before Watchdog, default True
+        }
+        self._system_shutting_down = False
+        self._system_ready = False
+        self._system_ready_event = asyncio.Event()
+        self._crash_counts: dict[str, int] = {}         # module_id -> consecutive crash count
+
     # ── Module discovery ──
 
     async def discover_modules(self):
-        """Fetch monitored modules from Launcher API + Registry health endpoints."""
-        # Step 1: Get module list with monitor/pid from Launcher API
-        monitored = {}  # name -> {pid, running}
+        """Fetch monitored modules from Launcher + Registry via RPC."""
+        # Step 1: Get module list with monitor/pid from Launcher via RPC
+        monitored = {}  # name -> pid
         try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.get(
-                    f"{self.launcher_url}/launcher/modules", timeout=5,
-                )
-                if resp.status_code == 200:
-                    for m in resp.json():
-                        name = m.get("name", "")
-                        if name == "watchdog" or not m.get("monitor", True):
-                            continue
-                        if m.get("actual_state", "").startswith("running"):
-                            monitored[name] = m.get("pid")
+            resp = await self.rpc_call("launcher.list_modules", {})
+            result = resp.get("result", {})
+            for m in result.get("modules", []):
+                name = m.get("name", "")
+                if name == "watchdog" or not m.get("monitor", True):
+                    continue
+                if m.get("actual_state", "").startswith("running"):
+                    monitored[name] = m.get("pid")
         except Exception as e:
-            print(f"[watchdog] Launcher API failed: {e}")
+            print(f"[watchdog] Launcher RPC failed: {e}")
             return
 
-        # Step 2: Get health endpoints from Registry
+        # Step 2: Get health endpoints from Registry via RPC
         health_map = {}  # name -> {api_endpoint, health_endpoint}
-        headers = {"Authorization": f"Bearer {self.own_token}"}
         try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.get(
-                    f"{self.registry_url}/lookup",
-                    params={"field": "health_endpoint"},
-                    headers=headers, timeout=5,
-                )
-                if resp.status_code == 200:
-                    for entry in resp.json():
-                        mid = entry.get("module", "")
-                        if mid in monitored:
-                            health_map[mid] = {
-                                "api_endpoint": entry.get("api_endpoint", ""),
-                                "health_endpoint": entry.get("value", "/health"),
-                            }
+            resp = await self.rpc_call("registry.lookup", {"field": "health_endpoint"})
+            result = resp.get("result", {})
+            for entry in result.get("results", []):
+                mid = entry.get("module", "")
+                if mid in monitored:
+                    health_map[mid] = {
+                        "api_endpoint": entry.get("api_endpoint", ""),
+                        "health_endpoint": entry.get("value", "/health"),
+                    }
         except Exception:
             pass
 
@@ -126,15 +124,21 @@ class HealthMonitor:
         for mid, pid in monitored.items():
             seen.add(mid)
             h = health_map.get(mid, {})
+            ep = h.get("api_endpoint", "")
+            hp = h.get("health_endpoint", "/health")
             if mid not in self.modules:
                 self.modules[mid] = ModuleStatus(
                     module_id=mid,
-                    api_endpoint=h.get("api_endpoint", ""),
-                    health_endpoint=h.get("health_endpoint", "/health"),
+                    api_endpoint=ep,
+                    health_endpoint=hp,
                     pid=pid,
                 )
             else:
                 self.modules[mid].pid = pid
+                # Refresh endpoints once Registry has them
+                if ep:
+                    self.modules[mid].api_endpoint = ep
+                    self.modules[mid].health_endpoint = hp
 
         for mid in list(self.modules):
             if mid not in seen:
@@ -144,6 +148,8 @@ class HealthMonitor:
 
     async def _check_one(self, status: ModuleStatus):
         """Check a single module's /health endpoint."""
+        if not status.api_endpoint:
+            return  # Not yet registered in Registry, will be picked up on next discover
         url = f"{status.api_endpoint}{status.health_endpoint}"
         status.last_check = time.time()
 
@@ -197,28 +203,27 @@ class HealthMonitor:
     # ── Restart via Launcher API ──
 
     async def _restart_module(self, status: ModuleStatus):
-        """Restart a module via Launcher API."""
+        """Restart a module via Launcher RPC."""
         mid = status.module_id
         print(f"[watchdog] Restarting {mid} (attempt {status.restarted_count + 1}/{self.MAX_RESTARTS})")
         try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.post(
-                    f"{self.launcher_url}/launcher/modules/{mid}/restart",
-                    json={"reason": "resource_critical" if status.resource_state == CRITICAL else "restart"},
-                    timeout=15,
-                )
-                if resp.status_code == 200:
-                    status.restarted_count += 1
-                    status.fail_count = 0
-                    print(f"[watchdog] {mid} restart requested")
-                    if status.restarted_count >= self.ALERT_AFTER_RESTARTS:
-                        await self._publish("watchdog.alert", {
-                            "module_id": mid,
-                            "restarted_count": status.restarted_count,
-                            "message": f"{mid} has been restarted {status.restarted_count} times",
-                        })
-                else:
-                    print(f"[watchdog] {mid} restart failed: HTTP {resp.status_code}")
+            resp = await self.rpc_call("launcher.restart_module", {
+                "name": mid,
+                "reason": "resource_critical" if status.resource_state == CRITICAL else "restart",
+            })
+            result = resp.get("result", {})
+            if result.get("status") == "restarted":
+                status.restarted_count += 1
+                status.fail_count = 0
+                print(f"[watchdog] {mid} restart requested")
+                if status.restarted_count >= self.ALERT_AFTER_RESTARTS:
+                    await self._publish("watchdog.alert", {
+                        "module_id": mid,
+                        "restarted_count": status.restarted_count,
+                        "message": f"{mid} has been restarted {status.restarted_count} times",
+                    })
+            else:
+                print(f"[watchdog] {mid} restart failed: {result}")
         except Exception as e:
             print(f"[watchdog] {mid} restart error: {e}")
 
@@ -348,38 +353,134 @@ class HealthMonitor:
     # ── Incoming event handler ──
 
     async def handle_event(self, msg: dict):
-        """Handle events from Event Hub (module.started / module.stopped)."""
+        """Handle events from Kernel — restart decisions + health tracking."""
         event_type = msg.get("event", "")
         data = msg.get("data", {})
         module_id = data.get("module_id", "")
 
+        if event_type == "system.ready":
+            print("[watchdog] Received system.ready")
+            self._system_ready = True
+            self._system_ready_event.set()
+            return
+
         if not module_id or module_id == "watchdog":
             return
 
         if event_type == "module.started":
             print(f"[watchdog] Received module.started: {module_id}")
-            # Trigger immediate discovery to pick up the new module
+            self._crash_counts.pop(module_id, None)
             await self.discover_modules()
 
         elif event_type == "module.stopped":
             print(f"[watchdog] Received module.stopped: {module_id}")
-            # Remove from tracking — it's gone
             self.modules.pop(module_id, None)
+            await self._handle_module_stopped(module_id, data)
+
+        elif event_type == "module.exiting":
+            action = data.get("action", "none")
+            print(f"[watchdog] Received module.exiting: {module_id}, action={action}")
+            self._exit_intents[module_id] = action
+
+        elif event_type == "module.ready":
+            graceful = bool(data.get("graceful_shutdown"))
+            print(f"[watchdog] Received module.ready: {module_id}, graceful_shutdown={graceful}")
+            self._graceful_modules[module_id] = graceful
+
+        elif event_type == "module.shutdown":
+            reason = data.get("reason", "")
+            if reason == "system_shutdown":
+                print(f"[watchdog] Received system_shutdown signal")
+                self._system_shutting_down = True
+
+    async def _handle_module_stopped(self, module_id: str, data: dict):
+        """Restart decision engine — called when module.stopped is received.
+
+        Priority:
+        1. System shutting down → no restart
+        2. Has exit_intent → follow the declared action (none/restart/restart_delay)
+        3. No intent (crash) → increment crash count, restart up to MAX_RESTARTS
+        """
+        # Sync graceful_shutdown from Launcher (covers missed module.ready)
+        if "graceful_shutdown" in data:
+            self._graceful_modules[module_id] = bool(data["graceful_shutdown"])
+
+        if self._system_shutting_down:
+            print(f"[watchdog] {module_id} stopped during shutdown, skipping restart")
+            return
+
+        intent = self._exit_intents.pop(module_id, None)
+        if intent is not None:
+            if intent == "none":
+                print(f"[watchdog] {module_id} exited intentionally (action=none), no restart")
+                return
+            elif intent == "restart":
+                print(f"[watchdog] {module_id} requested restart, restarting now")
+                await self._restart_module_by_id(module_id, reason="module_requested")
+                return
+            elif intent == "restart_delay":
+                delay = 5
+                print(f"[watchdog] {module_id} requested delayed restart, waiting {delay}s")
+                await asyncio.sleep(delay)
+                await self._restart_module_by_id(module_id, reason="module_requested_delay")
+                return
+            else:
+                print(f"[watchdog] {module_id} exited with unknown action '{intent}', no restart")
+                return
+
+        # No exit intent → treat as crash
+        self._crash_counts[module_id] = self._crash_counts.get(module_id, 0) + 1
+        count = self._crash_counts[module_id]
+        exit_code = data.get("exit_code", -1)
+
+        if count <= self.MAX_RESTARTS:
+            print(f"[watchdog] {module_id} crashed (exit_code={exit_code}), restarting ({count}/{self.MAX_RESTARTS})")
+            await self._restart_module_by_id(module_id, reason="crash")
+        else:
+            print(f"[watchdog] {module_id} crashed {count} times, giving up")
+            await self._publish("watchdog.alert", {
+                "module_id": module_id,
+                "message": f"{module_id} exceeded {self.MAX_RESTARTS} crash restarts",
+            })
+
+    async def _restart_module_by_id(self, module_id: str, reason: str = "restart"):
+        """Restart a module via Launcher RPC by module_id."""
+        print(f"[watchdog] Requesting restart for {module_id} (reason={reason})")
+        try:
+            resp = await self.rpc_call("launcher.restart_module", {
+                "name": module_id,
+                "reason": reason,
+            })
+            result = resp.get("result", {})
+            if result.get("status") == "restarted":
+                print(f"[watchdog] {module_id} restart requested successfully")
+            else:
+                print(f"[watchdog] {module_id} restart failed: {result}")
+        except Exception as e:
+            print(f"[watchdog] {module_id} restart error: {e}")
 
     # ── Main loop ──
 
     async def run(self):
-        """Main monitoring loop with dynamic intervals per resource state."""
+        """Main monitoring loop with dynamic intervals per resource state.
+        Waits for system.ready before starting health checks."""
         self._running = True
-        print("[watchdog] Monitor started")
-        last_discover = 0
+        print("[watchdog] Monitor started, waiting for system.ready...")
+
+        # Wait for system.ready (or manual start via API later)
+        while self._running and not self._system_ready:
+            try:
+                await asyncio.wait_for(self._system_ready_event.wait(), timeout=1.0)
+            except asyncio.TimeoutError:
+                continue
+
+        if not self._running:
+            return
+        print("[watchdog] system.ready received, starting health checks")
 
         while self._running:
-            now = time.time()
-            # Rediscover every 30s
-            if now - last_discover >= 30:
-                await self.discover_modules()
-                last_discover = now
+            # Re-discover every cycle to pick up newly started/stopped modules
+            await self.discover_modules()
 
             if self.modules:
                 tasks = []

package/extensions/services/web/__init__.py

@@ -0,0 +1 @@
+

package/extensions/services/web/config.yaml

@@ -0,0 +1,149 @@
+user:
+  phone_number: ""       # 当前 AI 使用的号码
+  phone_numbers: []      # AI 号码列表，可在配置页面管理
+  owners: []             # 主人列表，每项包含 phone/name 等基础信息
+  # 示例:
+  # phone_numbers:
+  #   - "13800138000"
+  #   - "13800138001"
+  # owners:
+  #   - phone: "13900139000"
+  #     name: "张三"
+  #     note: "公司CEO"
+  #   - phone: "13700137000"
+  #     name: "李四"
+
+server:
+  host: "0.0.0.0"
+  port: 18766
+  ssl: true
+
+bluetooth:
+  auto_connect: true
+  reconnect_interval: 5
+  reconnect_max_interval: 60
+  device_address: ""
+
+audio:
+  sample_rate: 16000
+  channels: 1
+  format: "s16le"
+  record_calls: true
+
+llm:
+  active_provider: "openai"
+  providers:
+    openai:
+      base_url: "https://api.openai.com/v1"
+      api_key: ""
+      model: "gpt-4o"
+      temperature: 0.7
+      max_tokens: 1024
+    claude:
+      base_url: "https://api.anthropic.com/v1"
+      api_key: ""
+      model: "claude-sonnet-4-20250514"
+      temperature: 0.7
+      max_tokens: 1024
+    gemini:
+      base_url: "https://generativelanguage.googleapis.com/v1beta"
+      api_key: ""
+      model: "gemini-2.0-flash"
+      temperature: 0.7
+      max_tokens: 1024
+
+asr:
+  provider: "whisper"
+  whisper:
+    base_url: "https://api.openai.com/v1"
+    api_key: ""
+    model: "whisper-1"
+    language: "zh"
+  xunfei:
+    app_id: ""
+    api_key: ""
+    api_secret: ""
+  volcengine:
+    app_id: ""
+    access_token: ""
+    resource_id: "volc.bigasr.sauc.duration"
+    ws_url: "wss://openspeech.bytedance.com/api/v3/sauc/bigmodel_async"
+  tencent:
+    app_id: ""
+    secret_id: ""
+    secret_key: ""
+    engine_model_type: "16k_zh_large"
+
+tts:
+  provider: "edge-tts"
+  edge_tts:
+    voice: "zh-CN-XiaoxiaoNeural"
+    rate: "+0%"
+    volume: "+0%"
+  volcengine:
+    app_id: ""
+    access_token: ""
+    cluster: "volcano_tts"
+    voice_type: "BV001_streaming"
+    speed_ratio: 1.0
+    volume_ratio: 1.0
+    pitch_ratio: 1.0
+    encoding: "mp3"
+    sample_rate: 24000
+  tencent:
+    app_id: ""
+    secret_id: ""
+    secret_key: ""
+    voice_type: 101001
+    codec: "pcm"
+    sample_rate: 16000
+    speed: 0
+    volume: 0
+  azure:
+    api_key: ""
+    region: "eastasia"
+    voice: "zh-CN-XiaoxiaoNeural"
+    rate: "1.0"
+    volume: "100"
+  openai:
+    api_key: ""
+    base_url: "https://api.openai.com/v1"
+    model: "tts-1"
+    voice: "alloy"
+    speed: 1.0
+  aliyun:
+    access_key_id: ""
+    access_key_secret: ""
+    app_key: ""
+    voice: "zhixiaobai"
+    sample_rate: 16000
+    speech_rate: 0
+    volume: 50
+  local:
+    engine: "sherpa-onnx"
+    model_path: ""
+    voice: ""
+    sample_rate: 16000
+
+vad:
+  mode: 3
+  energy_threshold: 300
+  silence_threshold_ms: 800
+  min_speech_ms: 250
+
+call:
+  max_duration_seconds: 300
+  no_response_timeout: 15
+  no_response_max_retries: 3
+  incoming_confirm_timeout: 15
+  incoming_default_action: "reject"
+  opening_message: ""
+
+webhook:
+  default_url: ""
+  retry_count: 3
+  retry_delays: [1, 5, 30]
+  timeout: 10
+
+data:
+  base_dir: "./data"