Auto-deploy from GitHub: 1ff9b762b3692b3fb6428694bf175fc54879d453

app/api/routes.py

@@ -5,11 +5,12 @@ import uuid
 import json
 import asyncio
 import aiofiles
-from app.core.config import settings
+from app.core.config import settings, get_device
 from custom_logger import logger_config as logger
 from app.db import crud
 from app.services.worker import start_worker, is_worker_running
-from app.services.streaming import StreamingSTT, ALLOWED_MODELS
+from app.services.streaming import create_streaming_stt, ALLOWED_MODELS
+from stt.registry import describe, supports, streaming_engines, get_engine
 
 router = APIRouter()
 
@@ -26,13 +27,27 @@ async def index():
     return FileResponse('index.html')
 
 @router.post("/api/tasks/upload")
-async def upload_task(audio: UploadFile = File(...), hide_from_ui: str = Form("")):
+async def upload_task(
+    audio: UploadFile = File(...),
+    hide_from_ui: str = Form(""),
+    language: str = Form("auto"),
+    task: str = Form("transcribe"),
+    engine: str = Form(""),
+):
     if not audio.filename:
         raise HTTPException(status_code=400, detail="No file selected")
-    
+
     if not allowed_file(audio.filename):
         raise HTTPException(status_code=400, detail="Invalid file type")
-    
+
+    language = (language or "auto").strip().lower()
+    task = (task or "transcribe").strip().lower()
+    engine = (engine or "").strip() or settings.STT_MODEL_NAME
+
+    ok, reason = supports(engine, language, task)
+    if not ok:
+        raise HTTPException(status_code=400, detail=reason)
+
     task_id = str(uuid.uuid4())
     filename = audio.filename
     filepath = os.path.join(settings.UPLOAD_FOLDER, f"{task_id}_{filename}")
@@ -48,17 +63,29 @@ async def upload_task(audio: UploadFile = File(...), hide_from_ui: str = Form(""
     
     hide_from_ui_val = 1 if hide_from_ui.lower() in ['true', '1'] else 0
     
-    await crud.insert_task(task_id, filename, filepath, 'not_started', hide_from_ui_val)
-    
+    await crud.insert_task(task_id, filename, filepath, 'not_started', hide_from_ui_val,
+                           language=language, task=task, engine=engine)
+
     await start_worker()
-    
+
     return JSONResponse(status_code=201, content={
         'id': task_id,
         'filename': filename,
         'status': 'not_started',
+        'language': language,
+        'task': task,
+        'engine': engine,
         'message': 'File uploaded successfully'
     })
 
+@router.get("/api/engines")
+async def get_engines():
+    """Capabilities of every engine, so the UI can build its own dropdowns."""
+    data = describe()
+    data["default_engine"] = settings.STT_MODEL_NAME
+    data["streaming_engines"] = sorted(streaming_engines())
+    return data
+
 @router.get("/api/tasks")
 async def get_tasks():
     rows, queue_ids, processing_count, avg_time = await crud.get_all_tasks()
@@ -101,6 +128,9 @@ async def get_task(task_id: str):
         'filename': row['filename'],
         'status': row['status'],
         'result': row['result'],
+        'language': row['language'],
+        'task': row['task'],
+        'engine': row['engine'],
         'created_at': row['created_at'],
         'processed_at': row['processed_at'],
         'progress': row['progress'] or 0,
@@ -139,23 +169,61 @@ async def websocket_transcribe(websocket: WebSocket):
     try:
         config_text = await websocket.receive_text()
         config = json.loads(config_text)
+        engine = config.get("engine", "fasterwhispher")
         model_name = config.get("model", "base")
+        language = config.get("language", "en") or "auto"
+        # Named stt_task, not task: `task` below is the asyncio background task.
+        stt_task = config.get("task", "transcribe")
 
-        if model_name not in ALLOWED_MODELS:
+        ok, reason = supports(engine, language, stt_task)
+        if not ok:
+            await websocket.send_json({"type": "error", "message": reason})
+            await websocket.close()
+            return
+
+        if not get_engine(engine)["streaming"]:
+            await websocket.send_json(
+                {"type": "error", "message": f"Engine '{engine}' does not support live streaming"}
+            )
+            await websocket.close()
+            return
+
+        # Whisper sizes are only meaningful for the whisper engine.
+        if engine == "fasterwhispher" and model_name not in ALLOWED_MODELS:
             await websocket.send_json(
                 {"type": "error", "message": f"Unsupported model: {model_name}"}
             )
             await websocket.close()
             return
 
+        # tiny/base translate Hindi poorly enough to look broken; warn rather
+        # than silently returning garbage English.
+        if engine == "fasterwhispher" and stt_task == "translate" and model_name in ("tiny", "base"):
+            await websocket.send_json({
+                "type": "warning",
+                "message": f"'{model_name}' gives weak translation quality; "
+                           "prefer small or larger, or switch to the indic engine.",
+            })
+
         loop = asyncio.get_event_loop()
         # WhisperModel construction downloads/loads weights synchronously; run it
         # in an executor so it doesn't block the event loop (and every other
         # connection) while the model loads.
+        device = get_device()
         stt = await loop.run_in_executor(
-            None, lambda: StreamingSTT(model_name=model_name, device="cpu")
+            None,
+            lambda: create_streaming_stt(
+                engine, model_name=model_name, device=device,
+                language=language, task=stt_task,
+            ),
         )
-        await websocket.send_json({"type": "ready", "sample_rate": stt.sample_rate})
+        await websocket.send_json({
+            "type": "ready",
+            "sample_rate": stt.sample_rate,
+            "engine": engine,
+            "language": language,
+            "task": stt_task,
+        })
 
         async def bg_process():
             while True:

app/core/config.py

@@ -1,5 +1,22 @@
 import os
 
+# Ensure CUDA 12 libraries are findable for faster-whisper/CTranslate2
+_cuda12_path = "/usr/local/lib/ollama/cuda_v12"
+if os.path.isdir(_cuda12_path):
+    cur = os.environ.get("LD_LIBRARY_PATH", "")
+    if _cuda12_path not in cur:
+        os.environ["LD_LIBRARY_PATH"] = f"{_cuda12_path}:{cur}" if cur else _cuda12_path
+
+# get_device comes from the stt package (already a dependency) rather than
+# jebin_lib: importing jebin_lib pulls in hf_bucket_client, which imports
+# huggingface_hub.sync_bucket - removed from huggingface_hub - so a single
+# broken transitive import would take down server startup.
+try:
+    from jebin_lib.utils import get_device
+except ImportError:
+    from stt.common import get_device
+
+
 class Config:
     PORT = int(os.environ.get('PORT', 7860))
     UPLOAD_FOLDER = 'uploads'
@@ -10,6 +27,12 @@ class Config:
     CWD = "./"
     PYTHON_PATH = "stt-transcribe"
     STT_MODEL_NAME = "parakeet"
+    # Parakeet is English-only, so non-English audio and X->English translation
+    # are routed to a whisper engine instead.
+    STT_MULTILINGUAL_MODEL_NAME = os.environ.get('STT_MULTILINGUAL_MODEL', 'fasterwhispher')
+    # faster-whisper checkpoint size used for those jobs; "base" translates
+    # Hindi poorly, so default to something usable.
+    STT_WHISPER_MODEL = os.environ.get('STT_WHISPER_MODEL', 'small')
     POLL_INTERVAL = 3
 
 settings = Config()

app/db/crud.py

@@ -4,12 +4,14 @@ from datetime import datetime, timedelta
 from app.core.config import settings
 from custom_logger import logger_config as logger
 
-async def insert_task(task_id: str, filename: str, filepath: str, status: str, hide_from_ui: int):
+async def insert_task(task_id: str, filename: str, filepath: str, status: str, hide_from_ui: int,
+                      language: str = None, task: str = 'transcribe', engine: str = None):
     async with aiosqlite.connect(settings.DATABASE_FILE) as db:
-        await db.execute('''INSERT INTO tasks 
-                     (id, filename, filepath, status, created_at, hide_from_ui)
-                     VALUES (?, ?, ?, ?, ?, ?)''',
-                  (task_id, filename, filepath, status, datetime.now().isoformat(), hide_from_ui))
+        await db.execute('''INSERT INTO tasks
+                     (id, filename, filepath, status, created_at, hide_from_ui, language, task, engine)
+                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)''',
+                  (task_id, filename, filepath, status, datetime.now().isoformat(), hide_from_ui,
+                   language, task, engine))
         await db.commit()
     logger.debug(f"Inserted task {filename} (ID: {task_id}) into database.")
 

app/db/database.py

@@ -15,7 +15,21 @@ async def init_db():
                       processed_at TEXT,
                       progress INTEGER DEFAULT 0,
                       progress_text TEXT,
-                      hide_from_ui INTEGER DEFAULT 0)'''
+                      hide_from_ui INTEGER DEFAULT 0,
+                      language TEXT,
+                      task TEXT DEFAULT 'transcribe',
+                      engine TEXT)'''
         )
+
+        # Migrate databases created before language/task existed.
+        async with db.execute("PRAGMA table_info(tasks)") as cursor:
+            existing = {row[1] for row in await cursor.fetchall()}
+        if 'language' not in existing:
+            await db.execute("ALTER TABLE tasks ADD COLUMN language TEXT")
+        if 'task' not in existing:
+            await db.execute("ALTER TABLE tasks ADD COLUMN task TEXT DEFAULT 'transcribe'")
+        if 'engine' not in existing:
+            await db.execute("ALTER TABLE tasks ADD COLUMN engine TEXT")
+
         await db.commit()
     logger.info("Database initialized successfully.")

app/services/streaming.py

@@ -9,6 +9,18 @@ from custom_logger import logger_config as logger
 # is ever attempted (an unknown name would otherwise trigger a download).
 ALLOWED_MODELS = {"tiny", "base", "small", "medium", "large-v3"}
 
+# Capabilities come from the shared registry so the CLI, backend and UI can
+# never disagree about what an engine accepts.
+from stt.registry import ENGINES, ALL_TASKS
+
+# None/"auto" lets whisper detect the language, but an explicit code is more
+# reliable on short streaming windows.
+ALLOWED_LANGUAGES = set(ENGINES["fasterwhispher"]["languages"])
+
+# "transcribe" keeps the source language; "translate" is whisper's built-in
+# X -> English translation (so Hindi speech comes back as English text).
+ALLOWED_TASKS = set(ALL_TASKS)
+
 # Whisper weights are large, so identical (model, device) pairs are shared across
 # connections instead of loaded once per connection (4 concurrent large-v3
 # models would otherwise OOM). faster-whisper's WhisperModel is safe to use from
@@ -103,12 +115,20 @@ class _HypothesisBuffer:
 
 
 class StreamingSTT:
-    def __init__(self, model_name="base", device="cpu", sample_rate=16000):
+    def __init__(self, model_name="base", device="cpu", sample_rate=16000,
+                 language="en", task="transcribe"):
         if model_name not in ALLOWED_MODELS:
             raise ValueError(f"Unsupported model: {model_name}")
+        if language is not None and language not in ALLOWED_LANGUAGES:
+            raise ValueError(f"Unsupported language: {language}")
+        if task not in ALLOWED_TASKS:
+            raise ValueError(f"Unsupported task: {task}")
         self.sample_rate = sample_rate
         self.model_name = model_name
         self.device = device
+        # None => let whisper detect the language per window.
+        self.language = None if language == "auto" else language
+        self.task = task
         self.buffer = np.array([], dtype=np.float32)
         self.processed_until = 0
         # Absolute sample index of buffer[0]. Grows as _trim_buffer() discards
@@ -154,7 +174,12 @@ class StreamingSTT:
     def _transcribe_words(self, audio, time_offset):
         """Transcribe audio, returning [(start, end, text), ...] in absolute time."""
         segments, _ = self.model.transcribe(
-            audio, beam_size=1, vad_filter=True, language="en", word_timestamps=True
+            audio,
+            beam_size=1,
+            vad_filter=True,
+            language=self.language,
+            task=self.task,
+            word_timestamps=True,
         )
         words = []
         for seg in segments:
@@ -235,3 +260,196 @@ class StreamingSTT:
         self.buffer = np.array([], dtype=np.float32)
         import gc
         gc.collect()
+
+
+class IndicStreamingSTT:
+    """Streaming wrapper around the AI4Bharat cascade.
+
+    Whisper emits English tokens directly, so its output can be committed
+    word-by-word. This cascade cannot: Hindi is verb-final, so a partial clause
+    translates to something that the rest of the clause would invalidate.
+    Instead, source-script text is shown as *tentative* the moment it is
+    recognised, and a clause is only translated and *committed* once it is
+    closed - detected either by trailing silence or by hitting the max window.
+    """
+
+    min_chunk = 2.0      # seconds of audio before any tentative output
+    max_window = 8.0     # force a commit rather than growing without bound
+    silence_tail = 0.6   # seconds of quiet that count as a clause boundary
+    silence_rms = 0.012  # amplitude below which a frame is considered silent
+
+    def __init__(self, model_name=None, device="cpu", sample_rate=16000,
+                 language="hi", task="translate"):
+        if language in (None, "", "auto"):
+            raise ValueError("The indic engine needs an explicit language (no auto-detect)")
+
+        from stt.indic import LANG_TAGS
+        if language not in LANG_TAGS:
+            raise ValueError(f"Unsupported language for the indic engine: {language}")
+        if task not in ALLOWED_TASKS:
+            raise ValueError(f"Unsupported task: {task}")
+
+        self.sample_rate = sample_rate
+        self.device = device
+        self.language = language
+        self.task = task
+        self.src_tag = LANG_TAGS[language]
+        self.buffer = np.array([], dtype=np.float32)
+        self.processed_until = 0
+        self.buffer_start = 0
+        self.is_finalized = False
+        self._incoming = queue.Queue()
+
+        # Reuse the batch engine so the model-loading and translation logic
+        # lives in exactly one place.
+        from stt.indic import IndicSTTProcessor
+        self.engine = IndicSTTProcessor(device=device)
+        self.engine.language = language
+        self.engine.task = task
+        if task == "translate":
+            self.engine._load_translator()
+
+    def add_audio(self, audio_bytes: bytes):
+        audio_float = (
+            np.frombuffer(audio_bytes, dtype=np.int16).astype(np.float32) / 32768.0
+        )
+        self._incoming.put(audio_float)
+
+    def _drain_incoming(self):
+        chunks = []
+        while True:
+            try:
+                chunks.append(self._incoming.get_nowait())
+            except queue.Empty:
+                break
+        if chunks:
+            self.buffer = np.append(self.buffer, np.concatenate(chunks))
+
+    def _trim_buffer(self):
+        max_buffered = self.sample_rate * 120
+        if len(self.buffer) > max_buffered:
+            trim_to = self.processed_until - self.sample_rate * 5
+            if trim_to > 0:
+                self.buffer = self.buffer[trim_to:]
+                self.processed_until -= trim_to
+                self.buffer_start += trim_to
+
+    def _ends_in_silence(self, audio):
+        tail = audio[-int(self.silence_tail * self.sample_rate):]
+        if len(tail) < self.silence_tail * self.sample_rate:
+            return False
+        return float(np.sqrt(np.mean(tail ** 2))) < self.silence_rms
+
+    def _transcribe(self, audio):
+        import torch
+        wav = torch.from_numpy(audio).unsqueeze(0).to(self.device)
+        with torch.inference_mode():
+            text = self.engine.model(wav, self.language, "ctc")
+        if isinstance(text, (list, tuple)):
+            text = " ".join(str(t) for t in text)
+        return (text or "").strip()
+
+    def _to_english(self, text):
+        if self.task != "translate" or not text:
+            return text
+        sentences = self.engine._split_sentences(text)
+        return " ".join(self.engine._translate(sentences, self.src_tag))
+
+    def _commit(self, text, span_samples):
+        start = (self.buffer_start + self.processed_until) / self.sample_rate
+        end = start + span_samples / self.sample_rate
+        self.processed_until += span_samples
+        self._trim_buffer()
+        return {
+            "start": round(start, 2),
+            "end": round(end, 2),
+            "text": self._to_english(text),
+        }
+
+    def process(self):
+        if self.is_finalized:
+            return None
+
+        self._drain_incoming()
+
+        unprocessed = self.buffer[self.processed_until:]
+        if len(unprocessed) < self.min_chunk * self.sample_rate:
+            return None
+
+        try:
+            text = self._transcribe(unprocessed)
+        except Exception as e:
+            logger.error(f"[IndicStreamingSTT] process error: {e}")
+            return None
+
+        at_boundary = (
+            len(unprocessed) >= self.max_window * self.sample_rate
+            or self._ends_in_silence(unprocessed)
+        )
+
+        if not text:
+            # Nothing recognised; drop silent audio so the window doesn't grow.
+            if at_boundary:
+                self.processed_until += len(unprocessed)
+                self._trim_buffer()
+            return {"commit": None, "tentative": ""}
+
+        if at_boundary:
+            try:
+                return {"commit": self._commit(text, len(unprocessed)), "tentative": ""}
+            except Exception as e:
+                logger.error(f"[IndicStreamingSTT] translate error: {e}")
+                return None
+
+        # Clause still open - show the source script so there is live feedback.
+        return {"commit": None, "tentative": text}
+
+    def flush(self):
+        if self.is_finalized:
+            return None
+        self.is_finalized = True
+
+        self._drain_incoming()
+
+        unprocessed = self.buffer[self.processed_until:]
+        if len(unprocessed) < 0.3 * self.sample_rate:
+            return {"commit": None}
+
+        try:
+            text = self._transcribe(unprocessed)
+            if not text:
+                return {"commit": None}
+            return {"commit": self._commit(text, len(unprocessed))}
+        except Exception as e:
+            logger.error(f"[IndicStreamingSTT] flush error: {e}")
+            return {"commit": None}
+
+    def cleanup(self):
+        if self.engine is not None:
+            self.engine.cleanup()
+            self.engine = None
+        self.buffer = np.array([], dtype=np.float32)
+        import gc
+        gc.collect()
+
+
+def create_streaming_stt(engine, model_name=None, device="cpu", language="en",
+                         task="transcribe"):
+    """Build the streaming implementation for a registry engine name."""
+    from stt.registry import get_engine
+
+    spec = get_engine(engine)
+    if not spec["streaming"]:
+        raise ValueError(f"Engine '{engine}' does not support live streaming")
+
+    if engine == "fasterwhispher":
+        return StreamingSTT(
+            model_name=model_name or spec["default_size"] or "base",
+            device=device,
+            language=language,
+            task=task,
+        )
+    if engine == "indic":
+        return IndicStreamingSTT(device=device, language=language, task=task)
+
+    raise ValueError(f"Engine '{engine}' is marked streaming but has no implementation")

app/services/worker.py

@@ -40,16 +40,39 @@ async def worker_loop():
                 task_id = row['id']
                 filepath = row['filepath']
                 filename = row['filename']
-                
-                logger.info(f"\n{'='*60}\nProcessing: {filename}\nID: {task_id}\n{'='*60}")
+                language = row['language'] or 'auto'
+                stt_task = row['task'] or 'transcribe'
+                engine = row['engine']
+
+                if not engine:
+                    # Legacy rows (queued before the engine column existed) have
+                    # no choice recorded, so fall back to capability routing:
+                    # parakeet is English-only, anything else needs whisper.
+                    needs_multilingual = stt_task == 'translate' or language not in ('auto', 'en')
+                    engine = (
+                        settings.STT_MULTILINGUAL_MODEL_NAME
+                        if needs_multilingual
+                        else settings.STT_MODEL_NAME
+                    )
+
+                logger.info(
+                    f"\n{'='*60}\nProcessing: {filename}\nID: {task_id}\n"
+                    f"Engine: {engine} | language: {language} | task: {stt_task}\n{'='*60}"
+                )
                 
                 await crud.update_status(task_id, 'processing')
                 
                 try:
                     await crud.update_progress(task_id, 5, "Starting STT...")
                     
-                    command = f"cd {settings.CWD} && {settings.PYTHON_PATH} --input {shlex.quote(os.path.abspath(filepath))} --model {settings.STT_MODEL_NAME}"
-                    
+                    command = (
+                        f"cd {settings.CWD} && {settings.PYTHON_PATH} "
+                        f"--input {shlex.quote(os.path.abspath(filepath))} "
+                        f"--model {shlex.quote(engine)} "
+                        f"--language {shlex.quote(language)} "
+                        f"--task {shlex.quote(stt_task)}"
+                    )
+
                     logger.debug(f"Executing command: {command}")
                     
                     process = await asyncio.create_subprocess_shell(
@@ -60,8 +83,7 @@ async def worker_loop():
                         env={
                             **os.environ,
                             'PYTHONUNBUFFERED': '1',
-                            'CUDA_LAUNCH_BLOCKING': '1',
-                            'USE_CPU_IF_POSSIBLE': 'true'
+                            'STT_WHISPER_MODEL': settings.STT_WHISPER_MODEL,
                         }
                     )
                     

index.html

@@ -534,6 +534,18 @@
                             class="px-4 py-1.5 bg-surface border-[2px] border-crayon-red text-crayon-red text-lg font-bold rounded-xl organic-shape -rotate-1">FLAC</span>
                     </div>
                 </div>
+                <!-- stopPropagation so using these controls doesn't open the file picker -->
+                <div class="flex items-center justify-center gap-4 mt-6 flex-wrap"
+                    onclick="event.stopPropagation()">
+                    <label class="text-label-sm text-[#4b5563] font-bold">Model:</label>
+                    <select id="uploadEngineSelect"></select>
+                    <label class="text-label-sm text-[#4b5563] font-bold">Spoken:</label>
+                    <select id="uploadLanguageSelect"></select>
+                    <label class="text-label-sm text-[#4b5563] font-bold">Output:</label>
+                    <select id="uploadTaskSelect"></select>
+                </div>
+                <p id="uploadEngineNote" class="text-label-sm text-[#6b7280] text-center mt-2"
+                    onclick="event.stopPropagation()"></p>
                 <input type="file" id="fileInput" hidden accept="audio/*">
             </div>
         </section>
@@ -655,14 +667,14 @@
             </div>
             <div class="modal-body">
                 <div class="flex items-center gap-6 mb-6 flex-wrap">
-                    <label class="text-label-sm text-[#4b5563] font-bold">Model:</label>
-                    <select id="liveModelSelect">
-                        <option value="tiny">tiny</option>
-                        <option value="base" selected>base</option>
-                        <option value="small">small</option>
-                        <option value="medium">medium</option>
-                        <option value="large-v3">large-v3</option>
-                    </select>
+                    <label class="text-label-sm text-[#4b5563] font-bold">Engine:</label>
+                    <select id="liveEngineSelect"></select>
+                    <label id="liveModelLabel" class="text-label-sm text-[#4b5563] font-bold">Size:</label>
+                    <select id="liveModelSelect"></select>
+                    <label class="text-label-sm text-[#4b5563] font-bold">Speaking:</label>
+                    <select id="liveLanguageSelect"></select>
+                    <label class="text-label-sm text-[#4b5563] font-bold">Output:</label>
+                    <select id="liveTaskSelect"></select>
                     <button id="startLiveBtn"
                         class="flex items-center gap-2 px-8 py-3 bg-crayon-green text-white text-headline-md font-bold crayon-button border-crayon-green shadow-md">
                         <span class="material-symbols-outlined text-3xl">play_arrow</span>
@@ -764,6 +776,9 @@
 
             const formData = new FormData();
             formData.append('audio', file);
+            formData.append('engine', uploadEngineSelect.value);
+            formData.append('language', uploadLanguageSelect.value);
+            formData.append('task', uploadTaskSelect.value);
 
             try {
                 const res = await fetch(`${API_BASE}/tasks/upload`, { method: 'POST', body: formData });
@@ -915,6 +930,84 @@
         const liveBtn = document.getElementById('liveBtn');
         const liveModal = document.getElementById('liveModal');
         const liveModelSelect = document.getElementById('liveModelSelect');
+        const liveModelLabel = document.getElementById('liveModelLabel');
+        const liveEngineSelect = document.getElementById('liveEngineSelect');
+        const liveLanguageSelect = document.getElementById('liveLanguageSelect');
+        const liveTaskSelect = document.getElementById('liveTaskSelect');
+        const uploadEngineSelect = document.getElementById('uploadEngineSelect');
+        const uploadLanguageSelect = document.getElementById('uploadLanguageSelect');
+        const uploadTaskSelect = document.getElementById('uploadTaskSelect');
+        const uploadEngineNote = document.getElementById('uploadEngineNote');
+
+        // --- Engine registry (server is the single source of truth) ---
+        // Every dropdown below is built from /api/engines, so adding an engine
+        // server-side makes it selectable here with no changes to this file.
+        let REGISTRY = null;
+
+        const TASK_LABELS = { transcribe: 'Same language', translate: 'English' };
+
+        function fillSelect(select, items, selected) {
+            select.innerHTML = items.map(i =>
+                `<option value="${i.value}"${i.value === selected ? ' selected' : ''}>${i.label}</option>`
+            ).join('');
+        }
+
+        // Repopulate language/task/size to match the chosen engine, keeping the
+        // user's current picks whenever the new engine still supports them.
+        function syncEngineOptions(engineSelect, languageSelect, taskSelect, sizeSelect, note) {
+            if (!REGISTRY) return;
+            const spec = REGISTRY.engines[engineSelect.value];
+            if (!spec) return;
+
+            const prevLang = languageSelect.value;
+            const prevTask = taskSelect.value;
+
+            const langs = spec.languages.map(l => ({ value: l.code, label: l.name }));
+            fillSelect(languageSelect, langs,
+                langs.some(l => l.value === prevLang) ? prevLang : langs[0].value);
+
+            const tasks = spec.tasks.map(t => ({ value: t, label: TASK_LABELS[t] || t }));
+            fillSelect(taskSelect, tasks,
+                tasks.some(t => t.value === prevTask) ? prevTask : tasks[0].value);
+
+            if (sizeSelect) {
+                const hasSizes = spec.sizes && spec.sizes.length > 0;
+                const sizes = (spec.sizes || []).map(s => ({ value: s, label: s }));
+                if (hasSizes) fillSelect(sizeSelect, sizes, spec.default_size || sizes[0].value);
+                sizeSelect.style.display = hasSizes ? '' : 'none';
+                if (liveModelLabel && sizeSelect === liveModelSelect) {
+                    liveModelLabel.style.display = hasSizes ? '' : 'none';
+                }
+            }
+
+            if (note) note.textContent = spec.notes || '';
+        }
+
+        async function loadRegistry() {
+            try {
+                const res = await fetch(`${API_BASE}/engines`);
+                REGISTRY = await res.json();
+            } catch (err) {
+                console.error('Could not load engine registry:', err);
+                return;
+            }
+
+            const all = Object.entries(REGISTRY.engines)
+                .map(([value, spec]) => ({ value, label: spec.label }));
+            fillSelect(uploadEngineSelect, all, REGISTRY.default_engine);
+            syncEngineOptions(uploadEngineSelect, uploadLanguageSelect, uploadTaskSelect,
+                null, uploadEngineNote);
+            uploadEngineSelect.onchange = () => syncEngineOptions(
+                uploadEngineSelect, uploadLanguageSelect, uploadTaskSelect, null, uploadEngineNote);
+
+            // Live only offers engines that actually implement streaming.
+            const streaming = all.filter(e => REGISTRY.streaming_engines.includes(e.value));
+            fillSelect(liveEngineSelect, streaming, streaming[0] && streaming[0].value);
+            syncEngineOptions(liveEngineSelect, liveLanguageSelect, liveTaskSelect,
+                liveModelSelect, null);
+            liveEngineSelect.onchange = () => syncEngineOptions(
+                liveEngineSelect, liveLanguageSelect, liveTaskSelect, liveModelSelect, null);
+        }
         const startLiveBtn = document.getElementById('startLiveBtn');
         const stopLiveBtn = document.getElementById('stopLiveBtn');
         const liveTranscript = document.getElementById('liveTranscript');
@@ -1021,14 +1114,17 @@
                 isLiveStreaming = true;
 
                 // Connect WebSocket
+                const engine = liveEngineSelect.value;
                 const model = liveModelSelect.value;
+                const language = liveLanguageSelect.value;
+                const task = liveTaskSelect.value;
                 const wsUrl = `${window.location.origin.replace(/^http/, 'ws')}/ws/transcribe`;
 
                 liveWs = new WebSocket(wsUrl);
                 liveWs.binaryType = 'arraybuffer';
 
                 liveWs.onopen = () => {
-                    liveWs.send(JSON.stringify({ model }));
+                    liveWs.send(JSON.stringify({ engine, model, language, task }));
                 };
 
                 liveWs.onmessage = (e) => {
@@ -1055,6 +1151,9 @@
                             renderLiveTranscript();
                         } else if (msg.type === 'done') {
                             teardownLiveStreaming();
+                        } else if (msg.type === 'warning') {
+                            console.warn('[live-stt]', msg.message);
+                            liveTranscript.innerText = '⚠️ ' + msg.message;
                         } else if (msg.type === 'error') {
                             liveTranscript.innerText = '❌ Error: ' + msg.message;
                         }
@@ -1075,6 +1174,9 @@
                 stopLiveBtn.classList.remove('hidden');
                 liveStatusBadge.classList.remove('hidden');
                 liveModelSelect.disabled = true;
+                liveEngineSelect.disabled = true;
+                liveLanguageSelect.disabled = true;
+                liveTaskSelect.disabled = true;
 
             } catch (err) {
                 liveTranscript.innerText = '❌ Error: ' + err.message;
@@ -1098,6 +1200,9 @@
             stopLiveBtn.disabled = false;
             liveStatusBadge.classList.add('hidden');
             liveModelSelect.disabled = false;
+            liveEngineSelect.disabled = false;
+            liveLanguageSelect.disabled = false;
+            liveTaskSelect.disabled = false;
         }
 
         // Immediate teardown: closes the socket, stops the mic, resets the UI.
@@ -1138,6 +1243,7 @@
         stopLiveBtn.onclick = stopLiveStreaming;
 
         // --- Lifecycle ---
+        loadRegistry();
         loadTasks();
         setInterval(loadTasks, 5000);
         setInterval(checkHealth, 10000);

pyproject.toml

@@ -17,6 +17,7 @@ dependencies = [
     "custom_logger @ git+https://github.com/jebin2/custom_logger.git",
     "stt-runner[parakeet] @ git+https://github.com/jebin2/STT.git",
     "faster-whisper",
+    "jebin-lib[all] @ git+https://github.com/jebin2/lib.git",
 ]
 
 [project.scripts]