Release v1.5.0 - PARAKEET and CANARY: NVIDIA NeMo Engines

Two new opt-in ASR engines run NVIDIA's NeMo models through onnx-asr: PARAKEET
(Parakeet-TDT-0.6B-v3) and CANARY (Canary-1B-v2). Both cover 25 European languages.
A Whisper companion on ASR_MODEL serves language detection and every other language, so
/detect-language, Bazarr and every other API caller see the same contract as before.
The default engine is unchanged (ASR_ENGINE=AUTO still resolves to FASTER-WHISPER),
and so are the API and the task statuses. Two things change for every engine: the scheduler
now sends idle work to the fastest idle unit kind, and the dashboard's accelerator-load
figure follows where work really runs (see Scheduling and monitoring).

Highlights

PARAKEET and CANARY engines

• ASR_ENGINE=PARAKEET or CANARY. One engine per hardware unit, like every other
  engine; inside it are the NeMo model and a Faster-Whisper companion.
• Routing per decode call ([NeMo] route=nemo|whisper reason=... in the log): a
  language outside the model's 25 goes to Whisper, as does a call with no language. NeMo
  models never fail on an unknown language; they quietly transcribe it as the nearest one
  they know, so they are never given one. Translation goes to Canary natively, and to
  Whisper under Parakeet.
• Decoding by speech region and pause/resume work unchanged. The engines honour
  clip_timestamps, split anything over NEMO_MAX_CHUNK_SEC (20 s) at its quietest point,
  and yield segments a batch at a time, so preemption stops them at the next batch.
• Timestamps: Parakeet's token times become word timestamps and lines (at most 7 s and
  84 characters). Canary reports no times, so its lines are spread across their chunk by
  length and wrapped at 84 characters.
• Devices: CUDA, and Intel GPUs through ONNX Runtime's OpenVINO provider; NPU and AMD
  units run the model on the CPU. Providers are always named explicitly, and the startup
  banner reports the one actually in use.
• Supply chain: NEMO_MODEL can only name a catalog entry, and each entry is pinned to
  one Hugging Face revision. Provisioning downloads it and integrity-checks the result,
  never onnx-asr. The engine checks the pinned files again at load and refuses to start
  without them, so a failed provisioning can never let onnx-asr fetch the repository head.
• Settings: NEMO_MODEL, NEMO_QUANTIZATION (AUTO = fp32 on accelerators, int8 on
  the CPU), NEMO_MAX_CHUNK_SEC, NEMO_BATCH_SIZE, NEMO_GPU_MEM_LIMIT_MB, and
  NEMO_COMPANION_DEVICE (CPU keeps the companion off a card too small for both). A CUDA
  out-of-memory error at load falls back to the CPU. Mid-decode, a batch that runs out of
  memory is retried one chunk at a time, and a chunk that still does not fit is decoded on
  a CPU copy while the engine stays on the card.

Scheduling and monitoring

• With several idle units, a task goes to the fastest kind
  (engine_registry.AUTO_DEVICE_PRIORITY). Units of the same kind keep FIFO rotation. This
  matters once one engine drives two vendors: PARAKEET ran 123x real time on a CUDA card
  and 9x on the iGPU beside it.
• The dashboard counts a NeMo engine's work as accelerator load only where it really runs.
  Language detection on an Intel unit is the CPU-bound companion's work.

Engine evaluation

docs/ASR_ENGINE_EVALUATION.md records the measurements behind keeping FASTER-WHISPER the
default, and the benchmark harness that produced them (tests/real_audio/test_engine_benchmark.py,
scripts/remote_validate.sh --suite bench|codeswitch|longform). On an RTX 5090, Parakeet
decodes about 6.5x faster than Whisper large-v3, at a WER about three points higher on the
matrix clips. Canary sits between them on both. Canary also translates a short foreign line
into the language detection gave its region, rather than transcribing it, which makes it
the weaker choice for code-switched material.

Dependencies

Every dependency without a hardware-backed reason to stay put moves to its current release.

Held deliberately: torch 2.13.0 / torchvision 0.28.0 (torch 2.14 needs CUDA 13, which
CTranslate2 cannot load), and the js-yaml override on 4.x (cosmiconfig's API). Checked
against published metadata: openvino 2026.4.1 still declares numpy<2.6.0, and
transformers 5.19.0 accepts huggingface-hub<3.0. huggingface-hub 2.x is a major version;
the only call this project makes, snapshot_download, keeps every argument it passes.

Verification

• Tests: backend 3069 passed / 0 failed, coverage 97 %, all run in the Docker test
  image. Pylint 10.00/10 on code and tests; Ruff, Radon (rank A), Bandit, ESLint, Markdownlint
  and HTML validation pass, with no inline suppressions.

• npm audit: clean. GHSA-vfj7-8cjw-p6xm (braces, stack exhaustion from deeply nested
  patterns) affects every published version and has no fix, and reaches this project only
  through the lint tooling (markdownlint-cli2, stylelint). braces is overridden to a
  vendored 3.0.3 that refuses nesting past 64 levels (vendor/npm/braces). It rejects the
  4,900-level input that crashes the original, and will be dropped once upstream releases a fix.

• RTX 5090 (nvidia build, every engine on cuda:0):

  engine	accuracy	smoke	code-switched	long-form
  FASTER-WHISPER	9/9	30/30	30/30	44/44
  PARAKEET	9/9	30/30	30/30	44/44
  CANARY	8/9	30/30	30/30	42/44

  Canary writes "whisperpro" for "Whisper Pro". Its long-form misses are a recurring
  Russian line it mishears, plus the region-language translation described above.

• After the dependency sweep (RTX 5090, nvidia image rebuilt from the swept tree,
  models re-provisioned through huggingface-hub 2.2.0): FASTER-WHISPER and PARAKEET each
  9/9 accuracy and 30/30 smoke on CUDA.

• RTX 3080 laptop and Intel NUC (Arc 140T + NPU): PARAKEET and CANARY on CUDA, the Intel
  GPU and the CPU; the shipped INTEL-WHISPER configuration 9/9 (no regression). Details are
  in docs/RELEASE_VALIDATION_PLAN.md.