Upload 3 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 ASR (speech-to-text):** a language can route its voice input to a different ASR engine — useful because Qwen's `qwen3-asr-flash` doesn't cover Yoruba, while Whisper does. Set `asr_base_url` / `asr_api_key` / `asr_model` on the language (or via env `ASR_<LANGID>_BASE_URL` etc.), and it uses that OpenAI-compatible `/audio/transcriptions` endpoint with the language's `asr_lang` hint. Yoruba ships pointed at a Whisper model (`whisper-large-v3`, hint `yo`); set `ASR_YORUBA_BASE_URL` to any OpenAI-compatible Whisper endpoint (e.g. `https://api.groq.com/openai/v1` or `https://api.openai.com/v1`) plus `ASR_YORUBA_API_KEY`. A language with its own `asr_base_url` never inherits the global Qwen ASR endpoint.
+
 **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.

app.py

@@ -105,6 +105,12 @@ def apply_env_overrides(cfg):
             lang["tts_model"] = _env(f"TTS_{lid}_MODEL")
         if _env(f"TTS_{lid}_VOICE"):
             lang["tts_voice"] = _env(f"TTS_{lid}_VOICE")
+        if _env(f"ASR_{lid}_BASE_URL"):
+            lang["asr_base_url"] = _env(f"ASR_{lid}_BASE_URL")
+        if _env(f"ASR_{lid}_API_KEY"):
+            lang["asr_api_key"] = _env(f"ASR_{lid}_API_KEY")
+        if _env(f"ASR_{lid}_MODEL"):
+            lang["asr_model"] = _env(f"ASR_{lid}_MODEL")
 
     return cfg
 
@@ -193,6 +199,30 @@ def get_lang_config(lang_id: str) -> dict:
     return langs[0] if langs else {}
 
 
+def get_asr_config(lang_id: str) -> dict:
+    """Resolve the ASR endpoint for a language. A language may carry its own
+    asr_base_url / asr_api_key / asr_model (e.g. Yoruba -> a Whisper endpoint).
+    If a language sets its own asr_base_url it fully overrides the global block,
+    so it never inherits the Qwen URL/key for a different engine."""
+    lang = get_lang_config(lang_id)
+    g = CONFIG.get("asr", {})
+    if lang.get("asr_base_url"):
+        base_url = lang.get("asr_base_url")
+        api_key = lang.get("asr_api_key") or ""
+        model = lang.get("asr_model") or "whisper-large-v3"
+    else:
+        base_url = g.get("base_url", "")
+        api_key = g.get("api_key", "")
+        model = g.get("model", "")
+    return {
+        "mode": lang.get("asr_mode") or g.get("mode", "api"),
+        "base_url": base_url or "",
+        "api_key": api_key or "",
+        "model": model or "",
+        "lang_hint": lang.get("asr_lang") or "auto",
+    }
+
+
 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
@@ -228,21 +258,31 @@ _local_whisper = None
 
 
 @app.post("/api/asr")
-async def transcribe_audio(audio: UploadFile = File(...), language: str = Form(default="auto")):
+async def transcribe_audio(
+    audio: UploadFile = File(...),
+    language: str = Form(default="auto"),
+    lang_id: str = Form(default=""),
+):
     """
-    Transcribe audio. Two modes:
-      - mode=api  → POST to OpenAI-compatible /audio/transcriptions
-      - mode=local → use local Whisper model (requires faster-whisper or openai-whisper)
+    Transcribe audio. Resolves a per-language ASR endpoint when lang_id is given
+    (e.g. Yoruda -> Whisper), otherwise uses the global ASR config.
+      - mode=api  → POST to OpenAI-compatible /audio/transcriptions (or DashScope)
+      - mode=local → use local Whisper model
     """
-    asr_cfg = CONFIG.get("asr", {})
-    mode = asr_cfg.get("mode", "api")
+    if lang_id:
+        acfg = get_asr_config(lang_id)
+        lang_hint = acfg["lang_hint"]
+    else:
+        acfg = CONFIG.get("asr", {})
+        lang_hint = language
 
+    mode = acfg.get("mode", "api")
     audio_bytes = await audio.read()
 
     if mode == "api":
-        return await _asr_via_api(audio_bytes, audio.filename, language, asr_cfg)
+        return await _asr_via_api(audio_bytes, audio.filename, lang_hint, acfg)
     else:
-        return await _asr_via_local(audio_bytes, audio.filename, language, asr_cfg)
+        return await _asr_via_local(audio_bytes, audio.filename, lang_hint, acfg)
 
 
 async def _asr_via_api(audio_bytes: bytes, filename: str, language: str, asr_cfg: dict):
@@ -1010,7 +1050,7 @@ async function processAudio(blob){
     // Get asr_lang hint from current language config
     const langCfg=languages.find(l=>l.id===currentLang)||{};
     const asrLang=langCfg.asr_lang||'auto';
-    const fd=new FormData();fd.append('audio',blob,'rec.webm');fd.append('language',asrLang||'auto');
+    const fd=new FormData();fd.append('audio',blob,'rec.webm');fd.append('language',asrLang||'auto');fd.append('lang_id',currentLang);
     const r=await fetch('/api/asr',{method:'POST',body:fd});
     if(!r.ok){const e=await r.json();throw new Error(e.detail||'ASR error')}
     const d=await r.json();

config.json

@@ -11,7 +11,11 @@
       "id": "yoruba",
       "label": "Yoruba",
       "asr_lang": "yo",
+      "asr_base_url": "",
+      "asr_model": "whisper-large-v3",
       "system_prompt": "You are a helpful AI assistant that converses in Yoruba. Understand the user's Yoruba input, respond in Yoruba naturally. Keep responses concise (2-4 sentences max) since they will be spoken aloud. Be warm and culturally appropriate.",
+      "tts_format": "custom",
+      "tts_base_url": "",
       "tts_model": ""
     }
   ],