@agentunion/kite 1.0.7 → 1.3.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,375 @@
+"""
+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 Kernel via WebSocket JSON-RPC 2.0 for event publishing and subscription.
+"""
+
+import asyncio
+import json
+import logging
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+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 = "", kernel_port: int = 0,
+                 host: str = "0.0.0.0", port: int = 0, boot_t0: float = 0):
+        self.token = token
+        self.kernel_port = kernel_port
+        self.host = host
+        self.port = port
+        self.boot_t0 = boot_t0
+        self._ws_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
+            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:
+                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": {
+                    "kernel_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
+
+    # ── Kernel WebSocket client ──
+
+    async def _ws_loop(self):
+        """Connect to Kernel, subscribe, register, 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] Kernel 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, register, subscribe, receive loop."""
+        url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={self.token}&id=web"
+        print(f"[web] WS connecting to Kernel")
+        async with websockets.connect(url, open_timeout=5, 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 Kernel{elapsed_str}")
+
+            # Subscribe to events
+            await self._rpc_call(ws, "event.subscribe", {
+                "events": [
+                    "module.started",
+                    "module.stopped",
+                    "module.shutdown",
+                ],
+            })
+
+            # 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",
+                "events_publish": {
+                    "web.test": {"description": "Test event from web module"},
+                    "web.started": {"description": "Web UI started with access URL"},
+                },
+                "events_subscribe": [
+                    "module.started",
+                    "module.stopped",
+                    "module.shutdown",
+                ],
+            })
+            print(f"[web] Registered to Kernel{elapsed_str}")
+
+            # Send module.ready (once) so Launcher knows we're up
+            if not self._ready_sent:
+                await self._rpc_call(ws, "event.publish", {
+                    "event_id": str(uuid.uuid4()),
+                    "event": "module.ready",
+                    "data": {
+                        "module_id": "web",
+                        "graceful_shutdown": True,
+                    },
+                })
+                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,
+                    },
+                })
+
+            # Receive loop
+            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
+
+                    if has_method and not has_id:
+                        # Event Notification
+                        await self._handle_event_notification(msg)
+                    elif has_method and has_id:
+                        # Incoming RPC request
+                        await self._handle_rpc_request(ws, msg)
+                    # Ignore RPC responses (we don't await them in this simple impl)
+                except Exception as e:
+                    print(f"[web] 消息处理异常（已忽略）: {e}")
+
+    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}
+        if params:
+            msg["params"] = params
+        await ws.send(json.dumps(msg))
+
+    async def _handle_event_notification(self, msg: dict):
+        """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
+        params = msg.get("params", {})
+        event_type = params.get("event", "")
+        data = params.get("data", {})
+
+        # Special handling for module.shutdown targeting web
+        if event_type == "module.shutdown" and data.get("module_id") == "web":
+            await self._handle_shutdown()
+            return
+
+        # Log other events
+        print(f"[web] Event received: {event_type}")
+
+    async def _handle_rpc_request(self, ws, msg: dict):
+        """Handle an incoming RPC request (web.* methods)."""
+        rpc_id = msg.get("id", "")
+        method = msg.get("method", "")
+        params = msg.get("params", {})
+
+        handlers = {
+            "health": lambda p: self._rpc_health(),
+            "status": lambda p: self._rpc_status(),
+        }
+        handler = handlers.get(method)
+        if handler:
+            try:
+                result = await handler(params)
+                await ws.send(json.dumps({"jsonrpc": "2.0", "id": rpc_id, "result": result}))
+            except Exception as e:
+                await ws.send(json.dumps({
+                    "jsonrpc": "2.0", "id": rpc_id,
+                    "error": {"code": -32603, "message": str(e)},
+                }))
+        else:
+            await ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": rpc_id,
+                "error": {"code": -32601, "message": f"Method not found: {method}"},
+            }))
+
+    async def _rpc_health(self) -> dict:
+        """RPC handler for web.health."""
+        return {
+            "status": "healthy",
+            "details": {
+                "uptime_seconds": round(time.time() - self._start_time),
+            },
+        }
+
+    async def _rpc_status(self) -> dict:
+        """RPC handler for web.status."""
+        return {
+            "module": "web",
+            "status": "running",
+            "uptime_seconds": round(time.time() - self._start_time),
+        }
+
+    async def _handle_shutdown(self):
+        """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._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 via RPC event.publish."""
+        if not self._ws:
+            return
+        await self._rpc_call(self._ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
+            "event": event.get("event", ""),
+            "data": event.get("data", {}),
+        })
+
+    # ── 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")