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

{agent_cli-0.105.1 → 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.1 → agent_cli-0.105.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-cli
-Version: 0.105.1
+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.1 → 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.1 → 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.1 → 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.1 → agent_cli-0.105.2}/agent_cli/server/whisper/backends/transformers.py

@@ -15,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,
@@ -593,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,
@@ -606,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.1 → agent_cli-0.105.2}/macos/appcast.xml

@@ -4,6 +4,24 @@
         <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>
@@ -190,24 +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>
     </channel>
 </rss>

{agent_cli-0.105.1 → 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.1 → 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.1 → 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:

{agent_cli-0.105.1 → agent_cli-0.105.2}/tests/test_server_whisper.py

@@ -20,7 +20,7 @@ from agent_cli.server.cli import (
 )
 from agent_cli.server.model_manager import ModelStats
 from agent_cli.server.whisper.backends import TranscriptionResult
-from agent_cli.server.whisper.backends.base import UnsupportedRequestError
+from agent_cli.server.whisper.backends.base import InvalidAudioError, UnsupportedRequestError
 from agent_cli.server.whisper.model_manager import (
     WhisperModelConfig as ModelConfig,
 )
@@ -602,6 +602,62 @@ class TestWhisperAPI:
         assert data["status"] == "healthy"
         assert data["models"] == []
 
+    def test_transcribe_forwards_upload_filename_to_backend(
+        self,
+        client: TestClient,
+        mock_registry: WhisperModelRegistry,
+    ) -> None:
+        """The upload filename is the demuxer hint backends need to convert non-WAV audio."""
+        manager = mock_registry.get_manager()
+        with patch.object(
+            manager,
+            "transcribe",
+            new_callable=AsyncMock,
+            return_value=TranscriptionResult(
+                text="Hello world",
+                language="en",
+                language_probability=0.95,
+                duration=1.5,
+                segments=[],
+            ),
+        ) as mock_transcribe:
+            response = client.post(
+                "/v1/audio/transcriptions",
+                files={"file": ("voice.m4a", b"\x00\x00\x00 ftypM4A ", "audio/mp4")},
+                data={"model": "whisper-1"},
+            )
+
+        assert response.status_code == 200
+        assert response.json() == {"text": "Hello world"}
+        assert mock_transcribe.await_args is not None
+        assert mock_transcribe.await_args.kwargs["source_filename"] == "voice.m4a"
+
+    def test_transcribe_undecodable_audio_returns_400(
+        self,
+        client: TestClient,
+        mock_registry: WhisperModelRegistry,
+    ) -> None:
+        """Undecodable audio is an actionable 400, never a 200 or a raw parser traceback."""
+        manager = mock_registry.get_manager()
+        with patch.object(
+            manager,
+            "transcribe",
+            new_callable=AsyncMock,
+            side_effect=InvalidAudioError(
+                "Unsupported audio format for faster-whisper. "
+                "Provide a WAV file or install ffmpeg to convert uploads.",
+            ),
+        ):
+            response = client.post(
+                "/v1/audio/transcriptions",
+                files={"file": ("voice.ogg", b"OggS\x00\x02", "audio/ogg")},
+                data={"model": "whisper-1"},
+            )
+
+        assert response.status_code == 400
+        assert "Unsupported audio format" in response.json()["detail"]
+        assert "install ffmpeg" in response.json()["detail"]
+
     def test_transcribe_empty_audio_returns_400(self, client: TestClient) -> None:
         """Test that empty audio file returns 400 error."""
         response = client.post(