@agentunion/kite 1.0.6 → 1.2.0

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

@@ -0,0 +1,512 @@
+"""Routes for configuration and LLM model listing."""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import json
+import logging
+from typing import Any
+
+import httpx
+from fastapi import APIRouter, HTTPException, Query, WebSocket, WebSocketDisconnect
+from pydantic import BaseModel
+
+from vendor import config as cfg
+from routes.schemas import ConfigUpdate
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["config"])
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _mask_keys(obj: Any, depth: int = 0) -> Any:
+    """Recursively mask values whose key looks like a secret."""
+    if isinstance(obj, dict):
+        masked: dict[str, Any] = {}
+        for k, v in obj.items():
+            if any(s in k.lower() for s in ("api_key", "secret", "password", "token")):
+                if isinstance(v, str) and len(v) > 4:
+                    masked[k] = "****" + v[-4:]
+                elif isinstance(v, str) and v:
+                    masked[k] = "****"
+                else:
+                    masked[k] = v
+            else:
+                masked[k] = _mask_keys(v, depth + 1)
+        return masked
+    if isinstance(obj, list):
+        return [_mask_keys(item, depth + 1) for item in obj]
+    return obj
+
+
+# ---------------------------------------------------------------------------
+# Config endpoints
+# ---------------------------------------------------------------------------
+
+@router.get("/config")
+async def get_config():
+    """Return the current configuration (keys shown in plain text)."""
+    return copy.deepcopy(cfg.get_config())
+
+
+@router.put("/config")
+async def update_config(updates: ConfigUpdate):
+    """Merge updates into the runtime configuration and persist to disk."""
+    update_data = updates.model_dump(exclude_none=True)
+    if not update_data:
+        raise HTTPException(status_code=400, detail="No updates provided")
+    try:
+        new_config = cfg.update_config(update_data)
+        return copy.deepcopy(new_config)
+    except Exception as exc:
+        logger.exception("Failed to update config")
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Model listing
+# ---------------------------------------------------------------------------
+
+@router.get("/models")
+async def list_models(provider: str = Query(..., description="LLM provider: openai, claude, gemini")):
+    """Query a provider's API for available models and return ``[{id, name}]``."""
+    provider = provider.lower()
+    provider_cfg = cfg.get(f"llm.providers.{provider}")
+    if not provider_cfg:
+        raise HTTPException(status_code=400, detail=f"Unknown provider: {provider}")
+
+    base_url: str = provider_cfg.get("base_url", "")
+    api_key: str = provider_cfg.get("api_key", "")
+
+    if not api_key:
+        raise HTTPException(status_code=400, detail=f"API key not configured for {provider}")
+
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            if provider == "openai":
+                return await _fetch_openai_models(client, base_url, api_key)
+            elif provider == "claude":
+                return await _fetch_claude_models(client, base_url, api_key)
+            elif provider == "gemini":
+                return await _fetch_gemini_models(client, base_url, api_key)
+            else:
+                raise HTTPException(status_code=400, detail=f"Unsupported provider: {provider}")
+    except httpx.HTTPError as exc:
+        logger.exception("Failed to fetch models from %s", provider)
+        raise HTTPException(status_code=502, detail=f"Failed to fetch models from {provider}: {exc}")
+
+
+async def _fetch_openai_models(
+    client: httpx.AsyncClient, base_url: str, api_key: str
+) -> list[dict[str, str]]:
+    resp = await client.get(
+        f"{base_url.rstrip('/')}/models",
+        headers={"Authorization": f"Bearer {api_key}"},
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    models: list[dict[str, str]] = []
+    for m in data.get("data", []):
+        model_id: str = m.get("id", "")
+        if model_id:
+            models.append({"id": model_id, "name": model_id})
+    models.sort(key=lambda x: x["id"])
+    return models
+
+
+async def _fetch_claude_models(
+    client: httpx.AsyncClient, base_url: str, api_key: str
+) -> list[dict[str, str]]:
+    resp = await client.get(
+        f"{base_url.rstrip('/')}/models",
+        headers={
+            "x-api-key": api_key,
+            "anthropic-version": "2023-06-01",
+        },
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    models: list[dict[str, str]] = []
+    for m in data.get("data", []):
+        model_id = m.get("id", "")
+        display_name = m.get("display_name", model_id)
+        models.append({"id": model_id, "name": display_name})
+    models.sort(key=lambda x: x["id"])
+    return models
+
+
+async def _fetch_gemini_models(
+    client: httpx.AsyncClient, base_url: str, api_key: str
+) -> list[dict[str, str]]:
+    resp = await client.get(
+        f"{base_url.rstrip('/')}/models",
+        params={"key": api_key},
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    models: list[dict[str, str]] = []
+    for m in data.get("models", []):
+        model_name: str = m.get("name", "")
+        display_name: str = m.get("displayName", model_name)
+        model_id = model_name.removeprefix("models/")
+        models.append({"id": model_id, "name": display_name})
+    models.sort(key=lambda x: x["id"])
+    return models
+
+
+# ---------------------------------------------------------------------------
+# Chat test
+# ---------------------------------------------------------------------------
+
+class ChatRequest(BaseModel):
+    provider: str = "openai"
+    base_url: str = ""
+    api_key: str = ""
+    model: str = ""
+    temperature: float = 0.7
+    max_tokens: int = 1024
+    messages: list[dict[str, Any]] = []
+
+
+@router.post("/chat")
+async def chat_completion(req: ChatRequest):
+    """Send messages to an LLM and return the response. Used for model testing."""
+    if not req.api_key:
+        raise HTTPException(status_code=400, detail="API key is required")
+    if not req.messages:
+        raise HTTPException(status_code=400, detail="Messages cannot be empty")
+
+    provider = req.provider.lower()
+
+    try:
+        from conversation.llm import OpenAILLM, ClaudeLLM, GeminiLLM
+
+        if provider == "openai":
+            llm = OpenAILLM(
+                base_url=req.base_url or "https://api.openai.com/v1",
+                api_key=req.api_key,
+                model=req.model or "gpt-4o",
+                temperature=req.temperature,
+                max_tokens=req.max_tokens,
+            )
+        elif provider == "claude":
+            llm = ClaudeLLM(
+                base_url=req.base_url or "https://api.anthropic.com/v1",
+                api_key=req.api_key,
+                model=req.model or "claude-sonnet-4-20250514",
+                temperature=req.temperature,
+                max_tokens=req.max_tokens,
+            )
+        elif provider == "gemini":
+            llm = GeminiLLM(
+                base_url=req.base_url or "https://generativelanguage.googleapis.com/v1beta",
+                api_key=req.api_key,
+                model=req.model or "gemini-2.0-flash",
+                temperature=req.temperature,
+                max_tokens=req.max_tokens,
+            )
+        else:
+            raise HTTPException(status_code=400, detail=f"Unsupported provider: {provider}")
+
+        result = await llm.generate(req.messages)
+        return {"content": result.get("content", "")}
+
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Chat completion failed")
+        raise HTTPException(status_code=502, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# ASR real-time test via WebSocket
+# ---------------------------------------------------------------------------
+
+@router.websocket("/ws/asr-test")
+async def asr_test_websocket(ws: WebSocket):
+    """WebSocket endpoint for real-time ASR testing."""
+    from conversation.asr import create_asr_provider
+
+    await ws.accept()
+
+    asr = None
+    stats = {"audio_bytes": 0, "audio_chunks": 0, "asr_packets_sent": 0, "asr_responses": 0}
+
+    try:
+        test_provider = ""
+        test_resource_id = ""
+        test_sample_rate = 0
+        first_msg = await asyncio.wait_for(ws.receive(), timeout=5.0)
+        if "text" in first_msg and first_msg["text"]:
+            try:
+                config_data = json.loads(first_msg["text"])
+                if config_data.get("type") == "config":
+                    test_provider = config_data.get("provider", "")
+                    test_resource_id = config_data.get("resource_id", "")
+                    test_sample_rate = int(config_data.get("sample_rate", 0))
+                    logger.info("ASR test config: provider=%s, resource_id=%s, sample_rate=%s",
+                                test_provider, test_resource_id, test_sample_rate)
+            except (json.JSONDecodeError, ValueError):
+                pass
+
+        asr = create_asr_provider(
+            provider_override=test_provider or None,
+            resource_id_override=test_resource_id or None,
+            sample_rate_override=test_sample_rate or None,
+        )
+        actual_provider = test_provider or cfg.get("asr.provider", "unknown")
+        language = cfg.get("asr.whisper.language", "zh")
+
+        max_retries = 3
+        last_err = None
+        for attempt in range(1, max_retries + 1):
+            try:
+                await asr.start_stream(language)
+                last_err = None
+                break
+            except Exception as exc:
+                last_err = exc
+                logger.warning("ASR connect attempt %d/%d failed: %s", attempt, max_retries, exc)
+                if attempt < max_retries:
+                    await asyncio.sleep(0.5 * attempt)
+                    asr = create_asr_provider(
+                        provider_override=test_provider or None,
+                        resource_id_override=test_resource_id or None,
+                        sample_rate_override=test_sample_rate or None,
+                    )
+        if last_err:
+            await ws.send_json({"type": "error", "message": str(last_err)})
+            return
+
+        actual_sr = getattr(asr, "SAMPLE_RATE", 16000)
+
+        await ws.send_json({
+            "type": "ready",
+            "provider": actual_provider,
+            "sample_rate": actual_sr,
+            "resource_id": getattr(asr, "resource_id", ""),
+        })
+
+        last_interim = ""
+        last_stats_time = asyncio.get_event_loop().time()
+
+        while True:
+            message = await ws.receive()
+
+            if message["type"] == "websocket.disconnect":
+                break
+
+            if "bytes" in message and message["bytes"]:
+                chunk = message["bytes"]
+                stats["audio_bytes"] += len(chunk)
+                stats["audio_chunks"] += 1
+
+                prev_buf_len = len(getattr(asr, "_buffer", b""))
+                await asr.feed_audio(chunk)
+                new_buf_len = len(getattr(asr, "_buffer", b""))
+                if new_buf_len < prev_buf_len + len(chunk):
+                    bytes_consumed = prev_buf_len + len(chunk) - new_buf_len
+                    frame_size = getattr(asr, "BYTES_PER_FRAME", 6400)
+                    packets = bytes_consumed // frame_size if frame_size else 0
+                    stats["asr_packets_sent"] += packets
+
+                interim = await asr.get_interim_result()
+                if interim and interim != last_interim:
+                    last_interim = interim
+                    await ws.send_json({"type": "interim", "text": interim})
+
+                now = asyncio.get_event_loop().time()
+                if now - last_stats_time >= 0.5:
+                    last_stats_time = now
+                    duration_s = stats["audio_bytes"] / (actual_sr * 2)
+                    await ws.send_json({
+                        "type": "stats",
+                        "audio_bytes": stats["audio_bytes"],
+                        "audio_chunks": stats["audio_chunks"],
+                        "audio_duration": round(duration_s, 1),
+                        "asr_packets_sent": stats["asr_packets_sent"],
+                        "has_interim": bool(interim),
+                    })
+
+            elif "text" in message and message["text"]:
+                try:
+                    data = json.loads(message["text"])
+                except json.JSONDecodeError:
+                    continue
+
+                if data.get("type") == "stop":
+                    duration_s = stats["audio_bytes"] / (actual_sr * 2)
+                    await ws.send_json({
+                        "type": "stats",
+                        "audio_bytes": stats["audio_bytes"],
+                        "audio_chunks": stats["audio_chunks"],
+                        "audio_duration": round(duration_s, 1),
+                        "asr_packets_sent": stats["asr_packets_sent"],
+                        "has_interim": bool(last_interim),
+                        "getting_final": True,
+                    })
+                    final_text = await asr.get_result()
+                    await ws.send_json({"type": "final", "text": final_text})
+                    break
+
+    except WebSocketDisconnect:
+        logger.info("ASR test WebSocket disconnected")
+    except Exception as exc:
+        logger.exception("ASR test WebSocket error")
+        try:
+            await ws.send_json({"type": "error", "message": str(exc)})
+        except Exception:
+            pass
+    finally:
+        if asr:
+            try:
+                await asr.stop_stream()
+            except Exception:
+                pass
+        try:
+            await ws.close()
+        except Exception:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Audio diagnostic log upload
+# ---------------------------------------------------------------------------
+
+class AudioDiagLog(BaseModel):
+    log: str = ""
+    timestamp: str = ""
+
+
+@router.post("/audio-diag")
+async def upload_audio_diag(data: AudioDiagLog):
+    """Receive browser audio diagnostic logs."""
+    import os
+    log_dir = str(cfg.data_dir())
+    os.makedirs(log_dir, exist_ok=True)
+    log_path = os.path.join(log_dir, "audio_diag.log")
+    with open(log_path, "w", encoding="utf-8") as f:
+        f.write(f"=== Audio Diagnostic Log ===\n")
+        f.write(f"Timestamp: {data.timestamp}\n\n")
+        f.write(data.log)
+    logger.info("Audio diagnostic log saved to %s (%d bytes)", log_path, len(data.log))
+    return {"status": "ok", "path": log_path}
+
+
+# ---------------------------------------------------------------------------
+# TTS diagnostic log
+# ---------------------------------------------------------------------------
+
+class TTSDiagLog(BaseModel):
+    log: str = ""
+    provider: str = ""
+    error: str = ""
+    timestamp: str = ""
+
+
+@router.post("/tts-diag")
+async def upload_tts_diag(data: TTSDiagLog):
+    """Receive TTS test diagnostic logs from the browser."""
+    import os
+    log_dir = str(cfg.data_dir())
+    os.makedirs(log_dir, exist_ok=True)
+    log_path = os.path.join(log_dir, "tts_diag.log")
+    with open(log_path, "a", encoding="utf-8") as f:
+        f.write(f"\n=== TTS Diag [{data.timestamp}] provider={data.provider} ===\n")
+        if data.error:
+            f.write(f"Error: {data.error}\n")
+        f.write(data.log + "\n")
+    logger.info("TTS diag log appended to %s (provider=%s, error=%s)",
+                log_path, data.provider, data.error[:80] if data.error else "")
+    return {"status": "ok", "path": log_path}
+
+class TTSTestRequest(BaseModel):
+    provider: str = "edge-tts"
+    voice: str = ""
+    speed: float = 1.0
+    volume: float = 1.0
+    text: str = ""
+
+
+@router.post("/tts-test")
+async def tts_test(req: TTSTestRequest):
+    """Synthesize text and return base64-encoded audio for playback testing."""
+    if not req.text or not req.text.strip():
+        raise HTTPException(status_code=400, detail="Text cannot be empty")
+
+    from conversation.tts import create_tts_provider
+
+    overrides: dict[str, Any] = {}
+    provider = req.provider.lower()
+
+    if provider == "volcengine":
+        app_id = cfg.get("tts.volcengine.app_id") or cfg.get("asr.volcengine.app_id", "")
+        token = cfg.get("tts.volcengine.access_token") or cfg.get("asr.volcengine.access_token", "")
+        if not app_id or not token:
+            raise HTTPException(
+                status_code=400,
+                detail=f"火山引擎 TTS 缺少认证配置 (app_id={'有' if app_id else '空'}, access_token={'有' if token else '空'}). "
+                       f"请在 ASR 或 TTS 配置中填写 app_id 和 access_token.",
+            )
+        if req.voice:
+            overrides["voice_type"] = req.voice
+        overrides["speed_ratio"] = req.speed
+        overrides["volume_ratio"] = req.volume
+
+    elif provider == "tencent":
+        sid = cfg.get("tts.tencent.secret_id") or cfg.get("asr.tencent.secret_id", "")
+        skey = cfg.get("tts.tencent.secret_key") or cfg.get("asr.tencent.secret_key", "")
+        if not sid or not skey:
+            raise HTTPException(
+                status_code=400,
+                detail=f"腾讯云 TTS 缺少认证配置 (secret_id={'有' if sid else '空'}, secret_key={'有' if skey else '空'}). "
+                       f"请在 ASR 或 TTS 配置中填写 secret_id 和 secret_key.",
+            )
+        if req.voice:
+            overrides["voice_type"] = int(req.voice)
+        overrides["speed"] = req.speed
+        overrides["volume"] = req.volume
+
+    elif provider == "edge-tts":
+        if req.voice:
+            overrides["voice"] = req.voice
+        pct = int((req.speed - 1.0) * 100)
+        overrides["rate"] = f"{pct:+d}%"
+        vol_pct = int((req.volume - 1.0) * 100)
+        overrides["volume"] = f"{vol_pct:+d}%"
+
+    logger.info("TTS test: provider=%s, voice=%s, speed=%s, overrides=%s",
+                provider, req.voice, req.speed, list(overrides.keys()))
+
+    try:
+        tts = create_tts_provider(provider=provider, **overrides)
+        audio_data = await tts.synthesize(req.text)
+        if not audio_data:
+            raise HTTPException(status_code=500, detail="TTS returned empty audio")
+
+        import base64 as b64
+        audio_b64 = b64.b64encode(audio_data).decode()
+
+        content_type = "audio/mpeg"
+        if provider == "tencent":
+            codec = cfg.get("tts.tencent.codec", "pcm")
+            if codec == "pcm":
+                content_type = "audio/pcm"
+
+        return {
+            "audio": audio_b64,
+            "content_type": content_type,
+            "size": len(audio_data),
+        }
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("TTS test failed for provider=%s", provider)
+        detail = str(exc)
+        exc_type = type(exc).__name__
+        raise HTTPException(status_code=502, detail=f"[{exc_type}] {detail}")

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

@@ -0,0 +1,98 @@
+"""Routes for contact management."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, HTTPException, Query, Request
+
+from routes.schemas import (
+    ContactCreate,
+    ContactRecord,
+    ContactUpdate,
+    PaginatedResponse,
+)
+from vendor.storage import store
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["contacts"])
+
+
+@router.get("/contacts", response_model=PaginatedResponse)
+async def list_contacts(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(50, ge=1, le=200),
+    query: str | None = Query(None),
+):
+    """List contacts with optional search and pagination."""
+    items, total = await store.list_contacts(page=page, page_size=page_size, query=query)
+    return PaginatedResponse(items=items, total=total, page=page, page_size=page_size)
+
+
+@router.post("/contacts", response_model=ContactRecord)
+async def add_contact(contact: ContactCreate):
+    """Add a new contact."""
+    data = contact.model_dump(exclude_none=True)
+    record = await store.add_contact(data)
+    return ContactRecord(**record)
+
+
+@router.get("/contacts/{contact_id}", response_model=ContactRecord)
+async def get_contact(contact_id: str):
+    """Retrieve a single contact by ID."""
+    record = await store.get_contact(contact_id)
+    if record is None:
+        raise HTTPException(status_code=404, detail="Contact not found")
+    return ContactRecord(**record)
+
+
+@router.put("/contacts/{contact_id}", response_model=ContactRecord)
+async def update_contact(contact_id: str, updates: ContactUpdate):
+    """Update an existing contact."""
+    existing = await store.get_contact(contact_id)
+    if existing is None:
+        raise HTTPException(status_code=404, detail="Contact not found")
+
+    update_data = updates.model_dump(exclude_none=True)
+    if not update_data:
+        raise HTTPException(status_code=400, detail="No fields to update")
+
+    success = await store.update_contact(contact_id, update_data)
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to update contact")
+
+    updated = await store.get_contact(contact_id)
+    return ContactRecord(**updated)
+
+
+@router.delete("/contacts/{contact_id}")
+async def delete_contact(contact_id: str):
+    """Delete a contact by ID."""
+    success = await store.delete_contact(contact_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Contact not found")
+    return {"status": "deleted", "contact_id": contact_id}
+
+
+@router.post("/contacts/sync")
+async def sync_contacts(request: Request):
+    """Sync contacts from the connected phone via Bluetooth."""
+    bt = request.app.state.bt_manager
+    try:
+        contacts = await bt.sync_contacts()
+        added = 0
+        updated = 0
+        for c in contacts:
+            existing = await store.find_contact_by_phone(c.get("phone", ""))
+            if existing:
+                await store.update_contact(existing["id"], c)
+                updated += 1
+            else:
+                c["source"] = "phone_sync"
+                await store.add_contact(c)
+                added += 1
+        return {"status": "synced", "added": added, "updated": updated, "total": len(contacts)}
+    except Exception as exc:
+        logger.exception("Contact sync failed")
+        raise HTTPException(status_code=500, detail=str(exc))