fix(stt): add batch language routing fallback (#5293)

Route Char Pro multi-language batch requests through Deepgram language detection fallback when Soniox is unavailable, and allow longer Soniox async polling.

Author: ComputelessComputer

crates/owhisper-client/src/adapter/deepgram/batch.rs

@@ -259,6 +259,30 @@ mod tests {
         assert!(query.contains("multichannel=true"));
     }
 
+    #[test]
+    fn batch_url_restricts_detect_language_for_unsupported_multi_language() {
+        let params = ListenParams {
+            languages: vec![
+                hypr_language::ISO639::En.into(),
+                hypr_language::ISO639::Pl.into(),
+            ],
+            ..Default::default()
+        };
+
+        let url = build_batch_url(
+            "https://api.deepgram.com/v1",
+            &params,
+            &DeepgramLanguageStrategy,
+            &DeepgramKeywordStrategy,
+        );
+
+        let query = url.query().unwrap_or_default();
+        assert!(query.contains("detect_language=en"));
+        assert!(query.contains("detect_language=pl"));
+        assert!(!query.contains("detect_language=true"));
+        assert!(!query.contains("language=multi"));
+    }
+
     #[tokio::test]
     #[ignore]
     async fn test_deepgram_batch_transcription() {

crates/owhisper-client/src/adapter/deepgram/language.rs

@@ -7,6 +7,11 @@ use crate::adapter::deepgram_compat::{
 
 const NOVA2_MULTI_LANGS: &[&str] = &["en", "es"];
 const NOVA3_MULTI_LANGS: &[&str] = &["en", "es", "fr", "de", "hi", "ru", "pt", "ja", "it", "nl"];
+const LANGUAGE_DETECTION_LANGS: &[&str] = &[
+    "bg", "ca", "cs", "da", "de", "el", "en", "es", "et", "fi", "fr", "hi", "hu", "id", "it", "ja",
+    "ko", "lt", "lv", "ms", "nl", "no", "pl", "pt", "ro", "ru", "sk", "sv", "th", "tr", "uk", "vi",
+    "zh",
+];
 
 pub fn can_use_multi(model: &str, languages: &[hypr_language::Language]) -> bool {
     if languages.len() < 2 {
@@ -55,7 +60,7 @@ impl LanguageQueryStrategy for DeepgramLanguageStrategy {
                 if can_use_multi(model, &params.languages) {
                     query_pairs.append_pair("language", "multi");
                 } else if mode == TranscriptionMode::Batch {
-                    query_pairs.append_pair("detect_language", "true");
+                    append_detect_language_query(query_pairs, &params.languages);
                 } else if let Some(language) = params.languages.first() {
                     let code = single_language_query_code(params, language);
                     query_pairs.append_pair("language", &code);
@@ -82,6 +87,23 @@ fn single_language_query_code(params: &ListenParams, language: &hypr_language::L
     }
 }
 
+fn append_detect_language_query<'a>(
+    query_pairs: &mut Serializer<'a, UrlQuery>,
+    languages: &[hypr_language::Language],
+) {
+    if languages.iter().all(supports_language_detection) {
+        for language in languages {
+            query_pairs.append_pair("detect_language", language.iso639().code());
+        }
+    } else {
+        query_pairs.append_pair("detect_language", "true");
+    }
+}
+
+pub(super) fn supports_language_detection(language: &hypr_language::Language) -> bool {
+    LANGUAGE_DETECTION_LANGS.contains(&language.iso639().code())
+}
+
 fn effective_model(params: &ListenParams) -> Option<DeepgramModel> {
     params
         .model

crates/owhisper-client/src/adapter/deepgram/mod.rs

@@ -162,6 +162,10 @@ impl DeepgramAdapter {
         Self::language_support_batch(languages, model).is_supported()
     }
 
+    pub fn supports_batch_language_detection(languages: &[hypr_language::Language]) -> bool {
+        !languages.is_empty() && languages.iter().all(language::supports_language_detection)
+    }
+
     fn can_use_multi(languages: &[hypr_language::Language]) -> bool {
         language::can_use_multi(DeepgramModel::Nova3General.as_ref(), languages)
             || language::can_use_multi(DeepgramModel::Nova2General.as_ref(), languages)
@@ -398,6 +402,15 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_supports_batch_language_detection() {
+        let en_pl: Vec<Language> = vec![ISO639::En.into(), ISO639::Pl.into()];
+        assert!(DeepgramAdapter::supports_batch_language_detection(&en_pl));
+
+        let en_ar: Vec<Language> = vec![ISO639::En.into(), ISO639::Ar.into()];
+        assert!(!DeepgramAdapter::supports_batch_language_detection(&en_ar));
+    }
+
     #[test]
     fn test_can_use_multi() {
         let cases: &[(&str, &[ISO639], bool)] = &[

crates/soniox/src/lib.rs

@@ -1,6 +1,9 @@
 use serde::{Deserialize, Serialize};
+use std::time::Duration;
 
 pub const API_HOST: &str = "https://api.soniox.com";
+const TRANSCRIPTION_POLL_INTERVAL: Duration = Duration::from_secs(2);
+const TRANSCRIPTION_MAX_POLLS: usize = 1800;
 
 #[derive(Debug)]
 pub struct Error {
@@ -319,8 +322,6 @@ pub async fn wait_for_completion(
     transcription_id: &str,
     api_key: &str,
 ) -> Result<(), Error> {
-    use std::time::Duration;
-
     #[derive(Deserialize)]
     struct StatusResponse {
         status: String,
@@ -330,7 +331,7 @@ pub async fn wait_for_completion(
 
     let url = format!("{API_HOST}/v1/transcriptions/{transcription_id}");
 
-    for _ in 0..300 {
+    for _ in 0..TRANSCRIPTION_MAX_POLLS {
         let response = client
             .get(&url)
             .header("Authorization", format!("Bearer {api_key}"))
@@ -369,7 +370,7 @@ pub async fn wait_for_completion(
                 });
             }
             "queued" | "processing" => {
-                tokio::time::sleep(Duration::from_secs(2)).await;
+                tokio::time::sleep(TRANSCRIPTION_POLL_INTERVAL).await;
             }
             unknown => {
                 return Err(Error {
@@ -381,7 +382,23 @@ pub async fn wait_for_completion(
     }
 
     Err(Error {
-        message: "transcription timed out".to_string(),
+        message: format!(
+            "transcription timed out after {} seconds",
+            TRANSCRIPTION_POLL_INTERVAL.as_secs() * TRANSCRIPTION_MAX_POLLS as u64
+        ),
         is_retryable: false,
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn soniox_polling_allows_long_batch_jobs() {
+        assert_eq!(
+            TRANSCRIPTION_POLL_INTERVAL.as_secs() * TRANSCRIPTION_MAX_POLLS as u64,
+            3600
+        );
+    }
+}

crates/transcribe-proxy/src/routes/batch/sync.rs

@@ -105,7 +105,9 @@ pub(super) async fn handle_hyprnote_batch(
     body: Bytes,
     content_type: &str,
 ) -> Response {
-    let provider_chain = state.resolve_hyprnote_provider_chain_for_mode(RoutingMode::Batch, params);
+    let mut provider_chain =
+        state.resolve_hyprnote_provider_chain_for_mode(RoutingMode::Batch, params);
+    append_deepgram_batch_detection_fallback(state, &mut provider_chain, &listen_params);
 
     if provider_chain.is_empty() {
         return (
@@ -213,6 +215,25 @@ pub(super) async fn handle_hyprnote_batch(
         .into_response()
 }
 
+fn append_deepgram_batch_detection_fallback(
+    state: &AppState,
+    provider_chain: &mut Vec<SelectedProvider>,
+    listen_params: &ListenParams,
+) {
+    if listen_params.languages.len() <= 1
+        || provider_chain
+            .iter()
+            .any(|selected| selected.provider() == Provider::Deepgram)
+        || !DeepgramAdapter::supports_batch_language_detection(&listen_params.languages)
+    {
+        return;
+    }
+
+    if let Ok(selected) = state.selector.select(Some(Provider::Deepgram)) {
+        provider_chain.push(selected);
+    }
+}
+
 pub(super) async fn transcribe_with_retry(
     selected: &SelectedProvider,
     params: ListenParams,

crates/transcribe-proxy/tests/hyprnote_routing_mock.rs

@@ -98,6 +98,33 @@ async fn batch_cloud_model_resolved_for_deepgram() {
     );
 }
 
+#[tokio::test]
+async fn batch_en_pl_uses_deepgram_detection_fallback_when_soniox_unavailable() {
+    let batch = start_mock_batch_upstream().await;
+    let upstream_url = batch_upstream_url(batch.addr);
+    let proxy = start_proxy(Some(&upstream_url), None).await;
+
+    send_batch(proxy, "model=cloud&language=en&language=pl").await;
+    let query = wait_for_first_batch_query(&batch, TIMEOUT).await;
+
+    assert!(
+        query.contains("detect_language=en"),
+        "should restrict Deepgram detection to English: {query}"
+    );
+    assert!(
+        query.contains("detect_language=pl"),
+        "should restrict Deepgram detection to Polish: {query}"
+    );
+    assert!(
+        !query.contains("detect_language=true"),
+        "should not fall back to unrestricted language detection: {query}"
+    );
+    assert!(
+        !query.contains("language=multi"),
+        "Polish is not in Deepgram's multi-language model set: {query}"
+    );
+}
+
 #[tokio::test]
 async fn batch_explicit_model_preserved_for_deepgram() {
     let batch = start_mock_batch_upstream().await;