omnius 1.0.620 → 1.0.621

package/dist/index.js

@@ -682401,6 +682401,7 @@ __export(py_embed_exports, {
   runEmbedImage: () => runEmbedImage,
   runEmbedText: () => runEmbedText,
   runTranscribeFile: () => runTranscribeFile,
+  transcribeManagedAsrFile: () => transcribeManagedAsrFile,
   transcribeManagedNemotronFile: () => transcribeManagedNemotronFile
 });
 import { spawnSync as spawnSync9 } from "node:child_process";
@@ -682940,6 +682941,66 @@ function transcribeManagedNemotronFile(input) {
     warnings: []
   };
 }
+function transcribeManagedWhisperFile(input) {
+  const modelId = input.modelId.trim().toLowerCase();
+  const existing = getManagedAsrReadiness("openai-whisper", modelId);
+  if (!existing.weightsReady) ensureManagedAsrModel({ engineId: "openai-whisper", modelId, device: input.device });
+  const modelDir2 = managedAsrModelDir("openai-whisper");
+  const code8 = [
+    "import json, os, sys",
+    "import torch, whisper",
+    "allow_cpu=os.environ.get('OMNIUS_ASR_ALLOW_CPU','').strip().lower() in ('1','true','yes','on')",
+    "if torch.cuda.is_available() and torch.cuda.device_count() > 0:",
+    " index=int(os.environ.get('OMNIUS_ASR_CUDA_DEVICE','0') or '0')",
+    " if index < 0 or index >= torch.cuda.device_count(): raise RuntimeError(f'CUDA device {index} is outside the visible device range')",
+    " torch.cuda.set_device(index); device=f'cuda:{index}'",
+    "elif allow_cpu: device='cpu'",
+    `else: raise RuntimeError(f'CUDA-only ASR is enabled but torch cannot use CUDA (torch.version.cuda={getattr(torch.version, \\"cuda\\", None)}, device_count={torch.cuda.device_count()})')`,
+    "result=whisper.load_model(sys.argv[2], device=device, download_root=sys.argv[3]).transcribe(sys.argv[1], fp16=device.startswith('cuda'), verbose=False)",
+    "segments=[{'start':float(s.get('start',0)), 'end':float(s.get('end',0)), 'text':str(s.get('text','')).strip()} for s in result.get('segments',[])]",
+    "duration=max((s['end'] for s in segments), default=None)",
+    "print(json.dumps({'ok': True, 'text': str(result.get('text','')).strip(), 'duration': duration, 'segments': segments, 'device': device}))"
+  ].join("\n");
+  const result = spawnSync9(getVenvPython(), ["-c", code8, input.path, modelId, modelDir2], {
+    encoding: "utf8",
+    timeout: 12e5,
+    env: {
+      ...process.env,
+      OMNIUS_ASR_MODEL_DIR: modelDir2,
+      ...input.device ? { OMNIUS_ASR_CUDA_DEVICE: input.device } : {}
+    }
+  });
+  const payload = [...parseWorkerEvents(`${result.stdout || ""}`)].reverse().find((event) => event["ok"] === true);
+  if (result.status !== 0 || !payload) {
+    const detail = `${result.stderr || ""}`.trim() || String(result.error ?? "Whisper file transcription failed");
+    throw new Error(detail);
+  }
+  const segments = Array.isArray(payload["segments"]) ? payload["segments"].flatMap((segment) => {
+    if (!segment || typeof segment !== "object") return [];
+    const value2 = segment;
+    return [{
+      start: Number(value2["start"] ?? 0),
+      end: Number(value2["end"] ?? 0),
+      text: String(value2["text"] ?? "")
+    }];
+  }) : [];
+  return {
+    text: String(payload["text"] ?? ""),
+    duration: Number.isFinite(Number(payload["duration"])) ? Number(payload["duration"]) : null,
+    device: typeof payload["device"] === "string" ? payload["device"] : existing.device,
+    segments,
+    warnings: []
+  };
+}
+function transcribeManagedAsrFile(input) {
+  const engineId = input.engineId.trim().toLowerCase();
+  if (engineId === "openai-whisper") return transcribeManagedWhisperFile(input);
+  if (engineId === "nemotron-streaming") {
+    const result = transcribeManagedNemotronFile(input);
+    return { ...result, segments: [] };
+  }
+  throw new Error(`Direct managed file ASR is unavailable for ${input.engineId}`);
+}
 function runEmbedImage(input) {
   const py = getVenvPython();
   const script = locateScript("embed-image.py");
@@ -816658,26 +816719,60 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
         }
         const listen = getDaemonListenEngine();
         const context2 = urlObj.searchParams.get("context") || void 0;
-        const result = await listen.transcribeFile(tmpPath, void 0, { context: context2 });
+        const selection = resolveAsrSelection({
+          engineId: listen.currentEngine,
+          modelId: listen.currentModel
+        });
+        const result = selection.engineId === "vibevoice-transformers" ? await (async () => {
+          const vibe = await transcribeVibeVoiceFile({
+            filePath: tmpPath,
+            context: context2,
+            setup: true
+          });
+          return {
+            text: vibe.text,
+            duration: vibe.durationMs == null ? null : vibe.durationMs / 1e3,
+            segments: vibe.segments.map((segment) => ({
+              start: segment.startMs / 1e3,
+              end: segment.endMs / 1e3,
+              text: segment.text,
+              speaker: segment.speakerId
+            })),
+            speakers: vibe.speakers,
+            engineId: vibe.engineId,
+            modelId: vibe.modelId,
+            rawText: vibe.rawText,
+            warnings: vibe.warnings
+          };
+        })() : (() => {
+          const managed = transcribeManagedAsrFile({
+            engineId: selection.engineId,
+            modelId: selection.modelId,
+            path: tmpPath
+          });
+          return {
+            text: managed.text,
+            duration: managed.duration,
+            segments: managed.segments,
+            speakers: [],
+            engineId: selection.engineId,
+            modelId: selection.modelId,
+            rawText: void 0,
+            warnings: managed.warnings
+          };
+        })();
         try {
           fs14.unlinkSync(tmpPath);
         } catch {
         }
-        if (!result) {
-          jsonResponse(res, 500, {
-            error: "transcribe_unavailable",
-            message: "ASR runtime unavailable; Omnius attempted managed transcribe-cli and Whisper fallback setup. Run /listen once or inspect ~/.omnius/runtimes/asr and ~/.omnius/venv."
-          });
-          return;
-        }
         jsonResponse(res, 200, {
           text: result.text,
           duration: result.duration,
           segments: result.segments,
           speakers: result.speakers,
           language: null,
-          engineId: result.engineId ?? listen.currentEngine,
-          modelId: result.modelId ?? listen.currentModel,
+          engineId: result.engineId,
+          modelId: result.modelId,
           rawText: result.rawText,
           warnings: result.warnings ?? []
         });

package/npm-shrinkwrap.json

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

package/package.json

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