ASR: fix Cohere Transcribe loading on ZeroGPU (gated auth + device move + native class)

Root cause of the dead mic: the model is gated and the Space ran unauthenticated,
so from_pretrained 401'd at download and the model never loaded (preload swallowed
it; every mic call returned ""). Fixed by adding the HF_TOKEN Space secret.

Code hardening so it actually transcribes once the gate opens:
- _load() now moves the fp16 model to CUDA inside the @spaces.GPU call (mirrors
game/model.py); without it, fp16 generate on CPU raises and returns "".
- Use the native CohereAsrForConditionalGeneration class (transformers>=5.11)
instead of AutoModelForSpeechSeq2Seq, which is not guaranteed to map cohere_asr.
- Proper librosa resample to 16k (guarded fallback to the old decimation).
- spaces.GPU duration 20->30 for the cold 2B host->device transfer.
- Add librosa + soundfile deps.
- Env-gated _selftest() (ASR_SELFTEST=1) transcribes the model's demo clip so the
deploy logs prove Cohere works without a mic.

No Whisper anywhere; on any failure returns "" and logs the exact error.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

game/asr.py

@@ -2,8 +2,11 @@
 
 Backend: Cohere Transcribe 2B, exclusively (sponsor model; verbatim by design —
 transcribes what was SAID, not what it thinks you meant; EN + ES native).
-The witness may speak either language and the decoder prompt is language-specific,
-so we run both prompts and keep the transcript the model found more likely.
+The witness picks the language in the UI; the decoder prompt is language-specific,
+so we decode in that language and only retry the other one if the first is empty.
+
+Gated model: the Space authenticates via the HF_TOKEN secret. On any failure the
+function returns an empty string and logs the exact error — it NEVER fabricates text.
 """
 from __future__ import annotations
 
@@ -13,7 +16,7 @@ COHERE_ASR_ID = "CohereLabs/cohere-transcribe-03-2026"
 
 try:
     import spaces
-    _gpu = spaces.GPU(duration=20)
+    _gpu = spaces.GPU(duration=30)  # cold 2B host->device transfer + short generate
 except Exception:
     def _gpu(fn):
         return fn
@@ -23,29 +26,36 @@ _backend = None  # (processor, model)
 
 
 def _load():
+    """ZeroGPU-canonical (mirrors game/model.py): weights load once on CPU; the
+    @spaces.GPU call moves them to CUDA. Keeps GPU calls short and admissible."""
     global _backend
     if _backend is None:
         with _lock:
             if _backend is None:
                 import torch
-                from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq
+                from transformers import AutoProcessor, CohereAsrForConditionalGeneration
                 proc = AutoProcessor.from_pretrained(COHERE_ASR_ID)
-                mdl = AutoModelForSpeechSeq2Seq.from_pretrained(
+                mdl = CohereAsrForConditionalGeneration.from_pretrained(
                     COHERE_ASR_ID, torch_dtype=torch.float16)
                 _backend = (proc, mdl)
                 print("[asr] backend: cohere-transcribe", flush=True)
-    return _backend
+    proc, mdl = _backend
+    import torch
+    if torch.cuda.is_available() and mdl.device.type != "cuda":
+        mdl.to("cuda")
+    return proc, mdl
 
 
 def preload():
     _load()
+    _selftest()
 
 
 @_gpu
 def transcribe(audio: tuple[int, "np.ndarray"] | None, language: str = "en") -> str:
     """gr.Audio mic tuple -> witness text in the chosen language ('en'/'es').
-    One pass (the witness picks the language), so no double decode. Empty
-    string on any failure."""
+    Decodes in the witness's language; only retries the other language if that
+    pass is empty. Empty string on any failure (never fabricated text)."""
     import numpy as np
 
     if audio is None:
@@ -64,9 +74,14 @@ def transcribe(audio: tuple[int, "np.ndarray"] | None, language: str = "en") ->
         import torch
         proc, mdl = _load()
         if sr != 16000:
-            idx = np.linspace(0, len(wav) - 1, int(len(wav) * 16000 / sr))
-            wav = wav[np.floor(idx).astype(int)]
+            try:  # proper anti-aliased resample; never hard-fail on a missing dep
+                import librosa
+                wav = librosa.resample(np.ascontiguousarray(wav), orig_sr=sr, target_sr=16000)
+            except Exception:
+                idx = np.linspace(0, len(wav) - 1, int(len(wav) * 16000 / sr))
+                wav = wav[np.floor(idx).astype(int)]
         for lang in order:
+            # `language` is a REQUIRED processor arg: it builds the decoder prompt.
             inputs = proc(wav, language=lang, sampling_rate=16000, return_tensors="pt")
             inputs = {k: (v.to(mdl.device, dtype=mdl.dtype) if v.dtype.is_floating_point
                           else v.to(mdl.device)) for k, v in inputs.items()
@@ -83,3 +98,24 @@ def transcribe(audio: tuple[int, "np.ndarray"] | None, language: str = "en") ->
     except Exception as e:
         print(f"[asr] failed: {type(e).__name__}: {e}", flush=True)
         return ""
+
+
+def _selftest():
+    """Deploy-time smoke test (set ASR_SELFTEST=1): transcribe the model's own
+    demo clip so the Space logs prove Cohere works end-to-end, no mic needed."""
+    import os
+    if os.getenv("ASR_SELFTEST") != "1":
+        return
+    try:
+        import numpy as np
+        import soundfile as sf
+        from huggingface_hub import hf_hub_download
+        path = hf_hub_download(repo_id=COHERE_ASR_ID,
+                               filename="demo/voxpopuli_test_en_demo.wav")
+        wav, sr = sf.read(path, dtype="float32")
+        text = transcribe((int(sr), np.asarray(wav)), "en")
+        print(f"[asr-selftest] OK: {text!r}", flush=True)
+    except Exception as e:
+        import traceback
+        print(f"[asr-selftest] FAIL: {type(e).__name__}: {e}\n{traceback.format_exc()}",
+              flush=True)

requirements.txt

@@ -6,3 +6,5 @@ torch
 spaces
 voxcpm
 numpy
+librosa                      # proper 48k->16k resample for mic audio (Cohere wants 16k)
+soundfile                    # audio I/O backend (librosa + ASR self-test demo wav)