omnius 1.0.429 → 1.0.431

package/dist/scripts/live-whisper.py

@@ -84,6 +84,76 @@ def emit_transcript(text: str, is_final: bool = False, doa=None, consensus=None)
         event["consensus"] = bool(consensus)
     emit(event)
 
+
+def host_cuda_hardware_present() -> bool:
+    """Best-effort CUDA hardware hint, including Jetson/Orin nodes."""
+    for path in (
+        "/dev/nvidiactl",
+        "/dev/nvidia0",
+        "/dev/nvhost-gpu",
+        "/proc/driver/nvidia/gpus",
+        "/sys/devices/gpu.0",
+    ):
+        if os.path.exists(path):
+            return True
+    visible = os.environ.get("NVIDIA_VISIBLE_DEVICES", "").strip().lower()
+    return bool(visible and visible not in ("none", "void", "no"))
+
+
+def select_whisper_device() -> str:
+    """Force Whisper onto CUDA whenever PyTorch can see a CUDA device.
+
+    CPU is only allowed when CUDA is genuinely unavailable to this Python
+    runtime. If CUDA is visible but unusable, fail loudly instead of silently
+    degrading into slow CPU transcription.
+    """
+    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)
+        emit_status(f"PyTorch unavailable for CUDA probe ({e}); using CPU because CUDA is not available to Whisper.")
+        return "cpu"
+
+    try:
+        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)
+        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)
+        emit_status(f"CUDA unavailable to PyTorch (torch.version.cuda={cuda_version}, device_count={cuda_count}); using CPU fallback.")
+        return "cpu"
+
+    raw_index = os.environ.get("OMNIUS_ASR_CUDA_DEVICE", "0").strip() or "0"
+    try:
+        device_index = int(raw_index)
+    except ValueError:
+        emit_error(f"Invalid OMNIUS_ASR_CUDA_DEVICE={raw_index!r}; refusing CPU fallback because CUDA is available.")
+        sys.exit(1)
+    if device_index < 0 or device_index >= cuda_count:
+        emit_error(f"OMNIUS_ASR_CUDA_DEVICE={device_index} outside available CUDA device range 0..{cuda_count - 1}; refusing CPU fallback.")
+        sys.exit(1)
+
+    try:
+        torch.cuda.set_device(device_index)
+        name = torch.cuda.get_device_name(device_index)
+    except Exception as e:
+        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}).")
+    return f"cuda:{device_index}"
+
 # ---------------------------------------------------------------------------
 # Venv bootstrap
 # ---------------------------------------------------------------------------
@@ -344,18 +414,15 @@ def main():
 
     import whisper
 
-    emit_status(f"Loading Whisper {args.model} model...")
+    device = select_whisper_device()
+    emit_status(f"Loading Whisper {args.model} model on {device}...")
     try:
-        device = "cpu"
-        try:
-            import torch
-            if torch.cuda.is_available():
-                device = "cuda"
-        except ImportError:
-            pass
         model = whisper.load_model(args.model, device=device)
     except Exception as e:
-        emit_error(f"Failed to load model: {e}")
+        if str(device).startswith("cuda"):
+            emit_error(f"Failed to load model on {device}; refusing CPU fallback because CUDA is available: {e}")
+        else:
+            emit_error(f"Failed to load model on CPU fallback: {e}")
         sys.exit(1)
 
     # Consensus model: hallucinations (mixed-language garbage on noisy or
@@ -363,7 +430,7 @@ def main():
     consensus_model = None
     consensus_name = (args.consensus_model or "off").strip().lower()
     if consensus_name not in ("off", "none", "", args.model):
-        emit_status(f"Loading consensus Whisper {consensus_name} model...")
+        emit_status(f"Loading consensus Whisper {consensus_name} model on {device}...")
         try:
             consensus_model = whisper.load_model(consensus_name, device=device)
         except Exception as e:
@@ -377,7 +444,7 @@ def main():
 
     emit({"type": "ready"})
 
-    fp16 = (device == "cuda")
+    fp16 = str(device).startswith("cuda")
 
     def run_transcribe(m, samples):
         return m.transcribe(

package/npm-shrinkwrap.json

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

package/package.json

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