omnius 1.0.627 → 1.0.628

package/dist/scripts/audio-yamnet-tensorrt-worker.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""Persistent CUDA/TensorRT YAMNet worker for Omnius audio classification.
+
+The process deliberately accepts only already-captured WAV paths.  It never
+opens an ALSA device and never downloads a model.  Omnius bootstrap stages and
+checksums the ONNX model and TensorRT plan before this worker is launched.
+
+Protocol: JSON Lines on stdin/stdout.  stdout is protocol-only; diagnostics go
+to stderr so callers cannot confuse logs with inference results.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import os
+import sys
+import time
+import traceback
+import wave
+
+
+def emit(payload: dict) -> None:
+    sys.stdout.write(json.dumps(payload, separators=(",", ":")) + "\n")
+    sys.stdout.flush()
+
+
+def fail(message: str) -> None:
+    emit({"type": "fatal", "error": message})
+    raise RuntimeError(message)
+
+
+def cuda_check(result, label: str):
+    """cuda-python returns either an error enum or (error enum, value)."""
+    if isinstance(result, tuple):
+        status, value = result[0], result[1:]
+    else:
+        status, value = result, ()
+    if int(status) != 0:
+        raise RuntimeError(f"CUDA {label} failed: {status}")
+    if len(value) == 0:
+        return None
+    return value[0] if len(value) == 1 else value
+
+
+class CudaPythonRuntime:
+    """Thin adapter over JetPack's cuda-python bindings."""
+    def __init__(self, cudart):
+        self.cudart = cudart
+
+    def stream_create(self):
+        return cuda_check(self.cudart.cudaStreamCreate(), "stream create")
+
+    def alloc(self, size, label):
+        return cuda_check(self.cudart.cudaMalloc(size), f"{label} allocation")
+
+    def h2d(self, device, host, stream, label):
+        cuda_check(
+            self.cudart.cudaMemcpyAsync(
+                device,
+                host.ctypes.data,
+                host.nbytes,
+                self.cudart.cudaMemcpyKind.cudaMemcpyHostToDevice,
+                stream,
+            ),
+            f"{label} copy",
+        )
+
+    def d2h(self, host, device, stream, label):
+        cuda_check(
+            self.cudart.cudaMemcpyAsync(
+                host.ctypes.data,
+                device,
+                host.nbytes,
+                self.cudart.cudaMemcpyKind.cudaMemcpyDeviceToHost,
+                stream,
+            ),
+            f"{label} copy",
+        )
+
+    def synchronize(self, stream):
+        cuda_check(self.cudart.cudaStreamSynchronize(stream), "stream synchronize")
+
+    def free(self, allocation):
+        self.cudart.cudaFree(allocation)
+
+    def device_metadata(self):
+        device = cuda_check(self.cudart.cudaGetDevice(), "get device")
+        props = cuda_check(self.cudart.cudaGetDeviceProperties(device), "get device properties")
+        name = getattr(props, "name", "CUDA device")
+        if isinstance(name, bytes):
+            name = name.split(b"\0", 1)[0].decode("utf8", "replace")
+        return str(name), f"{getattr(props, 'major', 0)}.{getattr(props, 'minor', 0)}"
+
+
+class PyCudaRuntime:
+    """JetPack also ships python3-pycuda on supported L4T images.
+
+    Keeping this fallback avoids a generic PyPI CUDA runtime wheel: both
+    backends call the CUDA libraries supplied by the installed JetPack image.
+    """
+    def __init__(self, cuda):
+        cuda.init()
+        self.cuda = cuda
+        self.device = cuda.Device(0)
+        self.context = self.device.make_context()
+
+    def stream_create(self):
+        return self.cuda.Stream()
+
+    def alloc(self, size, _label):
+        return self.cuda.mem_alloc(size)
+
+    def h2d(self, device, host, stream, _label):
+        self.cuda.memcpy_htod_async(device, host, stream)
+
+    def d2h(self, host, device, stream, _label):
+        self.cuda.memcpy_dtoh_async(host, device, stream)
+
+    def synchronize(self, stream):
+        stream.synchronize()
+
+    def free(self, allocation):
+        allocation.free()
+
+    def stream_handle(self, stream):
+        return stream.handle
+
+    def device_metadata(self):
+        major, minor = self.device.compute_capability()
+        return self.device.name(), f"{major}.{minor}"
+
+
+def read_wav(path: str, np):
+    started = time.perf_counter()
+    with wave.open(path, "rb") as reader:
+        channels = reader.getnchannels()
+        sample_width = reader.getsampwidth()
+        sample_rate = reader.getframerate()
+        frames = reader.getnframes()
+        compression = reader.getcomptype()
+        raw = reader.readframes(frames)
+    if compression != "NONE":
+        raise RuntimeError("Only uncompressed RIFF/WAV input is supported")
+    if channels != 1:
+        raise RuntimeError(f"Expected mono WAV from the caller, received {channels} channels")
+    if sample_width != 2:
+        raise RuntimeError(f"Expected PCM16 WAV from the caller, received {sample_width * 8}-bit samples")
+    if sample_rate != 16000:
+        raise RuntimeError(f"Expected 16 kHz WAV from the caller, received {sample_rate} Hz")
+    waveform = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
+    return waveform, sample_rate, (time.perf_counter() - started) * 1000
+
+
+class YAMNetTensorRT:
+    def __init__(self, engine_path: str, class_map_path: str):
+        started = time.perf_counter()
+        import numpy as np
+        import tensorrt as trt
+        try:
+            from cuda import cudart
+            cuda = CudaPythonRuntime(cudart)
+        except ImportError:
+            import pycuda.driver as pycuda
+            cuda = PyCudaRuntime(pycuda)
+
+        self.np = np
+        self.trt = trt
+        self.cuda = cuda
+        self.logger = trt.Logger(trt.Logger.ERROR)
+        with open(engine_path, "rb") as handle:
+            serialized = handle.read()
+        self.runtime = trt.Runtime(self.logger)
+        self.engine = self.runtime.deserialize_cuda_engine(serialized)
+        if self.engine is None:
+            raise RuntimeError("TensorRT could not deserialize the YAMNet engine")
+        self.context = self.engine.create_execution_context()
+        if self.context is None:
+            raise RuntimeError("TensorRT could not create a YAMNet execution context")
+        self.stream = cuda.stream_create()
+        self.input_name = None
+        self.output_names = []
+        for index in range(self.engine.num_io_tensors):
+            name = self.engine.get_tensor_name(index)
+            if self.engine.get_tensor_mode(name) == trt.TensorIOMode.INPUT:
+                self.input_name = name
+            else:
+                self.output_names.append(name)
+        if self.input_name is None or not self.output_names:
+            raise RuntimeError("YAMNet TensorRT engine did not expose input and output tensors")
+        with open(class_map_path, newline="", encoding="utf8") as handle:
+            self.classes = [row["display_name"] for row in csv.DictReader(handle)]
+        if len(self.classes) != 521:
+            raise RuntimeError(f"YAMNet class map must contain 521 classes; found {len(self.classes)}")
+        self.device_name, self.compute_capability = self._device_metadata()
+        self.model_load_ms = (time.perf_counter() - started) * 1000
+
+    def _device_metadata(self):
+        # TensorRT uses the CUDA-visible ordinal.  Omnius preflight limits that
+        # namespace to exactly the approved Jetson GPU before process launch.
+        return self.cuda.device_metadata()
+
+    def warm(self):
+        # YAMNet needs >=0.975 seconds.  This is a model-load probe, not a
+        # captured-audio classification, and it verifies the TensorRT path is
+        # actually executable before readiness is reported.
+        self.infer(self.np.zeros(15600, dtype=self.np.float32), 1)
+
+    def infer(self, waveform, top_k: int):
+        started = time.perf_counter()
+        np = self.np
+        if waveform.ndim != 1 or waveform.size < 15600:
+            # YAMNet's framing kernel requires 0.975 s; pad silence only to
+            # satisfy the model shape, without altering any supplied samples.
+            waveform = np.pad(waveform.reshape(-1), (0, max(0, 15600 - waveform.size)))
+        waveform = np.ascontiguousarray(waveform.astype(np.float32, copy=False))
+        if not self.context.set_input_shape(self.input_name, tuple(waveform.shape)):
+            raise RuntimeError(f"TensorRT rejected YAMNet input shape {tuple(waveform.shape)}")
+
+        allocations = []
+        host_outputs = {}
+        try:
+            input_bytes = waveform.nbytes
+            input_device = self.cuda.alloc(input_bytes, "input")
+            allocations.append(input_device)
+            self.context.set_tensor_address(self.input_name, int(input_device))
+            for name in self.output_names:
+                shape = tuple(self.context.get_tensor_shape(name))
+                if any(int(dim) < 0 for dim in shape):
+                    raise RuntimeError(f"TensorRT did not resolve output shape for {name}: {shape}")
+                dtype = self.trt.nptype(self.engine.get_tensor_dtype(name))
+                host = np.empty(shape, dtype=dtype)
+                device = self.cuda.alloc(host.nbytes, name)
+                allocations.append(device)
+                host_outputs[name] = (host, device)
+                self.context.set_tensor_address(name, int(device))
+            self.cuda.h2d(input_device, waveform, self.stream, "input")
+            stream_handle = self.cuda.stream_handle(self.stream) if hasattr(self.cuda, "stream_handle") else self.stream
+            if not self.context.execute_async_v3(stream_handle):
+                raise RuntimeError("TensorRT YAMNet execute_async_v3 returned false")
+            for name, (host, device) in host_outputs.items():
+                self.cuda.d2h(host, device, self.stream, name)
+            self.cuda.synchronize(self.stream)
+            # The converted Google model exposes output_0 with AudioSet scores.
+            scores = next((value[0] for name, value in host_outputs.items() if value[0].shape[-1] == 521), None)
+            if scores is None:
+                raise RuntimeError("TensorRT YAMNet engine did not produce a 521-class score tensor")
+            mean_scores = np.mean(scores, axis=0)
+            indices = np.argsort(mean_scores)[-top_k:][::-1]
+            return [
+                {"label": self.classes[int(index)], "confidence": float(mean_scores[int(index)])}
+                for index in indices
+            ], (time.perf_counter() - started) * 1000
+        finally:
+            for allocation in allocations:
+                try:
+                    self.cuda.free(allocation)
+                except Exception:
+                    pass
+
+
+def file_digest(path: str) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        while True:
+            chunk = handle.read(1024 * 1024)
+            if not chunk:
+                break
+            digest.update(chunk)
+    return "sha256:" + digest.hexdigest()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--engine", required=True)
+    parser.add_argument("--class-map", required=True)
+    parser.add_argument("--model-digest", required=True)
+    args = parser.parse_args()
+    # CUDA_VISIBLE_DEVICES must be a single approved accelerator before any
+    # CUDA/TensorRT import. Jetson's integrated GPU is logical device 0.
+    visible = os.environ.get("CUDA_VISIBLE_DEVICES", "").strip()
+    if visible != "0":
+        fail("Audio TensorRT worker requires exactly CUDA_VISIBLE_DEVICES=0 on Jetson")
+    worker = YAMNetTensorRT(args.engine, args.class_map)
+    worker.warm()
+    emit({
+        "type": "ready",
+        "pid": os.getpid(),
+        "backend": "tensorrt-fp16",
+        "device": worker.device_name,
+        "compute_capability": worker.compute_capability,
+        "cuda_visible_devices": visible,
+        "model": "yamnet",
+        "model_digest": args.model_digest,
+        "taxonomy": "AudioSet-521",
+        "model_load_ms": round(worker.model_load_ms, 3),
+        "warmed": True,
+    })
+    for line in sys.stdin:
+        try:
+            request = json.loads(line)
+            if request.get("type") == "shutdown":
+                emit({"type": "stopped"})
+                return 0
+            if request.get("type") != "classify":
+                raise RuntimeError("unknown request type")
+            request_id = str(request.get("id") or "")
+            file_path = str(request.get("file") or "")
+            if not request_id or not file_path:
+                raise RuntimeError("classify requires id and file")
+            waveform, sample_rate, decode_ms = read_wav(file_path, worker.np)
+            classifications, inference_ms = worker.infer(waveform, max(1, min(int(request.get("top_k", 5)), 25)))
+            emit({
+                "type": "result",
+                "id": request_id,
+                "success": True,
+                "sample_rate_hz": sample_rate,
+                "duration_seconds": round(float(waveform.size) / sample_rate, 6),
+                "classifications": classifications,
+                "timings_ms": {"decode": round(decode_ms, 3), "inference": round(inference_ms, 3)},
+            })
+        except Exception as exc:  # keep the persistent worker alive per request
+            emit({
+                "type": "result",
+                "id": str(locals().get("request", {}).get("id", "")),
+                "success": False,
+                "error": str(exc),
+            })
+            print(traceback.format_exc(), file=sys.stderr, flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/update-worker.js

@@ -52,6 +52,13 @@ var init_model_broker = __esm({
   }
 });
 
+// packages/execution/dist/process-async.js
+var init_process_async = __esm({
+  "packages/execution/dist/process-async.js"() {
+    "use strict";
+  }
+});
+
 // packages/execution/dist/venv-paths.js
 var isWin;
 var init_venv_paths = __esm({
@@ -61,6 +68,16 @@ var init_venv_paths = __esm({
   }
 });
 
+// packages/execution/dist/tools/model-store.js
+import { homedir, platform } from "node:os";
+var platformId;
+var init_model_store = __esm({
+  "packages/execution/dist/tools/model-store.js"() {
+    "use strict";
+    platformId = platform();
+  }
+});
+
 // packages/execution/dist/process-kill.js
 import { execSync } from "node:child_process";
 function killProcessTree(pid, signal = "SIGKILL") {
@@ -104,7 +121,7 @@ var init_process_kill = __esm({
 // packages/execution/dist/process-lifecycle.js
 import { randomUUID, createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readlinkSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 function nowFrom(system) {
   return system?.now?.() ?? Date.now();
@@ -113,7 +130,7 @@ function realSleep(ms) {
   return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
 }
 function registryDir(options) {
-  return options?.storeDir || process.env["OMNIUS_PROCESS_REGISTRY_DIR"] || join(process.env["OMNIUS_HOME"] || join(homedir(), ".omnius"), "processes");
+  return options?.storeDir || process.env["OMNIUS_PROCESS_REGISTRY_DIR"] || join(process.env["OMNIUS_HOME"] || join(homedir2(), ".omnius"), "processes");
 }
 function ensureStoreDir(options) {
   const dir = registryDir(options);
@@ -499,13 +516,6 @@ var init_system_deps = __esm({
   }
 });
 
-// packages/execution/dist/process-async.js
-var init_process_async = __esm({
-  "packages/execution/dist/process-async.js"() {
-    "use strict";
-  }
-});
-
 // packages/execution/dist/tools/cuda-device-filter.js
 var init_cuda_device_filter = __esm({
   "packages/execution/dist/tools/cuda-device-filter.js"() {
@@ -514,16 +524,6 @@ var init_cuda_device_filter = __esm({
   }
 });
 
-// packages/execution/dist/tools/model-store.js
-import { homedir as homedir2, platform } from "node:os";
-var platformId;
-var init_model_store = __esm({
-  "packages/execution/dist/tools/model-store.js"() {
-    "use strict";
-    platformId = platform();
-  }
-});
-
 // packages/execution/dist/tools/camera-capture.js
 var DEFAULT_CAMERA_PROFILE, CAMERA_PROFILES;
 var init_camera_capture = __esm({
@@ -245069,10 +245069,21 @@ import { dirname as dirname8 } from "node:path";
 init_model_broker();
 init_jetson_monitor();
 
+// packages/execution/dist/audio-classifier-runtime.js
+init_process_async();
+
 // packages/execution/dist/python-cuda-runtime.js
 init_jetson_monitor();
 init_venv_paths();
 
+// packages/execution/dist/audio-classifier-runtime.js
+init_jetson_monitor();
+init_model_store();
+var MODEL_REVISION = "ac2ca3bd45d12ec1f19f1144205ea529b4e9dedf";
+var MODEL_URL = `https://huggingface.co/zeropointnine/yamnet-onnx/resolve/${MODEL_REVISION}/yamnet.onnx`;
+var CLASS_MAP_URL = `https://huggingface.co/zeropointnine/yamnet-onnx/resolve/${MODEL_REVISION}/yamnet_class_map.csv`;
+var SETUP_TIMEOUT_MS = 20 * 6e4;
+
 // packages/execution/dist/broker-mediated-backend.js
 init_model_broker();
 

package/docs/DISCOVERY.json

@@ -3832,7 +3832,7 @@
           "tags": [
             "ASR"
           ],
-          "description": "Body: {modelId?, device?}. Installs the managed runtime and pulls the requested model. Whisper, Nemotron, and Voxtral load the requested weights to validate exact CUDA placement; VibeVoice stores its pinned model and tokenizer snapshot under Omnius' ASR runtime directories.",
+          "description": "Body: {modelId?, device?}. Installs the managed runtime and pulls the requested model. Whisper, Nemotron, and Voxtral load the requested weights to validate exact CUDA placement; VibeVoice stores its pinned microsoft/VibeVoice-ASR model and tokenizer snapshot under Omnius' ASR runtime directories.",
           "parameters": [
             {
               "name": "engineId",
@@ -3936,7 +3936,7 @@
           "tags": [
             "ASR"
           ],
-          "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.",
+          "description": "Body: {engineId, modelId?, setup?, device?}. Selection is validated against the registry and fails fail-closed: no unavailable engine, missing weights, or unverified CUDA placement can silently replace the active selection. 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"
@@ -4184,6 +4184,236 @@
         "packages/cli/src/api/openapi.ts"
       ]
     },
+    {
+      "id": "api.v1-audio-classify",
+      "kind": "api",
+      "title": "/v1/audio/classify",
+      "summary": "Classify a supplied WAV with persistent CUDA/TensorRT YAMNet",
+      "aliases": [
+        "/v1/audio/classify"
+      ],
+      "keywords": [
+        "rest",
+        "openapi",
+        "POST",
+        "Audio",
+        "v1",
+        "audio",
+        "classify"
+      ],
+      "maturity": "stable",
+      "layer": "interface",
+      "audiences": [
+        "integrator",
+        "service-agent",
+        "coding-agent"
+      ],
+      "interfaces": [
+        {
+          "type": "rest",
+          "target": "POST /v1/audio/classify"
+        },
+        {
+          "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": [
+        "Audio"
+      ],
+      "operations": {
+        "post": {
+          "summary": "Classify a supplied WAV with persistent CUDA/TensorRT YAMNet",
+          "tags": [
+            "Audio"
+          ],
+          "description": "Alias of POST /v1/tools/audio_analyze/call. Body: {args:{action:'classify',file:'/absolute/path.wav',top_k:5},timeout_ms:90000}. Input must be caller-supplied mono PCM16/16 kHz WAV; no microphone capture, dependency install, or model download occurs on this path. Returns result.data.classifications.",
+          "responses": {
+            "200": {
+              "description": "Structured AudioSet-521 classification"
+            },
+            "409": {
+              "description": "One request runs and one waits; additional work is busy"
+            },
+            "503": {
+              "description": "Classifier not ready"
+            }
+          }
+        }
+      },
+      "source_of_truth": [
+        "GET /openapi.json",
+        "packages/cli/src/api/openapi.ts"
+      ]
+    },
+    {
+      "id": "api.v1-audio-classify-health",
+      "kind": "api",
+      "title": "/v1/audio/classify/health",
+      "summary": "Jetson CUDA/TensorRT YAMNet readiness",
+      "aliases": [
+        "/v1/audio/classify/health"
+      ],
+      "keywords": [
+        "rest",
+        "openapi",
+        "GET",
+        "Audio",
+        "v1",
+        "audio",
+        "classify",
+        "health"
+      ],
+      "maturity": "stable",
+      "layer": "interface",
+      "audiences": [
+        "integrator",
+        "service-agent",
+        "coding-agent"
+      ],
+      "interfaces": [
+        {
+          "type": "rest",
+          "target": "GET /v1/audio/classify/health"
+        },
+        {
+          "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": [
+        "GET"
+      ],
+      "tags": [
+        "Audio"
+      ],
+      "operations": {
+        "get": {
+          "summary": "Jetson CUDA/TensorRT YAMNet readiness",
+          "tags": [
+            "Audio"
+          ],
+          "description": "Reports real pinned-model, TensorRT worker, CUDA placement, warmup, queue, and error state. General /health is not an audio readiness signal.",
+          "responses": {
+            "200": {
+              "description": "Warm audio classifier readiness"
+            },
+            "503": {
+              "description": "Audio classifier is installing, stopped, or unavailable"
+            }
+          }
+        }
+      },
+      "source_of_truth": [
+        "GET /openapi.json",
+        "packages/cli/src/api/openapi.ts"
+      ]
+    },
+    {
+      "id": "api.v1-audio-classify-setup",
+      "kind": "api",
+      "title": "/v1/audio/classify/setup",
+      "summary": "Provision and warm Jetson CUDA/TensorRT YAMNet",
+      "aliases": [
+        "/v1/audio/classify/setup"
+      ],
+      "keywords": [
+        "rest",
+        "openapi",
+        "POST",
+        "Audio",
+        "v1",
+        "audio",
+        "classify",
+        "setup"
+      ],
+      "maturity": "stable",
+      "layer": "interface",
+      "audiences": [
+        "integrator",
+        "service-agent",
+        "coding-agent"
+      ],
+      "interfaces": [
+        {
+          "type": "rest",
+          "target": "POST /v1/audio/classify/setup"
+        },
+        {
+          "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": [
+        "Audio"
+      ],
+      "operations": {
+        "post": {
+          "summary": "Provision and warm Jetson CUDA/TensorRT YAMNet",
+          "tags": [
+            "Audio"
+          ],
+          "description": "Admin-only. Downloads checksummed ONNX/class-map artifacts once, builds a JetPack-specific FP16 TensorRT engine, verifies CUDA placement, and warms the persistent worker. It never installs a generic CUDA/Torch wheel.",
+          "responses": {
+            "200": {
+              "description": "Audio classifier installed and warm"
+            },
+            "403": {
+              "description": "Admin scope required"
+            },
+            "500": {
+              "description": "JetPack/TensorRT/CUDA preflight or setup failed"
+            }
+          }
+        }
+      },
+      "source_of_truth": [
+        "GET /openapi.json",
+        "packages/cli/src/api/openapi.ts"
+      ]
+    },
     {
       "id": "api.v1-audio-embed",
       "kind": "api",