omnius 1.0.434 → 1.0.436

package/dist/scripts/live-whisper.py

@@ -85,6 +85,33 @@ def emit_transcript(text: str, is_final: bool = False, doa=None, consensus=None)
     emit(event)
 
 
+def emit_consensus_rejected(primary: str, secondary: str, reason: str):
+    emit({
+        "type": "consensus_rejected",
+        "primary": primary[:200],
+        "secondary": (secondary or "")[:200],
+        "reason": reason,
+    })
+
+
+def cuda_memory_reserved_mb(device: str) -> int:
+    if not str(device).startswith("cuda"):
+        return 0
+    try:
+        import torch
+        raw = str(device).split(":", 1)[1] if ":" in str(device) else ""
+        index = int(raw) if raw.strip().isdigit() else torch.cuda.current_device()
+        try:
+            torch.cuda.synchronize(index)
+        except Exception:
+            pass
+        reserved = int(torch.cuda.memory_reserved(index))
+        allocated = int(torch.cuda.memory_allocated(index))
+        return max(0, round(max(reserved, allocated) / (1024 * 1024)))
+    except Exception:
+        return 0
+
+
 def host_cuda_hardware_present() -> bool:
     """Best-effort CUDA hardware hint, including Jetson/Orin nodes."""
     for path in (
@@ -100,6 +127,32 @@ def host_cuda_hardware_present() -> bool:
     return bool(visible and visible not in ("none", "void", "no"))
 
 
+def asr_cpu_allowed() -> bool:
+    raw = os.environ.get("OMNIUS_ASR_ALLOW_CPU", "").strip().lower()
+    return raw in ("1", "true", "yes", "on")
+
+
+def jetson_host_hint() -> str:
+    try:
+        model = Path("/proc/device-tree/model").read_text(errors="ignore").replace("\x00", " ").strip()
+    except Exception:
+        model = ""
+    if model and any(token in model.lower() for token in ("jetson", "orin", "tegra")):
+        return (
+            f" Detected {model}. Install a JetPack/L4T-compatible CUDA PyTorch wheel in the Omnius ASR venv; "
+            "the generic pip torch wheel is often CPU-only or CUDA-incompatible on Jetson."
+        )
+    return ""
+
+
+def cuda_required_error(reason: str):
+    emit_error(
+        f"CUDA-only ASR is enabled and Whisper cannot use CUDA: {reason}."
+        f"{jetson_host_hint()} Set OMNIUS_ASR_ALLOW_CPU=1 only for explicit emergency CPU fallback."
+    )
+    sys.exit(1)
+
+
 def select_whisper_device() -> str:
     """Force Whisper onto CUDA whenever PyTorch can see a CUDA device.
 
@@ -110,9 +163,8 @@ def select_whisper_device() -> str:
     try:
         import torch
     except Exception as e:
-        if host_cuda_hardware_present():
-            emit_error(f"CUDA hardware appears present, but PyTorch could not be imported for CUDA Whisper ({e}); refusing CPU fallback.")
-            sys.exit(1)
+        if host_cuda_hardware_present() or not asr_cpu_allowed():
+            cuda_required_error(f"PyTorch could not be imported ({e})")
         emit_status(f"PyTorch unavailable for CUDA probe ({e}); using CPU because CUDA is not available to Whisper.")
         return "cpu"
 
@@ -120,17 +172,15 @@ def select_whisper_device() -> str:
         cuda_count = int(torch.cuda.device_count())
         cuda_available = bool(torch.cuda.is_available() and cuda_count > 0)
     except Exception as e:
-        if host_cuda_hardware_present():
-            emit_error(f"CUDA hardware appears present, but PyTorch CUDA probe failed ({e}); refusing CPU fallback.")
-            sys.exit(1)
+        if host_cuda_hardware_present() or not asr_cpu_allowed():
+            cuda_required_error(f"PyTorch CUDA probe failed ({e})")
         emit_status(f"CUDA probe failed ({e}); using CPU because CUDA is not available to Whisper.")
         return "cpu"
 
     if not cuda_available:
         cuda_version = getattr(getattr(torch, "version", None), "cuda", None)
-        if host_cuda_hardware_present():
-            emit_error(f"CUDA hardware appears present, but PyTorch reports CUDA unavailable (torch.version.cuda={cuda_version}, device_count={cuda_count}); refusing CPU fallback.")
-            sys.exit(1)
+        if host_cuda_hardware_present() or not asr_cpu_allowed():
+            cuda_required_error(f"PyTorch reports CUDA unavailable (torch.version.cuda={cuda_version}, device_count={cuda_count})")
         emit_status(f"CUDA unavailable to PyTorch (torch.version.cuda={cuda_version}, device_count={cuda_count}); using CPU fallback.")
         return "cpu"
 
@@ -151,7 +201,7 @@ def select_whisper_device() -> str:
         emit_error(f"CUDA is available but cuda:{device_index} could not be selected ({e}); refusing CPU fallback.")
         sys.exit(1)
 
-    emit_status(f"CUDA available; forcing Whisper onto cuda:{device_index} ({name}).")
+    emit_status(f"CUDA available; forcing Whisper onto cuda:{device_index} ({name}); torch={getattr(torch, '__version__', 'unknown')} cuda={getattr(getattr(torch, 'version', None), 'cuda', None)}.")
     return f"cuda:{device_index}"
 
 # ---------------------------------------------------------------------------
@@ -442,9 +492,15 @@ def main():
     if tuning is not None:
         emit_status("ReSpeaker DSP active: hardware VAD, echo cancellation, DOA.")
 
-    emit({"type": "ready"})
-
     fp16 = str(device).startswith("cuda")
+    emit({
+        "type": "ready",
+        "model": args.model,
+        "device": str(device),
+        "cuda": bool(fp16),
+        "consensusModel": consensus_name if consensus_model is not None else None,
+        "vramUsedMB": cuda_memory_reserved_mb(str(device)),
+    })
 
     def run_transcribe(m, samples):
         return m.transcribe(
@@ -525,47 +581,46 @@ def main():
             return
         samples = amplify(samples)
         try:
-            if consensus_model is not None:
-                from concurrent.futures import ThreadPoolExecutor
-                with ThreadPoolExecutor(max_workers=2) as pool:
-                    primary_future = pool.submit(run_transcribe, model, samples)
-                    secondary_future = pool.submit(run_transcribe, consensus_model, samples)
-                    result = primary_future.result()
-                    secondary = secondary_future.result()
-            else:
-                result = run_transcribe(model, samples)
-                secondary = None
+            result = run_transcribe(model, samples)
 
             text = _segment_filtered_text(result)
             if not text:
                 emit_status("Whisper final produced no accepted speech text.")
                 return
-            if secondary is not None:
-                secondary_text = _segment_filtered_text(secondary)
-                lang_a = str(result.get("language", "")).lower()
-                lang_b = str(secondary.get("language", "")).lower()
-                lang_disagree = bool(lang_a and lang_b and lang_a != lang_b and not args.language)
-                if lang_disagree or not _texts_agree(text, secondary_text, args.consensus_threshold):
-                    emit({
-                        "type": "consensus_rejected",
-                        "primary": text[:200],
-                        "secondary": (secondary_text or "")[:200],
-                        "reason": "language_mismatch" if lang_disagree else "low_similarity",
-                    })
-                    return
             if text == last_final_text:
                 return
-            last_final_text = text
-            # consensus=True only when BOTH models ran and converged. When the
-            # second model is off/unavailable, omit consensus metadata entirely
-            # so legacy single-model consumers do not interpret consensus=false
-            # as an explicit dual-ASR rejection.
-            emit_transcript(
-                text,
-                is_final=True,
-                doa=tuning.doa() if tuning else None,
-                consensus=True if consensus_model is not None else None,
-            )
+            doa = tuning.doa() if tuning else None
+            if consensus_model is None:
+                last_final_text = text
+                emit_transcript(text, is_final=True, doa=doa, consensus=None)
+                return
+
+            # Fast UX path: surface the primary model's finalized text
+            # immediately as a non-final transcript. The secondary model then
+            # validates whether it is safe to accept as a final utterance.
+            emit_transcript(text, is_final=False, doa=doa, consensus=False)
+
+            def validate_consensus(primary_text, primary_result, audio_samples, primary_doa):
+                nonlocal last_final_text
+                try:
+                    secondary = run_transcribe(consensus_model, audio_samples)
+                    secondary_text = _segment_filtered_text(secondary)
+                    lang_a = str(primary_result.get("language", "")).lower()
+                    lang_b = str(secondary.get("language", "")).lower()
+                    lang_disagree = bool(lang_a and lang_b and lang_a != lang_b and not args.language)
+                    if lang_disagree or not _texts_agree(primary_text, secondary_text, args.consensus_threshold):
+                        emit_consensus_rejected(primary_text, secondary_text, "language_mismatch" if lang_disagree else "low_similarity")
+                        return
+                    last_final_text = primary_text
+                    emit_transcript(primary_text, is_final=True, doa=primary_doa, consensus=True)
+                except Exception as e:
+                    emit_error(f"Consensus validation error: {e}")
+
+            threading.Thread(
+                target=validate_consensus,
+                args=(text, result, samples.copy(), doa),
+                daemon=True,
+            ).start()
         except Exception as e:
             emit_error(f"Transcription error: {e}")
 

package/dist/scripts/transcribe-file.py

@@ -1,20 +1,16 @@
 #!/usr/bin/env python3
 """
-Transcribe an audio file using openai-whisper (CPU-only).
+Transcribe an audio file using openai-whisper (CUDA-only by default).
 
 stdin:  JSON {"path": "...", "model": "tiny|base|small|medium|large-v3"}
 stdout: JSON {"text": "...", "duration": null, "segments": []}
         or   {"error": "<kind>", "message": "..."}
 
-Force-loads on CPU because the venv's torch may not match the local GPU
-(e.g. a GT 1030 with sm_61 against a sm_75+ torch build) — those mismatches
-print noisy CUDA warnings and then crash. CPU is slower but always works.
+ASR is GPU-first: CPU fallback is refused unless OMNIUS_ASR_ALLOW_CPU=1.
 """
 import sys, os, json, warnings
 
-# Quiet CUDA warnings from torch even though we won't use the GPU.
 warnings.filterwarnings("ignore")
-os.environ.setdefault("CUDA_VISIBLE_DEVICES", "")  # hide all GPUs
 os.environ.setdefault("PYTHONWARNINGS", "ignore")
 
 try:
@@ -39,8 +35,22 @@ def main() -> None:
 
     model_name = data.get("model") or "tiny"
     try:
-        model = whisper.load_model(model_name, device="cpu")
-        result = model.transcribe(path, fp16=False)
+        device = os.environ.get("OMNIUS_ASR_DEVICE", "cuda").strip().lower() or "cuda"
+        allow_cpu = os.environ.get("OMNIUS_ASR_ALLOW_CPU", "").strip().lower() in ("1", "true", "yes", "on")
+        if device == "auto":
+            device = "cuda"
+        if device.startswith("cuda"):
+            import torch
+            if not torch.cuda.is_available() or torch.cuda.device_count() <= 0:
+                raise RuntimeError(
+                    f"CUDA-only ASR requested but torch cannot use CUDA "
+                    f"(torch.version.cuda={getattr(torch.version, 'cuda', None)}, device_count={torch.cuda.device_count()}). "
+                    "Install a CUDA-enabled PyTorch build for this device, or set OMNIUS_ASR_ALLOW_CPU=1 only for emergency fallback."
+                )
+        elif device == "cpu" and not allow_cpu:
+            raise RuntimeError("CPU ASR refused. Set OMNIUS_ASR_ALLOW_CPU=1 only for explicit emergency fallback.")
+        model = whisper.load_model(model_name, device=device)
+        result = model.transcribe(path, fp16=device.startswith("cuda"), condition_on_previous_text=False)
     except Exception as e:
         print(json.dumps({"error": "whisper_failed", "message": str(e)}))
         return

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.434",
+  "version": "1.0.436",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.434",
+      "version": "1.0.436",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.434",
+  "version": "1.0.436",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",