Upload 2 files

README.md

@@ -125,6 +125,8 @@ The app auto-detects these DashScope endpoints and uses the native multimodal fo
 
 **Per-service override (only if services differ):** set any of `ASR_BASE_URL` / `LLM_BASE_URL` / `TTS_BASE_URL` and `ASR_API_KEY` / `LLM_API_KEY` / `TTS_API_KEY` to point a single service somewhere else. A per-service value wins over the shared `DASHSCOPE_*` value. Optional model/voice overrides: `ASR_MODEL`, `LLM_MODEL`, `TTS_MODEL`, `TTS_VOICE`.
 
+**Per-language TTS backend:** each language can use its own TTS engine, so e.g. English speaks via Qwen while Yoruba speaks via a self-hosted model. A language uses its own endpoint when it sets `tts_format` / `tts_base_url` / `tts_api_key` (in `config.json` or via env). Supported `tts_format` values: `dashscope`, `openai`, or `custom`. The `custom` format POSTs `{text, speed}` to the URL **verbatim** (so an API Gateway invoke URL like `.../prod/tts` is used exactly as given), sends both `Authorization: Bearer` and `x-api-key` when a key is set, and accepts either raw audio (`audio/*`) or JSON carrying base64 audio (key `audio` / `audio_base64` / `data` / `wav` / `audio_content`). Per-language env vars follow the pattern `TTS_<LANGID>_BASE_URL`, `TTS_<LANGID>_API_KEY`, `TTS_<LANGID>_FORMAT`, `TTS_<LANGID>_MODEL`, `TTS_<LANGID>_VOICE` — e.g. `TTS_YORUBA_BASE_URL`. A `custom`-format language never inherits the global Qwen URL/key, so a missing value fails safely instead of sending text to the wrong engine.
+
 Leave the placeholder values in `config.json` as they are — they're scrubbed automatically at load, and the Secrets fill in the real values.
 
 **Step 3: Open the Space**

app.py

@@ -89,6 +89,23 @@ def apply_env_overrides(cfg):
     tts["model"] = _env("TTS_MODEL") or tts.get("model", "")
     tts["voice"] = _env("TTS_VOICE") or tts.get("voice", "default")
 
+    # Per-language TTS endpoint overrides, e.g. TTS_YORUBA_BASE_URL / _API_KEY /
+    # _FORMAT / _MODEL / _VOICE. Lets each language point at its own TTS backend.
+    for lang in cfg.get("languages", []):
+        lid = (lang.get("id") or "").upper()
+        if not lid:
+            continue
+        if _env(f"TTS_{lid}_BASE_URL"):
+            lang["tts_base_url"] = _env(f"TTS_{lid}_BASE_URL")
+        if _env(f"TTS_{lid}_API_KEY"):
+            lang["tts_api_key"] = _env(f"TTS_{lid}_API_KEY")
+        if _env(f"TTS_{lid}_FORMAT"):
+            lang["tts_format"] = _env(f"TTS_{lid}_FORMAT")
+        if _env(f"TTS_{lid}_MODEL"):
+            lang["tts_model"] = _env(f"TTS_{lid}_MODEL")
+        if _env(f"TTS_{lid}_VOICE"):
+            lang["tts_voice"] = _env(f"TTS_{lid}_VOICE")
+
     return cfg
 
 
@@ -176,6 +193,33 @@ def get_lang_config(lang_id: str) -> dict:
     return langs[0] if langs else {}
 
 
+def get_tts_config(lang_id: str) -> dict:
+    """Resolve the TTS endpoint for a language. A language may carry its own
+    tts_base_url / tts_api_key / tts_format / tts_model / tts_voice; anything not
+    set falls back to the global `tts` block — EXCEPT for `custom` format, which
+    never inherits the global (Qwen) URL/key, so a misconfig can't accidentally
+    POST Yoruba text at the DashScope endpoint."""
+    lang = get_lang_config(lang_id)
+    g = CONFIG.get("tts", {})
+    fmt = (lang.get("tts_format") or "").strip().lower()
+
+    if fmt == "custom":
+        base_url = lang.get("tts_base_url") or ""
+        api_key = lang.get("tts_api_key") or ""
+    else:
+        base_url = lang.get("tts_base_url") or g.get("base_url", "")
+        api_key = lang.get("tts_api_key") or g.get("api_key", "")
+
+    return {
+        "base_url": base_url or "",
+        "api_key": api_key or "",
+        "model": (lang.get("tts_model") or g.get("model", "") or ""),
+        "voice": (lang.get("tts_voice") or g.get("voice", "default") or "default"),
+        "format": fmt,
+        "speed": g.get("speed", 1.0),
+    }
+
+
 # ============================================================
 # API Routes — ASR
 # ============================================================
@@ -413,6 +457,81 @@ _LANG_TYPE_MAP = {
 }
 
 
+async def _tts_custom(base_url: str, api_key: str, text: str, speed: float):
+    """POST to a custom TTS service and return audio. Handles common shapes:
+      - URL is used verbatim (append /tts only if a bare host is given), so an
+        API Gateway invoke URL like .../prod/tts works as-is.
+      - Auth: sends both `Authorization: Bearer` and `x-api-key` when a key is
+        provided (harmless extras are ignored; covers API Gateway usage plans).
+      - Response: raw audio bytes (audio/*) OR JSON containing base64 audio under
+        a common key (audio / audio_base64 / data / wav / audio_content)."""
+    if not base_url:
+        return JSONResponse(status_code=200, content={
+            "status": "tts_not_configured",
+            "message": "Custom TTS endpoint not set for this language.",
+            "text": text,
+        })
+
+    from urllib.parse import urlparse
+    parsed = urlparse(base_url)
+    url = base_url if parsed.path.strip("/") else base_url.rstrip("/") + "/tts"
+
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+        headers["x-api-key"] = api_key
+
+    # F5-TTS can be slow on the first (cold) call — allow a generous timeout.
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        resp = await client.post(url, headers=headers, json={"text": text, "speed": speed})
+        if resp.status_code != 200:
+            return JSONResponse(status_code=200, content={
+                "status": "tts_error",
+                "message": f"Custom TTS {resp.status_code}: {resp.text[:300]}",
+                "text": text,
+            })
+
+        ct = resp.headers.get("content-type", "")
+        if ct.startswith("audio/"):
+            return Response(content=resp.content, media_type=ct)
+
+        # Otherwise expect JSON carrying base64 audio.
+        try:
+            data = resp.json()
+        except Exception:
+            return JSONResponse(status_code=200, content={
+                "status": "tts_error",
+                "message": f"Unexpected TTS response (content-type: {ct or 'unknown'})",
+                "text": text,
+            })
+
+        import base64 as b64
+        b64str = None
+        if isinstance(data, dict):
+            for k in ("audio_base64", "audio", "data", "wav", "audio_content", "b64_audio"):
+                v = data.get(k)
+                if isinstance(v, str) and len(v) > 100:
+                    b64str = v
+                    break
+        if not b64str:
+            return JSONResponse(status_code=200, content={
+                "status": "tts_error",
+                "message": "No base64 audio found in JSON TTS response.",
+                "text": text,
+            })
+        if b64str.startswith("data:") and "," in b64str:
+            b64str = b64str.split(",", 1)[1]
+        try:
+            audio = b64.b64decode(b64str)
+        except Exception as e:
+            return JSONResponse(status_code=200, content={
+                "status": "tts_error",
+                "message": f"Could not decode base64 audio: {e}",
+                "text": text,
+            })
+        return Response(content=audio, media_type="audio/wav")
+
+
 @app.post("/api/tts")
 async def text_to_speech(req: TTSRequest):
     """
@@ -425,25 +544,26 @@ async def text_to_speech(req: TTSRequest):
       2. Global tts.model
       3. Default: qwen3-tts-flash (DashScope) or tts-1 (OpenAI)
     """
-    tts_cfg = CONFIG.get("tts", {})
-    base_url = tts_cfg.get("base_url", "").strip().rstrip("/")
-    api_key = tts_cfg.get("api_key", "").strip()
-
-    # Resolve model: per-language override or global
-    lang_cfg = get_lang_config(req.language)
-    model = lang_cfg.get("tts_model", "").strip() or tts_cfg.get("model", "").strip()
+    tcfg = get_tts_config(req.language)
+    base_url = tcfg["base_url"].strip().rstrip("/")
+    api_key = tcfg["api_key"].strip()
+    model = tcfg["model"].strip()
+    fmt = tcfg["format"]
 
-    if not base_url or not api_key:
+    if fmt != "custom" and (not base_url or not api_key):
         return JSONResponse(status_code=200, content={
             "status": "tts_not_configured",
             "message": "TTS not configured. Set TTS Base URL and API Key in Settings.",
             "text": req.text,
         })
 
-    voice = req.voice or tts_cfg.get("voice", "default")
-    speed = tts_cfg.get("speed", 1.0)
+    voice = req.voice or tcfg["voice"]
+    speed = tcfg["speed"]
 
     try:
+        if fmt == "custom":
+            # === Custom HTTP TTS service (e.g. self-hosted F5-TTS Yoruba) ===
+            return await _tts_custom(base_url, api_key, req.text, speed)
         if _is_dashscope_maas(base_url):
             # === DashScope Native TTS Format ===
             tts_endpoint = _dashscope_tts_url(base_url)