omnius 1.0.618 → 1.0.620

package/dist/scripts/live-nemotron.py

@@ -61,6 +61,17 @@ WINDOW_SECONDS = 8.0
 # HuggingFace model identifier
 MODEL_ID = "nvidia/nemotron-speech-streaming-en-0.6b"
 
+# All managed ASR weights live outside the npm package so upgrades do not
+# invalidate an already-pulled model. HuggingFace honors HF_HOME for both the
+# NeMo and transformers loaders below.
+MODEL_CACHE_ROOT = Path(
+    os.environ.get(
+        "OMNIUS_ASR_MODEL_DIR",
+        str(Path.home() / ".omnius" / "models" / "asr" / "nemotron-streaming"),
+    )
+).expanduser()
+os.environ.setdefault("HF_HOME", str(MODEL_CACHE_ROOT))
+
 # ---------------------------------------------------------------------------
 # Output helpers (JSON lines to stdout)
 # ---------------------------------------------------------------------------
@@ -81,12 +92,42 @@ def emit_error(msg: str):
 def emit_transcript(text: str, is_final: bool = False, backend: str = "nemotron"):
     emit({"type": "transcript", "text": text, "isFinal": is_final, "backend": backend})
 
+
+def asr_cpu_allowed() -> bool:
+    return os.environ.get("OMNIUS_ASR_ALLOW_CPU", "").strip().lower() in ("1", "true", "yes", "on")
+
+
+def select_asr_device() -> str:
+    """Select CUDA whenever it is present; never silently retry on CPU."""
+    import torch
+
+    if torch.cuda.is_available() and torch.cuda.device_count() > 0:
+        raw_index = os.environ.get("OMNIUS_ASR_CUDA_DEVICE", "0").strip() or "0"
+        try:
+            index = int(raw_index)
+        except ValueError as error:
+            raise RuntimeError(f"Invalid OMNIUS_ASR_CUDA_DEVICE={raw_index!r}") from error
+        if index < 0 or index >= torch.cuda.device_count():
+            raise RuntimeError(f"OMNIUS_ASR_CUDA_DEVICE={index} is outside CUDA device range 0..{torch.cuda.device_count() - 1}")
+        torch.cuda.set_device(index)
+        return f"cuda:{index}"
+    if asr_cpu_allowed():
+        return "cpu"
+    cuda_version = getattr(getattr(torch, "version", None), "cuda", None)
+    raise RuntimeError(
+        f"CUDA-only ASR is enabled but PyTorch cannot use CUDA (torch.version.cuda={cuda_version}, "
+        f"device_count={torch.cuda.device_count()}). Set OMNIUS_ASR_ALLOW_CPU=1 only for an explicit emergency fallback."
+    )
+
 # ---------------------------------------------------------------------------
 # Venv bootstrap (same pattern as live-whisper.py)
 # ---------------------------------------------------------------------------
 
 def _in_venv() -> bool:
-    return sys.prefix != sys.base_prefix and str(SCRIPT_DIR) in sys.prefix
+    # Omnius launches this worker from its managed CUDA Python environment.
+    # Requiring the script directory here used to create a second, CPU-prone
+    # venv beside the npm package on every Jetson install.
+    return sys.prefix != sys.base_prefix
 
 
 def _ensure_venv():
@@ -125,7 +166,7 @@ def _ensure_deps():
         emit_status(f"Installing core deps: {', '.join(need)}...")
         try:
             subprocess.check_call(
-                [str(PIP), "install", *need],
+                [sys.executable, "-m", "pip", "install", *need],
                 stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
             )
         except subprocess.CalledProcessError as e:
@@ -144,7 +185,7 @@ def _ensure_deps():
         emit_status("Installing nemo_toolkit[asr] (large — may take a few minutes)...")
         try:
             subprocess.check_call(
-                [str(PIP), "install", "nemo_toolkit[asr]"],
+                [sys.executable, "-m", "pip", "install", "nemo_toolkit[asr]"],
                 stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
                 timeout=600,
             )
@@ -175,40 +216,22 @@ import numpy as np  # noqa: E402
 # Backend loaders
 # ---------------------------------------------------------------------------
 
-def _load_nemo_model(model_id: str = MODEL_ID, force_cpu: bool = False):
-    """Try to load via NeMo toolkit. Returns (model, device) or (None, None).
-
-    Handles the "cuDNN not compatible with SM < 7.5" error by retrying
-    on CPU. This is the common failure mode on older NVIDIA GPUs where
-    the installed torch has a newer cuDNN than the hardware supports.
-    """
-    # If caller asked for CPU explicitly, hide the GPU from torch before
-    # importing anything that might touch CUDA.
-    if force_cpu:
-        os.environ["CUDA_VISIBLE_DEVICES"] = ""
+def _load_nemo_model(model_id: str = MODEL_ID):
+    """Load NeMo on the selected CUDA device, with no implicit CPU retry."""
     try:
         import nemo.collections.asr as nemo_asr
         import torch
     except ImportError:
         return (None, None)
     try:
+        device = select_asr_device()
         emit_status(f"Loading NeMo model {model_id}...")
         model = nemo_asr.models.ASRModel.from_pretrained(model_id)
         model.eval()
-        # Force CPU to avoid cuDNN version mismatches on older GPUs
-        if force_cpu or not torch.cuda.is_available():
-            try:
-                model = model.cpu()
-            except Exception:
-                pass
-        return (model, "cpu" if (force_cpu or not torch.cuda.is_available()) else "cuda")
+        model = model.to(torch.device(device))
+        return (model, device)
     except Exception as e:
-        msg = str(e)
-        emit_status(f"NeMo load failed: {msg[:200]}")
-        # Retry on CPU if the error looks like a cuDNN / device compat issue
-        if not force_cpu and any(k in msg for k in ("cuDNN", "SM <", "CUDA", "device side")):
-            emit_status("Retrying NeMo load on CPU only...")
-            return _load_nemo_model(model_id, force_cpu=True)
+        emit_status(f"NeMo load failed: {str(e)[:200]}")
         return (None, None)
 
 
@@ -220,13 +243,8 @@ def _load_transformers_model(model_id: str = MODEL_ID):
         return None
     try:
         emit_status(f"Loading transformers pipeline for {model_id}...")
-        device = -1
-        try:
-            import torch
-            if torch.cuda.is_available():
-                device = 0
-        except ImportError:
-            pass
+        selected = select_asr_device()
+        device = int(selected.split(":", 1)[1]) if selected.startswith("cuda:") else -1
         pipe = pipeline(
             task="automatic-speech-recognition",
             model=model_id,
@@ -329,7 +347,7 @@ def _transcribe_buffer_transformers(pipe, audio: np.ndarray) -> str:
 # File transcription mode (single-shot)
 # ---------------------------------------------------------------------------
 
-def transcribe_file(path: str, language: str = "en") -> int:
+def transcribe_file(path: str, language: str = "en", model_id: str = MODEL_ID) -> int:
     """Single-file transcription — reads a WAV, prints one transcript
     JSON line, exits. Used by AsrListenTool's file path. Exit code 0
     on success, 1 on failure."""
@@ -348,16 +366,17 @@ def transcribe_file(path: str, language: str = "en") -> int:
         emit_error(f"Failed to load audio file {path}: {e}")
         return 1
 
-    (model, device) = _load_nemo_model()
+    (model, device) = _load_nemo_model(model_id)
     backend = "nemo"
     if model is None:
-        model = _load_transformers_model()
+        device = select_asr_device()
+        model = _load_transformers_model(model_id)
         backend = "transformers"
     if model is None:
         emit_error("No nemotron backend available (tried NeMo + transformers)")
         return 1
 
-    emit({"type": "ready", "backend": backend, "device": device or "cpu"})
+    emit({"type": "ready", "backend": backend, "device": device or "cpu", "cuda": str(device).startswith("cuda")})
 
     t0 = time.time()
     if backend == "nemo":
@@ -463,14 +482,28 @@ def main():
     parser.add_argument("--window-seconds", type=float, default=WINDOW_SECONDS, help="Sliding window size")
     parser.add_argument("--stdin", action="store_true", help="Explicit stdin mode (default when no --file)")
     parser.add_argument("--check", action="store_true", help="Just verify the script parses + imports; no model load")
+    parser.add_argument("--setup", action="store_true", help="Pull and validate the selected model on the selected device, then exit")
     args = parser.parse_args()
 
     if args.check:
         emit({"type": "check", "ok": True, "script": str(Path(__file__).resolve())})
         return 0
 
+    if args.setup:
+        model, device = _load_nemo_model(args.model)
+        backend = "nemo"
+        if model is None:
+            device = select_asr_device()
+            model = _load_transformers_model(args.model)
+            backend = "transformers"
+        if model is None:
+            emit_error("No CUDA Nemotron backend available (tried NeMo + transformers)")
+            return 1
+        emit({"type": "ready", "backend": backend, "device": device, "cuda": str(device).startswith("cuda"), "model": args.model})
+        return 0
+
     if args.file:
-        return transcribe_file(args.file, args.language)
+        return transcribe_file(args.file, args.language, args.model)
     return stream_stdin(args)
 
 

package/dist/scripts/live-whisper.py

@@ -59,6 +59,14 @@ BLOCK_SECONDS = 0.2
 BLOCK_SAMPLES = int(SAMPLE_RATE * BLOCK_SECONDS)
 
 
+def whisper_model_dir() -> Path:
+    """Use Omnius' durable model store instead of a package-local cache."""
+    configured = os.environ.get("OMNIUS_ASR_MODEL_DIR", "").strip()
+    if configured:
+        return Path(configured).expanduser()
+    return Path.home() / ".omnius" / "models" / "asr" / "openai-whisper"
+
+
 def env_float(name: str, default: float) -> float:
     raw = os.environ.get(name, "").strip()
     if not raw:
@@ -496,7 +504,9 @@ def main():
     device = select_whisper_device()
     emit_status(f"Loading Whisper {args.model} model on {device}...")
     try:
-        model = whisper.load_model(args.model, device=device)
+        model_dir = whisper_model_dir()
+        model_dir.mkdir(parents=True, exist_ok=True)
+        model = whisper.load_model(args.model, device=device, download_root=str(model_dir))
     except Exception as e:
         if str(device).startswith("cuda"):
             emit_error(f"Failed to load model on {device}; refusing CPU fallback because CUDA is available: {e}")
@@ -511,7 +521,11 @@ def main():
     if consensus_name not in ("off", "none", "", args.model):
         emit_status(f"Loading consensus Whisper {consensus_name} model on {device}...")
         try:
-            consensus_model = whisper.load_model(consensus_name, device=device)
+            consensus_model = whisper.load_model(
+                consensus_name,
+                device=device,
+                download_root=str(whisper_model_dir()),
+            )
         except Exception as e:
             emit_status(f"Consensus model unavailable ({e}); running single-model.")
             consensus_model = None

package/dist/update-worker.js

@@ -293353,7 +293353,6 @@ var MM_INDEX = join9(MM_DIR, "index.json");
 // packages/execution/dist/asr/registry.js
 var VIBEVOICE_ASR_MODEL_REVISION = "d0c9efdb8d614685062c04425d91e01b6f37d944";
 var VIBEVOICE_ASR_WEIGHTS_BYTES = 17348198410;
-var NEMOTRON_DISABLED_REASON = "Nemotron is catalogued but its legacy self-installing worker is disabled until it is migrated to the managed fail-closed runtime.";
 var whisperCapabilities = Object.freeze({
   file: true,
   pcmStream: true,
@@ -293377,9 +293376,9 @@ function whisperModel(engineId, id, label) {
     languages: ["multilingual"],
     capabilities: whisperCapabilities,
     resources: {
-      cpuSupported: engineId === "transcribe-cli",
+      cpuSupported: false,
       architectures: ["x64", "arm64"],
-      notes: engineId === "transcribe-cli" ? ["Managed transcribe-cli runtime; implementation may use faster-whisper or ONNX."] : ["CUDA is required by Omnius unless an explicit local override is configured."]
+      notes: ["CUDA is required by Omnius unless an explicit local override is configured."]
     }
   };
 }
@@ -293395,15 +293394,6 @@ var ASR_ENGINES = Object.freeze([
     setupMode: "managed",
     models: whisperModels("openai-whisper")
   },
-  {
-    id: "transcribe-cli",
-    label: "transcribe-cli",
-    detail: "Managed faster-whisper/ONNX bridge for live and file transcription",
-    provider: "transcribe-cli",
-    runtime: "node",
-    setupMode: "managed",
-    models: whisperModels("transcribe-cli")
-  },
   {
     id: "nemotron-streaming",
     label: "NVIDIA Nemotron Speech Streaming",
@@ -293411,8 +293401,6 @@ var ASR_ENGINES = Object.freeze([
     provider: "NVIDIA",
     runtime: "python",
     setupMode: "managed",
-    availability: "disabled",
-    unavailableReason: NEMOTRON_DISABLED_REASON,
     models: [
       {
         id: "nemotron-speech-streaming-en-0.6b",

package/docs/DISCOVERY.json

@@ -3249,6 +3249,198 @@
         "packages/cli/src/api/openapi.ts"
       ]
     },
+    {
+      "id": "api.v1-asr-engines-engine-id-models-model-id-deploy",
+      "kind": "api",
+      "title": "/v1/asr/engines/{engineId}/models/{modelId}/deploy",
+      "summary": "Pull, select, and activate one exact ASR model",
+      "aliases": [
+        "/v1/asr/engines/{engineId}/models/{modelId}/deploy"
+      ],
+      "keywords": [
+        "rest",
+        "openapi",
+        "POST",
+        "ASR",
+        "v1",
+        "asr",
+        "engines",
+        "{engineId}",
+        "models",
+        "{modelId}",
+        "deploy"
+      ],
+      "maturity": "stable",
+      "layer": "interface",
+      "audiences": [
+        "integrator",
+        "service-agent",
+        "coding-agent"
+      ],
+      "interfaces": [
+        {
+          "type": "rest",
+          "target": "POST /v1/asr/engines/{engineId}/models/{modelId}/deploy"
+        },
+        {
+          "type": "openapi",
+          "target": "/openapi.json"
+        }
+      ],
+      "references": [
+        {
+          "type": "source",
+          "target": "packages/cli/src/api/openapi.ts",
+          "relation": "openapi-source"
+        },
+        {
+          "type": "documentation",
+          "target": "docs/reference/rest-api.md",
+          "relation": "endpoint-inventory"
+        }
+      ],
+      "methods": [
+        "POST"
+      ],
+      "tags": [
+        "ASR"
+      ],
+      "operations": {
+        "post": {
+          "summary": "Pull, select, and activate one exact ASR model",
+          "tags": [
+            "ASR"
+          ],
+          "description": "Optional body: {device}. Persists the selection after the managed runtime and weights are ready.",
+          "parameters": [
+            {
+              "name": "engineId",
+              "in": "path",
+              "required": true,
+              "schema": {
+                "type": "string"
+              }
+            },
+            {
+              "name": "modelId",
+              "in": "path",
+              "required": true,
+              "schema": {
+                "type": "string"
+              }
+            }
+          ],
+          "responses": {
+            "200": {
+              "description": "Model deployed and selected"
+            },
+            "500": {
+              "description": "Deploy or CUDA validation failed"
+            }
+          }
+        }
+      },
+      "source_of_truth": [
+        "GET /openapi.json",
+        "packages/cli/src/api/openapi.ts"
+      ]
+    },
+    {
+      "id": "api.v1-asr-engines-engine-id-models-model-id-pull",
+      "kind": "api",
+      "title": "/v1/asr/engines/{engineId}/models/{modelId}/pull",
+      "summary": "Pull one exact ASR model and validate its managed runtime",
+      "aliases": [
+        "/v1/asr/engines/{engineId}/models/{modelId}/pull"
+      ],
+      "keywords": [
+        "rest",
+        "openapi",
+        "POST",
+        "ASR",
+        "v1",
+        "asr",
+        "engines",
+        "{engineId}",
+        "models",
+        "{modelId}",
+        "pull"
+      ],
+      "maturity": "stable",
+      "layer": "interface",
+      "audiences": [
+        "integrator",
+        "service-agent",
+        "coding-agent"
+      ],
+      "interfaces": [
+        {
+          "type": "rest",
+          "target": "POST /v1/asr/engines/{engineId}/models/{modelId}/pull"
+        },
+        {
+          "type": "openapi",
+          "target": "/openapi.json"
+        }
+      ],
+      "references": [
+        {
+          "type": "source",
+          "target": "packages/cli/src/api/openapi.ts",
+          "relation": "openapi-source"
+        },
+        {
+          "type": "documentation",
+          "target": "docs/reference/rest-api.md",
+          "relation": "endpoint-inventory"
+        }
+      ],
+      "methods": [
+        "POST"
+      ],
+      "tags": [
+        "ASR"
+      ],
+      "operations": {
+        "post": {
+          "summary": "Pull one exact ASR model and validate its managed runtime",
+          "tags": [
+            "ASR"
+          ],
+          "description": "Optional body: {device}. Downloads model weights into Omnius-managed storage and verifies CUDA placement for Whisper and Nemotron.",
+          "parameters": [
+            {
+              "name": "engineId",
+              "in": "path",
+              "required": true,
+              "schema": {
+                "type": "string"
+              }
+            },
+            {
+              "name": "modelId",
+              "in": "path",
+              "required": true,
+              "schema": {
+                "type": "string"
+              }
+            }
+          ],
+          "responses": {
+            "200": {
+              "description": "Weights are ready"
+            },
+            "500": {
+              "description": "Runtime, download, or CUDA validation failed"
+            }
+          }
+        }
+      },
+      "source_of_truth": [
+        "GET /openapi.json",
+        "packages/cli/src/api/openapi.ts"
+      ]
+    },
     {
       "id": "api.v1-asr-engines-engine-id-setup",
       "kind": "api",
@@ -3309,7 +3501,7 @@
           "tags": [
             "ASR"
           ],
-          "description": "Currently implemented for vibevoice-transformers. The exact microsoft/VibeVoice-ASR revision and tokenizer snapshot are stored under the unified Omnius ASR model/runtime directories; model weights are never bundled into npm.",
+          "description": "Body: {modelId?, device?}. Installs the managed runtime and pulls the requested model. Whisper and Nemotron loads validate their selected CUDA device; VibeVoice stores its pinned model and tokenizer snapshot under Omnius' ASR runtime directories.",
           "parameters": [
             {
               "name": "engineId",
@@ -3413,7 +3605,7 @@
           "tags": [
             "ASR"
           ],
-          "description": "Body: {engineId, modelId?, setup?, device?}. Selection is validated against the registry. VibeVoice activation is CUDA-only and fail-closed; setup=true installs the pinned runtime and exact weights before activation. Hardware evidence uses nvidia-smi on discrete Linux and NVIDIA's documented tegrastats plus a CUDA Torch property probe on Jetson/L4T.",
+          "description": "Body: {engineId, modelId?, setup?, device?}. Selection is validated against the registry. setup=true pulls the exact managed model and verifies CUDA placement before activation. Hardware evidence uses nvidia-smi on discrete Linux and NVIDIA's documented tegrastats plus a CUDA Torch property probe on Jetson/L4T.",
           "responses": {
             "200": {
               "description": "Exact selection activated"

package/docs/DISCOVERY.md

@@ -88,6 +88,8 @@ Daemon equivalents are `GET /v1/discovery/bootstrap`, `GET /v1/discovery?q=<inte
 | `api.v1-aiwg-use` | /v1/aiwg/use | AIWG cascade activation bundle (aiwg use all equivalent, model-tier sized) |
 | `api.v1-asr-activate` | /v1/asr/activate | Activate and persist an exact ASR engine/model |
 | `api.v1-asr-engines` | /v1/asr/engines | List all ASR engines, models, capabilities, resource requirements, readiness, and active selection |
+| `api.v1-asr-engines-engine-id-models-model-id-deploy` | /v1/asr/engines/{engineId}/models/{modelId}/deploy | Pull, select, and activate one exact ASR model |
+| `api.v1-asr-engines-engine-id-models-model-id-pull` | /v1/asr/engines/{engineId}/models/{modelId}/pull | Pull one exact ASR model and validate its managed runtime |
 | `api.v1-asr-engines-engine-id-setup` | /v1/asr/engines/{engineId}/setup | Install a managed ASR runtime and its pinned weights |
 | `api.v1-asr-selection` | /v1/asr/selection | Read the selected ASR engine/model; Persist and activate an exact ASR selection |
 | `api.v1-asr-status` | /v1/asr/status | Read the selected ASR engine/model and runtime status |

package/npm-shrinkwrap.json

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

package/package.json

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