agent-cli 0.105.0__tar.gz → 0.105.2__tar.gz

{agent_cli-0.105.0 → agent_cli-0.105.2}/.github/workflows/pytest.yml

@@ -43,6 +43,6 @@ jobs:
         run: uv run --extra audio --extra diarization --extra llm --extra rag --extra memory --extra vad --extra faster-whisper --extra piper --extra kokoro --extra server --extra speed --extra test pytest -vvv
       - name: Upload coverage reports to Codecov
         if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
-        uses: codecov/codecov-action@v7.0.0
+        uses: codecov/codecov-action@v7.1.0
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

{agent_cli-0.105.0 → agent_cli-0.105.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-cli
-Version: 0.105.0
+Version: 0.105.2
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>

{agent_cli-0.105.0 → agent_cli-0.105.2}/agent_cli/core/audio_format.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import io
 import logging
 import shutil
@@ -152,13 +153,13 @@ def convert_audio_to_wyoming_format(
             output_path.unlink(missing_ok=True)
 
 
-def convert_audio_to_wav_format(
+async def convert_audio_to_wav_format(
     audio_data: bytes,
     source_filename: str,
     *,
-    timeout: int | None = 60,
+    timeout: int | None = 60,  # noqa: ASYNC109 - bounds and cleans up the child process
 ) -> bytes:
-    """Convert audio data to a 16kHz mono 16-bit PCM WAV container using FFmpeg."""
+    """Convert to 16kHz mono 16-bit WAV, stopping FFmpeg on cancellation or timeout."""
     if not shutil.which("ffmpeg"):
         msg = "FFmpeg not found in PATH. Please install FFmpeg to convert audio formats."
         raise RuntimeError(msg)
@@ -185,20 +186,23 @@ def convert_audio_to_wav_format(
         ]
 
         logger.debug("Running FFmpeg WAV conversion: %s", " ".join(cmd))
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.PIPE,
+        )
         try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=False,
-                check=False,
-                timeout=timeout,
-            )
-        except subprocess.TimeoutExpired as e:
+            _, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
+        except TimeoutError as e:
             msg = f"FFmpeg conversion timed out after {timeout} seconds"
             raise RuntimeError(msg) from e
+        finally:
+            if process.returncode is None:
+                process.kill()
+                await process.communicate()
 
-        if result.returncode != 0:
-            stderr_text = result.stderr.decode("utf-8", errors="replace")
+        if process.returncode != 0:
+            stderr_text = (stderr or b"").decode("utf-8", errors="replace")
             logger.error("FFmpeg WAV conversion failed: %s", stderr_text)
             msg = f"FFmpeg WAV conversion failed: {stderr_text}"
             raise RuntimeError(msg)

agent_cli-0.105.2/agent_cli/server/whisper/backends/audio.py

@@ -0,0 +1,44 @@
+"""Audio preparation for ASR backends that require PCM WAV input."""
+
+from __future__ import annotations
+
+import io
+import wave
+
+from agent_cli import constants
+from agent_cli.core.audio_format import convert_audio_to_wav_format
+from agent_cli.server.whisper.backends.base import InvalidAudioError
+
+
+async def prepare_wav_audio(
+    audio: bytes,
+    source_filename: str | None,
+    *,
+    backend_label: str,
+) -> bytes:
+    """Return 16kHz mono 16-bit PCM WAV bytes, converting only when needed.
+
+    Container validity alone is insufficient: Transformers reads samples as
+    int16 mono. Normalize other sample formats before model-worker dispatch.
+    Backends with their own decoders, such as faster-whisper, do not need this.
+    """
+    try:
+        with wave.open(io.BytesIO(audio), "rb") as wav_file:
+            if (
+                wav_file.getsampwidth() == constants.AUDIO_FORMAT_WIDTH
+                and wav_file.getnchannels() == constants.AUDIO_CHANNELS
+                and wav_file.getframerate() == constants.AUDIO_RATE
+            ):
+                return audio
+    except (wave.Error, EOFError, RuntimeError):
+        # wave can raise RuntimeError when a malformed RIFF chunk seeks past EOF.
+        pass
+
+    try:
+        return await convert_audio_to_wav_format(audio, source_filename or "audio")
+    except RuntimeError as exc:
+        msg = (
+            f"Unsupported audio format for {backend_label}. "
+            "Provide a valid WAV file or install ffmpeg to convert uploads."
+        )
+        raise InvalidAudioError(msg) from exc

{agent_cli-0.105.0 → agent_cli-0.105.2}/agent_cli/server/whisper/backends/base.py

@@ -89,7 +89,7 @@ class WhisperBackend(Protocol):
         """Transcribe audio data.
 
         Args:
-            audio: Audio data as bytes (WAV format, 16kHz, 16-bit, mono)
+            audio: Encoded audio bytes (16kHz mono 16-bit PCM WAV preferred).
             source_filename: Optional filename to help detect audio format.
             language: Language code or None for auto-detection
             task: "transcribe" or "translate" (to English)

{agent_cli-0.105.0 → agent_cli-0.105.2}/agent_cli/server/whisper/backends/nemo.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 import inspect
-import io
 import logging
 import os
 import sys
@@ -18,11 +17,10 @@ from multiprocessing import get_context
 from pathlib import Path
 from typing import Any, Literal
 
-from agent_cli.core.audio_format import convert_audio_to_wav_format
 from agent_cli.core.process import set_process_title
+from agent_cli.server.whisper.backends.audio import prepare_wav_audio
 from agent_cli.server.whisper.backends.base import (
     BackendConfig,
-    InvalidAudioError,
     TranscriptionResult,
 )
 
@@ -182,26 +180,6 @@ def _audio_duration_seconds(wav_path: str) -> float:
         return 0.0
 
 
-def _prepare_audio_for_nemo(audio_bytes: bytes, source_filename: str | None) -> bytes:
-    """Return a WAV container suitable for NeMo file-path transcription."""
-    try:
-        with wave.open(io.BytesIO(audio_bytes), "rb"):
-            return audio_bytes
-    except (wave.Error, EOFError):
-        pass
-
-    filename = source_filename or "audio"
-    try:
-        return convert_audio_to_wav_format(audio_bytes, filename)
-    except RuntimeError as exc:
-        logger.warning("FFmpeg conversion failed for NeMo Whisper: %s", exc)
-        msg = (
-            "Unsupported audio format for NeMo Whisper. "
-            "Provide a WAV file or install ffmpeg to convert uploads."
-        )
-        raise InvalidAudioError(msg) from exc
-
-
 def _build_transcribe_kwargs(
     transcribe_func: Any,
     *,
@@ -433,7 +411,11 @@ class NemoWhisperBackend:
             )
             self._warned_initial_prompt_ignored = True
 
-        audio = await asyncio.to_thread(_prepare_audio_for_nemo, audio, source_filename)
+        audio = await prepare_wav_audio(
+            audio,
+            source_filename,
+            backend_label="NeMo Whisper",
+        )
 
         kwargs: dict[str, Any] = {
             "language": language,

{agent_cli-0.105.0 → agent_cli-0.105.2}/agent_cli/server/whisper/backends/transformers.py

@@ -6,6 +6,7 @@ import asyncio
 import logging
 import tempfile
 import time
+import traceback
 import wave
 from concurrent.futures import ProcessPoolExecutor
 from dataclasses import dataclass
@@ -14,6 +15,7 @@ from pathlib import Path
 from typing import Any, Literal
 
 from agent_cli.core.process import set_process_title
+from agent_cli.server.whisper.backends.audio import prepare_wav_audio
 from agent_cli.server.whisper.backends.base import (
     BackendConfig,
     TranscriptionResult,
@@ -428,8 +430,8 @@ def _transcribe_with_generate(
     )
 
 
-def _transcribe_in_subprocess(kwargs: dict[str, Any]) -> dict[str, Any]:
-    """Run transcription in subprocess. Reuses model from _state."""
+def _transcribe_with_loaded_model(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Dispatch transcription using the model retained in this worker."""
     if _state.model is None or _state.processor is None:
         msg = "Model not loaded in subprocess. Call _load_model_in_subprocess first."
         raise RuntimeError(msg)
@@ -479,6 +481,44 @@ def _transcribe_in_subprocess(kwargs: dict[str, Any]) -> dict[str, Any]:
     )
 
 
+def _clear_exception_frames(exc: BaseException) -> None:
+    """Release helper locals retained by an exception and its chained failures."""
+    pending = [exc]
+    seen: set[int] = set()
+    while pending:
+        current = pending.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+        traceback.clear_frames(current.__traceback__)
+        pending.extend(
+            error for error in (current.__cause__, current.__context__) if error is not None
+        )
+        if isinstance(current, BaseExceptionGroup):
+            pending.extend(current.exceptions)
+
+
+def _transcribe_in_subprocess(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Transcribe and return unused CUDA memory while keeping model weights loaded."""
+    if not _state.device or not _state.device.startswith("cuda"):
+        return _transcribe_with_loaded_model(kwargs)
+
+    import torch  # noqa: PLC0415
+
+    try:
+        return _transcribe_with_loaded_model(kwargs)
+    except BaseException as exc:
+        # Failed helper frames otherwise keep temporary tensors live until the
+        # executor serializes the exception, which happens after our finally.
+        # Clear locals without losing the traceback's function names and lines.
+        _clear_exception_frames(exc)
+        raise
+    finally:
+        # Helper frames have returned, so their temporary tensors are now free.
+        # Only unused allocator blocks are released; model weights stay resident.
+        torch.cuda.empty_cache()
+
+
 class TransformersWhisperBackend:
     """ASR backend using HuggingFace transformers.
 
@@ -554,7 +594,7 @@ class TransformersWhisperBackend:
         self,
         audio: bytes,
         *,
-        source_filename: str | None = None,  # noqa: ARG002
+        source_filename: str | None = None,
         language: str | None = None,
         task: Literal["transcribe", "translate"] = "transcribe",
         initial_prompt: str | None = None,
@@ -567,6 +607,12 @@ class TransformersWhisperBackend:
             msg = "Model not loaded. Call load() first."
             raise RuntimeError(msg)
 
+        audio = await prepare_wav_audio(
+            audio,
+            source_filename,
+            backend_label="transformers ASR",
+        )
+
         # Write audio to temp file for wave parsing in subprocess
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
             tmp.write(audio)

{agent_cli-0.105.0 → agent_cli-0.105.2}/docs/commands/server/whisper.md

@@ -55,6 +55,7 @@ Run a local ASR server with automatic backend selection based on your platform:
 - **OpenAI-compatible API** at `/v1/audio/transcriptions` - drop-in replacement for OpenAI's Whisper API
 - **Wyoming protocol** for [Home Assistant](https://www.home-assistant.io/) voice integration (Wyoming is the standard protocol for local voice services)
 - **TTL-based memory management** - models unload after idle period, freeing RAM/VRAM
+- **CUDA cache cleanup** - the transformers backend releases unused GPU cache after each transcription while keeping model weights loaded
 - **Multiple models** - run different model sizes with independent TTLs
 - **Background preloading** - downloads start at startup without blocking; use `--preload` to wait
 - **Multi-platform support** - automatically uses the optimal backend for your hardware (`auto` switches to `nemo` for Parakeet models)

{agent_cli-0.105.0 → agent_cli-0.105.2}/macos/appcast.xml

@@ -4,6 +4,40 @@
         <title>Agent CLI Updates</title>
         <link>https://github.com/basnijholt/agent-cli</link>
         <description>Signed Agent CLI macOS app updates.</description>
+        <item>
+            <title>0.105.1</title>
+            <pubDate>Tue, 08 Sep 2026 13:10:30 +0000</pubDate>
+            <link>https://github.com/basnijholt/agent-cli</link>
+            <sparkle:version>205</sparkle:version>
+            <sparkle:shortVersionString>0.105.1</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>13.0</sparkle:minimumSystemVersion>
+            <sparkle:hardwareRequirements>arm64</sparkle:hardwareRequirements>
+            <description sparkle:format="markdown"><![CDATA[## Bug fixes
+
+- Release unused CUDA cache after each transcription in the transformers ASR backend, keeping model weights loaded for the next request. Long recordings no longer leave their peak temporary GPU allocation reserved throughout the idle timeout. In a Qwen3-ASR test, idle process VRAM dropped from 10.89 GiB to 4.13 GiB. (#642)
+- Clear temporary tensor references held by failed-request tracebacks, including chained and grouped exceptions, before releasing CUDA cache. CPU and MPS behavior is unchanged. (#642)
+
+**Full changelog:** https://github.com/basnijholt/agent-cli/compare/v0.105.0...v0.105.1
+
+]]></description>
+            <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.105.1/AgentCLI.zip" length="18455354" type="application/octet-stream" sparkle:edSignature="vZqacIut3YOxE/I4mgUeHiI9jviHLgzymE3jK8R7aLEooAPZhNqkzxTFpB95iWShRRWfR8lf9T4ztVFs0EHUDw=="/>
+        </item>
+        <item>
+            <title>0.105.0</title>
+            <pubDate>Tue, 08 Sep 2026 10:29:52 +0000</pubDate>
+            <link>https://github.com/basnijholt/agent-cli</link>
+            <sparkle:version>204</sparkle:version>
+            <sparkle:shortVersionString>0.105.0</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>13.0</sparkle:minimumSystemVersion>
+            <sparkle:hardwareRequirements>arm64</sparkle:hardwareRequirements>
+            <description sparkle:format="markdown"><![CDATA[## What’s Changed
+
+* Prevent Qwen long-audio truncation (#641) @basnijholt
+* Publish diarization Docker image (#640) @basnijholt
+
+]]></description>
+            <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.105.0/AgentCLI.zip" length="18454913" type="application/octet-stream" sparkle:edSignature="Z3253GuNAV6GC2V4Qib0Bm7m8bSdlWHPiXeHIZNa06qAJaY+qRXzrSPRyT8iZW5GnkZOJHciIbqvkkoJ9/DoCw=="/>
+        </item>
         <item>
             <title>0.104.0</title>
             <pubDate>Mon, 07 Sep 2026 21:38:19 +0000</pubDate>
@@ -174,39 +208,5 @@
 ]]></description>
             <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.101.0/AgentCLI.zip" length="22912290" type="application/octet-stream" sparkle:edSignature="9re7kqubAoQgSpsmDvAT/LCWy8/tI1RzR2uGkb+BCwGJbtfvuzDU2ETm/JD+lpQt3Ayik6ULAOv+/5S6JSmdBA=="/>
         </item>
-        <item>
-            <title>0.100.0</title>
-            <pubDate>Wed, 10 Jun 2026 17:59:16 +0000</pubDate>
-            <link>https://github.com/basnijholt/agent-cli</link>
-            <sparkle:version>195</sparkle:version>
-            <sparkle:shortVersionString>0.100.0</sparkle:shortVersionString>
-            <sparkle:minimumSystemVersion>13.0</sparkle:minimumSystemVersion>
-            <sparkle:hardwareRequirements>arm64</sparkle:hardwareRequirements>
-            <description sparkle:format="markdown"><![CDATA[## What’s Changed
-
-* Add cmux support to agent-cli dev (#589) @basnijholt
-* ⬆️ Update sparkle-project/Sparkle to v2.9.3 (#587) @[renovate[bot]](https://github.com/apps/renovate)
-* [pre-commit.ci] pre-commit autoupdate (#588) @[pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci)
-* ⬆️ Update codecov/codecov-action action to v7 (#586) @[renovate[bot]](https://github.com/apps/renovate)
-* ⬆️ Update codecov/codecov-action action to v6.0.2 (#585) @[renovate[bot]](https://github.com/apps/renovate)
-
-]]></description>
-            <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.100.0/AgentCLI.zip" length="22908645" type="application/octet-stream" sparkle:edSignature="2xn/3yQOqyqwCQ5871EAgFra/D/z6UrDl1B+ZxUh7PnOxJpL4Oe44UzQgjFB+LJXzqrY6Kmqvu9GBmk+3aZ1Ag=="/>
-        </item>
-        <item>
-            <title>0.99.0</title>
-            <pubDate>Fri, 05 Jun 2026 22:57:28 +0000</pubDate>
-            <link>https://github.com/basnijholt/agent-cli</link>
-            <sparkle:version>194</sparkle:version>
-            <sparkle:shortVersionString>0.99.0</sparkle:shortVersionString>
-            <sparkle:minimumSystemVersion>13.0</sparkle:minimumSystemVersion>
-            <sparkle:hardwareRequirements>arm64</sparkle:hardwareRequirements>
-            <description sparkle:format="markdown"><![CDATA[## What’s Changed
-
-* Add live transcription preview (#571) @basnijholt
-
-]]></description>
-            <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.99.0/AgentCLI.zip" length="22924494" type="application/octet-stream" sparkle:edSignature="COI8nqDd0cBtOO9jw/QRmsucsxE0SPiSgNF/o+s/nv3FCjSXy0C+gZX/bIFtCYyz/DYkff+IaHaLzhw8Z5aEBQ=="/>
-        </item>
     </channel>
 </rss>

{agent_cli-0.105.0 → agent_cli-0.105.2}/tests/core/test_audio_format.py

@@ -2,9 +2,12 @@
 
 from __future__ import annotations
 
+import asyncio
 import shutil
 import struct
-from unittest.mock import MagicMock, patch
+import sys
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -78,28 +81,73 @@ def test_convert_audio_arguments() -> None:
         assert "s16le" in cmd
 
 
-def test_convert_audio_to_wav_arguments() -> None:
+@pytest.mark.asyncio
+async def test_convert_audio_to_wav_arguments() -> None:
     """Regression test: WAV conversion should produce a PCM WAV container."""
     with (
         patch("shutil.which", return_value="/usr/bin/ffmpeg"),
-        patch("subprocess.run") as mock_run,
+        patch("asyncio.create_subprocess_exec") as mock_run,
         patch("pathlib.Path.read_bytes", return_value=b"wav_data"),
         patch("shutil.rmtree"),
     ):
-        mock_run.return_value = MagicMock(returncode=0, stdout=b"", stderr=b"")
+        mock_run.return_value = MagicMock(
+            returncode=0, communicate=AsyncMock(return_value=(None, b""))
+        )
 
-        converted = audio_format.convert_audio_to_wav_format(b"input_data", "test.mp3")
+        converted = await audio_format.convert_audio_to_wav_format(b"input_data", "test.mp3")
 
         assert converted == b"wav_data"
         args, kwargs = mock_run.call_args
-        assert kwargs.get("text") is False
-        cmd = args[0]
+        assert kwargs["stderr"] == asyncio.subprocess.PIPE
+        cmd = args
         assert cmd[0] == "ffmpeg"
         assert "-acodec" in cmd
         assert "pcm_s16le" in cmd
         assert "-f" not in cmd
 
 
+@pytest.mark.parametrize("cancel", [False, True], ids=["timeout", "cancellation"])
+@pytest.mark.asyncio
+async def test_wav_conversion_stops_process_and_removes_files(
+    monkeypatch: pytest.MonkeyPatch, cancel: bool
+) -> None:
+    """Timed-out or cancelled requests must reap FFmpeg before removing its files."""
+    spawn = asyncio.create_subprocess_exec
+    started = asyncio.Event()
+    processes: list[asyncio.subprocess.Process] = []
+    directories: list[Path] = []
+
+    async def start_process(*args: str, stdout: int, stderr: int) -> asyncio.subprocess.Process:
+        directories.append(Path(args[-1]).parent)
+        process = await spawn(
+            sys.executable, "-c", "import time; time.sleep(60)", stdout=stdout, stderr=stderr
+        )
+        processes.append(process)
+        started.set()
+        return process
+
+    monkeypatch.setattr("shutil.which", lambda _name: "ffmpeg")
+    monkeypatch.setattr(asyncio, "create_subprocess_exec", start_process)
+    task = asyncio.create_task(
+        audio_format.convert_audio_to_wav_format(b"input", "voice.m4a", timeout=1),
+    )
+    try:
+        await asyncio.wait_for(started.wait(), timeout=1)
+        assert directories[0].exists()
+        if cancel:
+            task.cancel()
+        error = asyncio.CancelledError if cancel else RuntimeError
+        with pytest.raises(error):
+            await task
+        assert processes[0].returncode is not None
+        assert not directories[0].exists()
+    finally:
+        for process in processes:
+            if process.returncode is None:
+                process.kill()
+                await process.communicate()
+
+
 def test_convert_audio_integration(sample_wav_data: bytes) -> None:
     """Integration test using actual ffmpeg if available."""
     if not shutil.which("ffmpeg"):

{agent_cli-0.105.0 → agent_cli-0.105.2}/tests/test_faster_whisper_backend.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import io
+import wave
 from concurrent.futures.process import BrokenProcessPool
 from typing import TYPE_CHECKING, cast
 from unittest.mock import AsyncMock, patch
@@ -58,9 +60,65 @@ async def test_faster_whisper_transcribe_recovers_from_broken_process_pool() ->
         patch.object(backend, "load", new=AsyncMock(side_effect=fake_load)) as load_mock,
     ):
         mock_loop.return_value.run_in_executor = mock_run_in_executor
-        result = await backend.transcribe(b"fake audio bytes")
+        result = await backend.transcribe(_create_test_wav())
 
     assert result.text == "hello world"
     unload_mock.assert_awaited_once()
     load_mock.assert_awaited_once()
     assert executors_seen == [initial_executor, recovered_executor]
+
+
+def _create_test_wav() -> bytes:
+    """Create a tiny valid 16kHz mono 16-bit WAV file."""
+    buffer = io.BytesIO()
+    with wave.open(buffer, "wb") as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(2)
+        wav_file.setframerate(16000)
+        wav_file.writeframes(b"\x00\x00" * 160)
+    return buffer.getvalue()
+
+
+async def _transcribe_capturing_audio(audio: bytes, source_filename: str | None) -> bytes:
+    """Run the backend against a stub executor and return the bytes it dispatched."""
+    backend = FasterWhisperBackend(BackendConfig(model_name="tiny"))
+    backend._executor = cast("ProcessPoolExecutor", object())
+    dispatched: dict[str, bytes] = {}
+
+    async def mock_run_in_executor(
+        _executor: object,
+        _func: object,
+        audio_bytes: bytes,
+        _kwargs: dict[str, object],
+    ) -> dict[str, object]:
+        dispatched["audio"] = audio_bytes
+        return {
+            "text": "hello",
+            "language": "en",
+            "language_probability": 1.0,
+            "duration": 0.01,
+            "segments": [],
+        }
+
+    with patch("asyncio.get_running_loop") as mock_loop:
+        mock_loop.return_value.run_in_executor = mock_run_in_executor
+        result = await backend.transcribe(audio, source_filename=source_filename)
+
+    assert result.text == "hello"
+    return dispatched["audio"]
+
+
+@pytest.mark.parametrize(
+    ("audio", "filename"),
+    [(b"OggS\x00\x02", "voice.ogg"), (b"\x00\x00\x00 ftypM4A ", "voice.m4a")],
+)
+@pytest.mark.asyncio
+async def test_transcribe_preserves_native_decoder_input_without_ffmpeg(
+    monkeypatch: pytest.MonkeyPatch, audio: bytes, filename: str
+) -> None:
+    """PyAV owns decoding; pre-conversion would add an unnecessary system dependency.
+
+    https://github.com/SYSTRAN/faster-whisper/blob/master/faster_whisper/audio.py
+    """
+    monkeypatch.setattr("shutil.which", lambda _name: None)
+    assert await _transcribe_capturing_audio(audio, filename) == audio

{agent_cli-0.105.0 → agent_cli-0.105.2}/tests/test_nemo_backend.py

@@ -9,15 +9,18 @@ import wave
 from concurrent.futures import ThreadPoolExecutor
 from concurrent.futures.process import BrokenProcessPool
 from types import ModuleType, SimpleNamespace
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
+from unittest.mock import patch
 
 import pytest
 
 from agent_cli.server.cli import _is_parakeet_model
+from agent_cli.server.whisper.backends import audio as audio_preparation
 from agent_cli.server.whisper.backends import nemo as backend
 from agent_cli.server.whisper.backends.base import BackendConfig, InvalidAudioError
 
 if TYPE_CHECKING:
+    from concurrent.futures import ProcessPoolExecutor
     from pathlib import Path
 
 
@@ -308,51 +311,60 @@ def test_audio_duration_seconds_returns_zero_for_non_wav(tmp_path: Path) -> None
     assert backend._audio_duration_seconds(str(audio_path)) == 0.0
 
 
-def test_prepare_audio_for_nemo_keeps_valid_wav(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Valid WAV uploads should not require FFmpeg conversion."""
-    audio = _create_test_wav()
-    monkeypatch.setattr(
-        backend,
-        "convert_audio_to_wav_format",
-        lambda *_args, **_kwargs: pytest.fail("unexpected conversion"),
-    )
-
-    assert backend._prepare_audio_for_nemo(audio, "sample.wav") == audio
-
-
-def test_prepare_audio_for_nemo_converts_non_wav(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
+@pytest.mark.asyncio
+async def test_transcribe_converts_non_wav_upload(monkeypatch: pytest.MonkeyPatch) -> None:
     """Non-WAV uploads should be converted to a WAV container before NeMo sees them."""
     converted = _create_test_wav()
     calls: dict[str, object] = {}
 
-    def fake_convert(audio: bytes, source_filename: str) -> bytes:
+    async def fake_convert(audio: bytes, source_filename: str) -> bytes:
         calls["audio"] = audio
         calls["source_filename"] = source_filename
         return converted
 
-    monkeypatch.setattr(backend, "convert_audio_to_wav_format", fake_convert)
+    monkeypatch.setattr(audio_preparation, "convert_audio_to_wav_format", fake_convert)
+    nemo_backend = backend.NemoWhisperBackend(BackendConfig(model_name="parakeet-tdt-0.6b-v2"))
+    nemo_backend._executor = cast("ProcessPoolExecutor", object())
+    dispatched: dict[str, bytes] = {}
+
+    async def mock_run_in_executor(
+        _executor: object,
+        _func: object,
+        audio_bytes: bytes,
+        _kwargs: dict[str, object],
+    ) -> dict[str, Any]:
+        dispatched["audio"] = audio_bytes
+        return {
+            "text": "hello",
+            "language": "en",
+            "language_probability": 1.0,
+            "duration": 0.01,
+            "segments": [],
+        }
+
+    with patch("asyncio.get_running_loop") as mock_loop:
+        mock_loop.return_value.run_in_executor = mock_run_in_executor
+        result = await nemo_backend.transcribe(b"ID3", source_filename="sample.mp3")
 
-    assert backend._prepare_audio_for_nemo(b"ID3", "sample.mp3") == converted
+    assert result.text == "hello"
+    assert dispatched["audio"] == converted
     assert calls == {"audio": b"ID3", "source_filename": "sample.mp3"}
 
 
-def test_prepare_audio_for_nemo_raises_invalid_audio_error(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
+@pytest.mark.asyncio
+async def test_transcribe_raises_invalid_audio_error(monkeypatch: pytest.MonkeyPatch) -> None:
     """Conversion failures should become API-visible invalid-audio errors."""
 
-    def fake_convert(audio: bytes, source_filename: str) -> bytes:  # noqa: ARG001
+    async def fake_convert(audio: bytes, source_filename: str) -> bytes:  # noqa: ARG001
         msg = "ffmpeg failed"
         raise RuntimeError(msg)
 
-    monkeypatch.setattr(backend, "convert_audio_to_wav_format", fake_convert)
+    monkeypatch.setattr(audio_preparation, "convert_audio_to_wav_format", fake_convert)
+    nemo_backend = backend.NemoWhisperBackend(BackendConfig(model_name="parakeet-tdt-0.6b-v2"))
+    nemo_backend._executor = cast("ProcessPoolExecutor", object())
 
     with pytest.raises(InvalidAudioError, match="Unsupported audio format for NeMo"):
-        backend._prepare_audio_for_nemo(b"not audio", "sample.mp3")
+        await nemo_backend.transcribe(b"not audio", source_filename="sample.mp3")
 
 
 def test_build_transcribe_kwargs_omits_language_for_plain_asr_models() -> None: