237 lines
8.1 KiB
Python
237 lines
8.1 KiB
Python
"""Voice endpoints — Gemini interaction, local TTS, prompt management."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
|
|
from fastapi import APIRouter, HTTPException
|
|
from pydantic import BaseModel
|
|
|
|
from Project.Sanad.core.config_loader import section as _cfg_section
|
|
from Project.Sanad.core.logger import get_logger
|
|
|
|
log = get_logger("voice_route")
|
|
|
|
router = APIRouter()
|
|
|
|
_VR = _cfg_section("dashboard", "voice_route")
|
|
_API = _cfg_section("dashboard", "api_input")
|
|
# MAX_TEXT_LEN — SINGLE SOURCE in dashboard.api_input
|
|
MAX_TEXT_LEN = _API.get("max_text_len", 2000)
|
|
_API_KEY_MASK_VISIBLE = _VR.get("api_key_mask_visible", 4)
|
|
|
|
|
|
def _mask_api_key(key: str) -> str:
|
|
"""Mask an API key for display — keeps 4 chars on each end.
|
|
|
|
Examples:
|
|
"" → ""
|
|
"AIza123" → "*******" (≤8 chars = full mask)
|
|
"AIzaSy...kqf8" → "AIza***...kqf8" (>8 chars = partial mask)
|
|
"""
|
|
if not key:
|
|
return ""
|
|
if len(key) <= 8:
|
|
return "*" * len(key)
|
|
return f"{key[:4]}{'*' * (len(key) - 8)}{key[-4:]}"
|
|
|
|
|
|
class TextPayload(BaseModel):
|
|
text: str
|
|
engine: str = "gemini" # "gemini" | "local"
|
|
|
|
|
|
@router.get("/status")
|
|
async def voice_status():
|
|
from Project.Sanad.main import voice_client, local_tts
|
|
return {
|
|
"gemini": voice_client.status() if voice_client else {},
|
|
"local_tts": local_tts.status() if local_tts else {},
|
|
}
|
|
|
|
|
|
@router.post("/generate")
|
|
async def generate_speech(payload: TextPayload):
|
|
"""Generate speech from text using Gemini or local TTS."""
|
|
if not payload.text.strip():
|
|
raise HTTPException(400, "Text cannot be empty.")
|
|
if len(payload.text) > MAX_TEXT_LEN:
|
|
raise HTTPException(413, f"Text too long (max {MAX_TEXT_LEN} chars).")
|
|
|
|
from Project.Sanad.main import voice_client, local_tts, audio_mgr
|
|
|
|
if payload.engine == "local":
|
|
if local_tts is None:
|
|
raise HTTPException(503, "Local TTS not available.")
|
|
pcm = await asyncio.to_thread(local_tts.synthesize, payload.text)
|
|
if audio_mgr:
|
|
await asyncio.to_thread(audio_mgr.play_pcm, pcm, 1, 16000, 2)
|
|
return {
|
|
"ok": True,
|
|
"engine": "local",
|
|
"duration_sec": round(len(pcm) / (16000 * 2), 3),
|
|
}
|
|
else:
|
|
if voice_client is None:
|
|
raise HTTPException(503, "Voice client not initialized.")
|
|
if not voice_client.connected:
|
|
try:
|
|
await voice_client.connect()
|
|
except Exception:
|
|
raise HTTPException(503, "Gemini not connected and reconnect failed.")
|
|
# Check session ownership — TypedReplay or live loop may hold it
|
|
if voice_client.session_owner is not None:
|
|
raise HTTPException(
|
|
409,
|
|
f"Voice session busy (owned by {voice_client.session_owner})",
|
|
)
|
|
try:
|
|
audio_bytes, text_parts = await voice_client.send_text(
|
|
payload.text, owner="voice_route"
|
|
)
|
|
except RuntimeError as exc:
|
|
raise HTTPException(503, str(exc))
|
|
except Exception as exc:
|
|
raise HTTPException(502, f"Gemini communication error: {exc}")
|
|
if audio_bytes and audio_mgr:
|
|
await asyncio.to_thread(audio_mgr.play_pcm, audio_bytes, 1, 24000, 2)
|
|
return {
|
|
"ok": True,
|
|
"engine": "gemini",
|
|
"has_audio": bool(audio_bytes),
|
|
"text_response": text_parts,
|
|
}
|
|
|
|
|
|
@router.post("/connect")
|
|
async def connect_gemini():
|
|
from Project.Sanad.main import voice_client
|
|
if voice_client is None:
|
|
raise HTTPException(503, "Voice client not initialized.")
|
|
try:
|
|
await voice_client.connect()
|
|
except Exception as exc:
|
|
raise HTTPException(502, f"Gemini connection failed: {exc}")
|
|
return {"connected": voice_client.connected}
|
|
|
|
|
|
@router.post("/disconnect")
|
|
async def disconnect_gemini():
|
|
from Project.Sanad.main import voice_client
|
|
if voice_client:
|
|
await voice_client.disconnect()
|
|
return {"connected": False}
|
|
|
|
|
|
# ─────────────────────── Gemini API key management ───────────────────────
|
|
|
|
class ApiKeyPayload(BaseModel):
|
|
api_key: str
|
|
|
|
|
|
@router.get("/api-key")
|
|
async def get_api_key():
|
|
"""Return the current Gemini API key in masked form.
|
|
|
|
Never returns the full key. Response:
|
|
{
|
|
"has_key": true,
|
|
"masked": "AIza***...kqf8",
|
|
"length": 39,
|
|
"source": "config_file" | "default"
|
|
}
|
|
"""
|
|
import Project.Sanad.config as cfg_mod
|
|
key = getattr(cfg_mod, "GEMINI_API_KEY", "") or ""
|
|
# Detect where the value came from (persisted override vs module default)
|
|
try:
|
|
from Project.Sanad.config import load_config
|
|
stored = load_config().get("gemini", {}) or {}
|
|
source = "config_file" if stored.get("api_key") else "default"
|
|
except Exception:
|
|
source = "default"
|
|
return {
|
|
"has_key": bool(key),
|
|
"masked": _mask_api_key(key),
|
|
"length": len(key),
|
|
"source": source,
|
|
}
|
|
|
|
|
|
@router.post("/api-key")
|
|
async def update_api_key(payload: ApiKeyPayload):
|
|
"""Update the Gemini API key — persists to data/motions/config.json and
|
|
hot-swaps the in-memory value so the next Gemini connect uses it.
|
|
|
|
Also disconnects any currently-connected Gemini session so that the
|
|
next reconnect picks up the new key cleanly. Returns the NEW masked
|
|
key + a flag telling the dashboard to trigger a reconnect.
|
|
"""
|
|
key = payload.api_key.strip()
|
|
if not key:
|
|
raise HTTPException(400, "API key cannot be empty.")
|
|
if len(key) < 20:
|
|
raise HTTPException(400, "API key looks too short.")
|
|
if not key.startswith("AIza"):
|
|
raise HTTPException(
|
|
400,
|
|
"Gemini API keys normally start with 'AIza'. "
|
|
"Double-check you're pasting a Google AI Studio key.",
|
|
)
|
|
|
|
# Persist to data/motions/config.json (atomic temp-then-replace)
|
|
try:
|
|
from Project.Sanad.config import load_config, save_config
|
|
cfg = load_config() or {}
|
|
gemini_cfg = cfg.get("gemini") if isinstance(cfg.get("gemini"), dict) else {}
|
|
gemini_cfg["api_key"] = key
|
|
cfg["gemini"] = gemini_cfg
|
|
save_config(cfg)
|
|
except Exception as exc:
|
|
log.exception("Failed to persist API key to config.json")
|
|
raise HTTPException(500, f"Could not save config: {exc}")
|
|
|
|
# Hot-swap the in-memory module globals.
|
|
# Both Project.Sanad.config AND Project.Sanad.voice.gemini_client
|
|
# have their OWN reference to GEMINI_API_KEY (the latter was created
|
|
# at `from Project.Sanad.config import GEMINI_API_KEY` at import time).
|
|
# Python's `from X import Y` binds a local name — updating config.Y
|
|
# alone does NOT propagate to the importer, so we must patch both.
|
|
try:
|
|
import Project.Sanad.config as _cfg_mod
|
|
_cfg_mod.GEMINI_API_KEY = key
|
|
except Exception:
|
|
log.exception("could not patch config.GEMINI_API_KEY")
|
|
|
|
try:
|
|
import Project.Sanad.voice.gemini_client as _gc
|
|
_gc.GEMINI_API_KEY = key
|
|
except Exception:
|
|
log.exception("could not patch gemini_client.GEMINI_API_KEY")
|
|
|
|
# Disconnect any live session so reconnect uses the new key.
|
|
from Project.Sanad.main import voice_client
|
|
was_connected = False
|
|
if voice_client is not None:
|
|
was_connected = bool(getattr(voice_client, "connected", False))
|
|
if was_connected:
|
|
try:
|
|
await voice_client.disconnect()
|
|
except Exception:
|
|
log.exception("disconnect during api-key swap failed")
|
|
|
|
log.info("Gemini API key updated (length=%d) source=config_file", len(key))
|
|
|
|
return {
|
|
"ok": True,
|
|
"masked": _mask_api_key(key),
|
|
"length": len(key),
|
|
"source": "config_file",
|
|
"was_connected": was_connected,
|
|
"message": (
|
|
"API key saved. Click 'Connect' to reopen the Gemini session with "
|
|
"the new key. Any running Live Gemini subprocess must be restarted "
|
|
"separately (Stop → Start) to pick up the new key."
|
|
),
|
|
}
|