@agentunion/kite 1.0.7 → 1.2.0

package/extensions/services/web/routes/schemas.py

@@ -0,0 +1,216 @@
+"""Pydantic models for all API request / response types."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# Call
+# ---------------------------------------------------------------------------
+
+class CallRequest(BaseModel):
+    phone_number: Optional[str] = None
+    purpose: str
+    system_prompt: Optional[str] = None
+    webhook_url: Optional[str] = None
+    max_duration_seconds: int = 300
+    language: str = "zh"
+    play_text: Optional[str] = None
+    require_confirmation: Optional[bool] = None
+
+
+class CallResponse(BaseModel):
+    task_id: str
+    status: str
+
+
+class CallStatus(BaseModel):
+    task_id: str
+    status: str
+    phone_number: Optional[str] = None
+    contact_name: Optional[str] = None
+    direction: Optional[str] = None
+    duration_seconds: Optional[float] = None
+    result: Optional[str] = None
+    summary: Optional[str] = None
+    started_at: Optional[str] = None
+    ended_at: Optional[str] = None
+    has_recording: Optional[bool] = None
+
+
+class CallConfirmRequest(BaseModel):
+    action: str
+    phone_number: Optional[str] = None
+    system_prompt: Optional[str] = None
+    purpose: Optional[str] = None
+
+
+class CallMessageRequest(BaseModel):
+    message: str
+
+
+class HangupResponse(BaseModel):
+    task_id: str
+    status: str
+
+
+# ---------------------------------------------------------------------------
+# Phone / Bluetooth
+# ---------------------------------------------------------------------------
+
+class PhoneStatus(BaseModel):
+    bluetooth_connected: bool = False
+    device_name: Optional[str] = None
+    device_address: Optional[str] = None
+    battery_level: Optional[int] = None
+    signal_strength: Optional[int] = None
+    operator: Optional[str] = None
+    in_call: bool = False
+
+
+# ---------------------------------------------------------------------------
+# SMS
+# ---------------------------------------------------------------------------
+
+class SMSRequest(BaseModel):
+    phone_number: str
+    content: str
+
+
+class SMSRecord(BaseModel):
+    id: str
+    phone_number: str
+    contact_name: Optional[str] = None
+    direction: str
+    content: str
+    status: Optional[str] = None
+    timestamp: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Contacts
+# ---------------------------------------------------------------------------
+
+class ContactCreate(BaseModel):
+    name: str
+    phone: str
+    company: Optional[str] = None
+    title: Optional[str] = None
+    notes: Optional[str] = None
+    tags: Optional[list[str]] = None
+
+
+class ContactUpdate(BaseModel):
+    name: Optional[str] = None
+    phone: Optional[str] = None
+    company: Optional[str] = None
+    title: Optional[str] = None
+    notes: Optional[str] = None
+    tags: Optional[list[str]] = None
+
+
+class ContactRecord(BaseModel):
+    id: str
+    name: str
+    phone: str
+    company: Optional[str] = None
+    title: Optional[str] = None
+    notes: Optional[str] = None
+    tags: Optional[list[str]] = None
+    source: Optional[str] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Paginated wrapper
+# ---------------------------------------------------------------------------
+
+class PaginatedResponse(BaseModel):
+    items: list[Any] = Field(default_factory=list)
+    total: int = 0
+    page: int = 1
+    page_size: int = 20
+
+
+# ---------------------------------------------------------------------------
+# Stats
+# ---------------------------------------------------------------------------
+
+class StatsResponse(BaseModel):
+    total_calls: int = 0
+    total_duration_seconds: float = 0
+    avg_duration_seconds: float = 0
+    calls_today: int = 0
+    calls_this_week: int = 0
+    calls_by_result: dict[str, int] = Field(default_factory=dict)
+    calls_by_direction: dict[str, int] = Field(default_factory=dict)
+    total_sms_sent: int = 0
+    total_sms_received: int = 0
+    total_contacts: int = 0
+
+
+# ---------------------------------------------------------------------------
+# Webhook
+# ---------------------------------------------------------------------------
+
+class WebhookPayload(BaseModel):
+    task_id: str
+    type: str
+    status: str
+    phone_number: Optional[str] = None
+    contact_name: Optional[str] = None
+    direction: Optional[str] = None
+    duration_seconds: Optional[float] = None
+    transcript: Optional[list[dict[str, Any]]] = None
+    summary: Optional[str] = None
+    result: Optional[str] = None
+    ended_reason: Optional[str] = None
+    recording_url: Optional[str] = None
+    timestamp: Optional[str] = None
+    matched_contact: Optional[dict[str, Any]] = None
+    contact_info: Optional[dict[str, Any]] = None
+
+
+# ---------------------------------------------------------------------------
+# Dev Log
+# ---------------------------------------------------------------------------
+
+class DevLogCreate(BaseModel):
+    content: str
+    important: bool = False
+    urgent: bool = False
+    type: str = "需求"  # 需求 | BUG | 优化 | 重构 | 澄清 | 文档
+
+
+class DevLogUpdate(BaseModel):
+    content: Optional[str] = None
+    important: Optional[bool] = None
+    urgent: Optional[bool] = None
+    status: Optional[str] = None
+    type: Optional[str] = None
+
+
+class DevLogRecord(BaseModel):
+    id: str
+    content: str
+    important: bool = False
+    urgent: bool = False
+    type: str = "需求"
+    status: str = "pending"
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    completed_at: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+class ConfigUpdate(BaseModel):
+    """Arbitrary config update payload — accepts any key/value pairs."""
+
+    model_config = {"extra": "allow"}

package/extensions/services/web/server.py

@@ -0,0 +1,332 @@
+"""
+Web Management HTTP server.
+Full web UI with all AI Phone Agent API endpoints.
+Exposes /health, /status, static frontend, and all /api/* routes.
+Connects to Event Hub via WebSocket for event publishing and subscription.
+Sends periodic heartbeat to Registry and test events to Event Hub.
+"""
+
+import asyncio
+import json
+import logging
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+import httpx
+import websockets
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from vendor import config as cfg
+from vendor.bluetooth.manager import BluetoothManager
+from vendor.task.manager import TaskManager
+from vendor.tools.registry import init_registry
+
+from routes.routes_call import router as call_router
+from routes.routes_phone import router as phone_router
+from routes.routes_config import router as config_router
+from routes.routes_sms import router as sms_router
+from routes.routes_contacts import router as contacts_router
+from routes.routes_stats import router as stats_router
+from routes.routes_voicechat import router as voicechat_router
+from routes.routes_devlog import router as devlog_router
+
+logger = logging.getLogger(__name__)
+
+
+class WebServer:
+
+    def __init__(self, token: str = "", registry_url: str = "",
+                 event_hub_ws: str = "",
+                 host: str = "0.0.0.0", port: int = 0, boot_t0: float = 0):
+        self.token = token
+        self.registry_url = registry_url
+        self.event_hub_ws = event_hub_ws
+        self.host = host
+        self.port = port
+        self.boot_t0 = boot_t0
+        self._ws_task: asyncio.Task | None = None
+        self._heartbeat_task: asyncio.Task | None = None
+        self._test_task: asyncio.Task | None = None
+        self._ws: object | None = None
+        self._ready_sent = False
+        self._shutting_down = False
+        self._uvicorn_server = None  # set by entry.py for graceful shutdown
+        self._start_time = time.time()
+        self.bt_manager: BluetoothManager | None = None
+        self.task_manager: TaskManager | None = None
+        self.app = self._create_app()
+
+    def _create_app(self) -> FastAPI:
+        app = FastAPI(title="Kite Web Management", docs_url="/docs", redoc_url=None)
+        server = self
+
+        @app.on_event("startup")
+        async def _startup():
+            # Load configuration
+            cfg.load_config()
+            load_err = cfg.get_load_error()
+            if load_err:
+                print(f"[web] 配置加载失败，无法启动:\n  {load_err}")
+                # Schedule graceful exit instead of crashing
+                if server._uvicorn_server:
+                    server._uvicorn_server.should_exit = True
+                return
+
+            # Ensure data directories exist
+            base = cfg.data_dir()
+            for sub in ("sms", "contacts", "tasks", "config", "devlog", "users", "tools"):
+                (base / sub).mkdir(parents=True, exist_ok=True)
+
+            logging.basicConfig(
+                level=logging.INFO,
+                format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
+            )
+
+            # Initialize tool registry
+            registry = init_registry()
+            app.state.tool_registry = registry
+
+            # Initialize managers
+            server.bt_manager = BluetoothManager()
+            server.task_manager = TaskManager(server.bt_manager)
+
+            app.state.bt_manager = server.bt_manager
+            app.state.task_manager = server.task_manager
+
+            # Start bluetooth auto-connect in background
+            asyncio.create_task(server.bt_manager.start())
+
+            logger.info("Web Management: managers initialized")
+
+            # Start background tasks directly
+            server._heartbeat_task = asyncio.create_task(server._heartbeat_loop())
+            if server.event_hub_ws:
+                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._heartbeat_task:
+                server._heartbeat_task.cancel()
+            if server._ws_task:
+                server._ws_task.cancel()
+            if server._test_task:
+                server._test_task.cancel()
+            if server._ws:
+                await server._ws.close()
+            if server.bt_manager:
+                await server.bt_manager.stop()
+            print("[web] Shutdown complete")
+
+        # Health and status endpoints
+        @app.get("/health")
+        async def health():
+            return {
+                "status": "healthy",
+                "details": {
+                    "event_hub_connected": server._ws is not None,
+                    "uptime_seconds": round(time.time() - server._start_time),
+                },
+            }
+
+        @app.get("/status")
+        async def status():
+            return {
+                "module": "web",
+                "status": "running",
+                "event_hub_connected": server._ws is not None,
+                "uptime_seconds": round(time.time() - server._start_time),
+            }
+
+        # Mount all API routes
+        app.include_router(call_router, prefix="/api")
+        app.include_router(phone_router, prefix="/api")
+        app.include_router(config_router, prefix="/api")
+        app.include_router(sms_router, prefix="/api")
+        app.include_router(contacts_router, prefix="/api")
+        app.include_router(stats_router, prefix="/api")
+        app.include_router(voicechat_router)  # no prefix (has own /ws/ and /api/ paths)
+        app.include_router(devlog_router, prefix="/api")
+
+        # Serve frontend static files
+        static_dir = Path(__file__).parent / "static"
+        if static_dir.exists():
+            app.mount("/", StaticFiles(directory=str(static_dir), html=True), name="web")
+
+        return app
+
+    # ── Event Hub WebSocket client ──
+
+    async def _ws_loop(self):
+        """Connect to Event Hub, subscribe, and listen. Reconnect on failure."""
+        retry_delay = 0.5  # start with 0.5s
+        max_delay = 30  # cap at 30s
+        while not self._shutting_down:
+            try:
+                await self._ws_connect()
+                retry_delay = 0.5  # reset on successful connection
+            except asyncio.CancelledError:
+                return
+            except Exception as e:
+                print(f"[web] Event Hub connection error: {e}, retrying in {retry_delay:.1f}s")
+            self._ws = None
+            if self._shutting_down:
+                return
+            await asyncio.sleep(retry_delay)
+            retry_delay = min(retry_delay * 2, max_delay)  # exponential backoff
+
+    async def _ws_connect(self):
+        """Single WebSocket session: connect, subscribe, receive loop."""
+        url = f"{self.event_hub_ws}?token={self.token}&id=web"
+        print(f"[web] WS connecting to {self.event_hub_ws}")
+        async with websockets.connect(url, open_timeout=3, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
+            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 Event Hub{elapsed_str}")
+
+            # Subscribe to module lifecycle events + shutdown
+            await ws.send(json.dumps({
+                "type": "subscribe",
+                "events": ["module.started", "module.stopped", "module.shutdown"],
+            }))
+
+            # Send module.ready (once) so Launcher knows we're up
+            if not self._ready_sent:
+                ready_msg = {
+                    "type": "event",
+                    "event_id": str(uuid.uuid4()),
+                    "event": "module.ready",
+                    "source": "web",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "data": {
+                        "module_id": "web",
+                        "graceful_shutdown": True,
+                    },
+                }
+                await ws.send(json.dumps(ready_msg))
+                self._ready_sent = 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,
+                    },
+                })
+                print(f"[web] \033[32m✓ Web UI ready: {access_url}\033[0m")
+
+            # Receive loop
+            async for raw in ws:
+                try:
+                    msg = json.loads(raw)
+                except (json.JSONDecodeError, TypeError):
+                    continue
+
+                try:
+                    msg_type = msg.get("type", "")
+                    if msg_type == "event":
+                        event_name = msg.get("event", "")
+                        if event_name == "module.shutdown":
+                            target = (msg.get("data") if isinstance(msg.get("data"), dict) else {}).get("module_id", "")
+                            if target == "web":
+                                await self._handle_shutdown(ws)
+                                return
+                    elif msg_type == "ack":
+                        pass  # publish confirmed
+                    elif msg_type == "error":
+                        print(f"[web] Event Hub error: {msg.get('message')}")
+                except Exception as e:
+                    print(f"[web] 事件处理异常（已忽略）: {e}")
+
+    async def _handle_shutdown(self, ws):
+        """Handle module.shutdown: ack → cleanup → ready → exit."""
+        print("[web] Received module.shutdown")
+        self._shutting_down = True
+
+        # Step 1: Send ack
+        await self._publish_event({
+            "event": "module.shutdown.ack",
+            "data": {"module_id": "web", "estimated_cleanup": 2},
+        })
+        print("[web] shutdown ack sent")
+
+        # Step 2: Cleanup (cancel background tasks)
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+        if self._test_task:
+            self._test_task.cancel()
+        if self.bt_manager:
+            await self.bt_manager.stop()
+
+        # Step 3: Send ready (before closing WS!)
+        await self._publish_event({
+            "event": "module.shutdown.ready",
+            "data": {"module_id": "web"},
+        })
+        print("[web] Shutdown complete")
+
+        # Step 4: Trigger uvicorn exit (WS will close when uvicorn shuts down)
+        if self._uvicorn_server:
+            self._uvicorn_server.should_exit = True
+
+    async def _publish_event(self, event: dict):
+        """Publish an event to Event Hub via WebSocket."""
+        if not self._ws:
+            return
+        msg = {
+            "type": "event",
+            "event_id": str(uuid.uuid4()),
+            "event": event.get("event", ""),
+            "source": "web",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "data": event.get("data", {}),
+        }
+        try:
+            await self._ws.send(json.dumps(msg))
+        except Exception as e:
+            print(f"[web] Failed to publish event: {e}")
+
+    # ── Heartbeat to Registry ──
+
+    async def _heartbeat_loop(self):
+        """Send heartbeat to Registry every 30 seconds."""
+        while True:
+            await asyncio.sleep(30)
+            try:
+                async with httpx.AsyncClient() as client:
+                    await client.post(
+                        f"{self.registry_url}/modules",
+                        json={"action": "heartbeat", "module_id": "web"},
+                        headers={"Authorization": f"Bearer {self.token}"},
+                        timeout=5,
+                    )
+                print("[web] heartbeat sent")
+            except Exception:
+                pass
+
+    # ── 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")