feat(engine): detect and discard silent recordings

Adds RMS-based silence detection to discard recordings where no speech
was detected, saving API costs and improving user experience.

- Add _is_silent() function using numpy RMS calculation
- Discard silent recordings at /record/stop endpoint
- Skip LLM processing for empty transcriptions in pipeline
- Add tests for silence detection and empty text handling

Release-As: 0.2.0

Author: rchardx

engine/aurotype_engine/pipeline.py

@@ -43,6 +43,14 @@ async def process_voice_input(audio_bytes: bytes, config: Settings) -> dict[str,
             f"STT failed after {_MAX_STT_RETRIES} attempts: {last_error}"
         ) from last_error
 
+    # Nothing was spoken — skip LLM and return empty results
+    if not raw_text.strip():
+        return {
+            "raw_text": "",
+            "polished_text": "",
+            "audio_data": base64.b64encode(audio_bytes).decode("ascii"),
+        }
+
     llm = get_llm_provider(config.llm_provider, config)
     polished_text = await llm.polish(raw_text, language=config.language)
 

engine/aurotype_engine/server.py

@@ -141,6 +141,21 @@ def _audio_duration_ms(wav_bytes: bytes) -> float:
         return wav.getnframes() / wav.getframerate() * 1000
 
 
+def _is_silent(wav_bytes: bytes, threshold: float = 0.005) -> bool:
+    """Return True if the RMS volume of the WAV is below *threshold* (silence)."""
+    import io
+    import wave
+
+    import numpy as np
+
+    with wave.open(io.BytesIO(wav_bytes), "rb") as wav:
+        frames = wav.readframes(wav.getnframes())
+    samples = np.frombuffer(frames, dtype=np.int16).astype(np.float32)
+    if samples.size == 0:
+        return True
+    rms = float(np.sqrt(np.mean(samples * samples)) / 32768.0)
+    return rms < threshold
+
 @app.post("/record/stop")
 async def stop_recording():
     try:
@@ -155,6 +170,11 @@ async def stop_recording():
         print(f"[aurotype] Recording too short ({duration_ms:.0f}ms), discarding")
         return {"too_short": True, "duration_ms": duration_ms}
 
+    # Discard silent recordings — nothing was spoken
+    if _is_silent(audio_bytes):
+        print("[aurotype] Recording is silent, discarding")
+        return {"silent": True}
+
     cfg = get_effective_settings()
     try:
         return await process_voice_input(audio_bytes, cfg)

tests/test_pipeline.py

@@ -136,3 +136,48 @@ def test_base64_audio_encoding_in_result() -> None:
 
     decoded = base64.b64decode(result["audio_data"])
     assert decoded == audio
+
+
+def test_empty_transcription_skips_llm() -> None:
+    """When STT returns empty text (silence), LLM should not be called."""
+    audio = b"silent-audio"
+    config = _build_config()
+
+    mock_stt = MagicMock()
+    mock_stt.transcribe = AsyncMock(return_value="")
+
+    mock_llm = MagicMock()
+    mock_llm.polish = AsyncMock(return_value="should not be called")
+
+    with (
+        patch("aurotype_engine.pipeline.get_stt_provider", return_value=mock_stt),
+        patch("aurotype_engine.pipeline.get_llm_provider", return_value=mock_llm),
+    ):
+        result = asyncio.run(process_voice_input(audio, config))
+
+    assert result["raw_text"] == ""
+    assert result["polished_text"] == ""
+    assert result["audio_data"] == base64.b64encode(audio).decode("ascii")
+    mock_llm.polish.assert_not_awaited()
+
+
+def test_whitespace_transcription_skips_llm() -> None:
+    """When STT returns only whitespace, treat as empty and skip LLM."""
+    audio = b"silent-audio"
+    config = _build_config()
+
+    mock_stt = MagicMock()
+    mock_stt.transcribe = AsyncMock(return_value="   \n  ")
+
+    mock_llm = MagicMock()
+    mock_llm.polish = AsyncMock(return_value="should not be called")
+
+    with (
+        patch("aurotype_engine.pipeline.get_stt_provider", return_value=mock_stt),
+        patch("aurotype_engine.pipeline.get_llm_provider", return_value=mock_llm),
+    ):
+        result = asyncio.run(process_voice_input(audio, config))
+
+    assert result["raw_text"] == ""
+    assert result["polished_text"] == ""
+    mock_llm.polish.assert_not_awaited()

tests/test_server.py

@@ -1,18 +1,33 @@
 # pyright: reportMissingImports=false, reportUnknownVariableType=false, reportUnknownMemberType=false, reportUnknownArgumentType=false, reportAny=false
 
+import io
+import struct
 import sys
+import wave
 from pathlib import Path
 from unittest.mock import AsyncMock, MagicMock, patch
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "engine"))
 
-from aurotype_engine.server import app, _config_overrides
+from aurotype_engine.server import app, _config_overrides, _is_silent
 
 from fastapi.testclient import TestClient
 
 client = TestClient(app)
 
 
+def _make_wav(samples: list[int], sample_rate: int = 16000) -> bytes:
+    """Create a WAV file bytes from a list of 16-bit signed samples."""
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)  # 16-bit
+        wav.setframerate(sample_rate)
+        raw = struct.pack(f"<{len(samples)}h", *samples)
+        wav.writeframes(raw)
+    return buf.getvalue()
+
+
 def test_health_endpoint() -> None:
     """GET /health returns status ok and version."""
     response = client.get("/health")
@@ -88,3 +103,42 @@ def test_process_endpoint() -> None:
     assert data["raw_text"] == "raw"
     assert data["polished_text"] == "polished"
     assert data["audio_data"] == "base64data"
+
+
+# --- _is_silent tests ---
+
+
+def test_is_silent_returns_true_for_silent_audio() -> None:
+    """Audio with very low amplitude is detected as silent."""
+    # All zeros = complete silence
+    silent_wav = _make_wav([0, 0, 0, 0, 0])
+    assert _is_silent(silent_wav) is True
+
+
+def test_is_silent_returns_true_for_very_quiet_audio() -> None:
+    """Audio with RMS below threshold is detected as silent."""
+    # Small values: RMS ~ 0.00003, well below default threshold 0.005
+    quiet_wav = _make_wav([1, -1, 2, -2, 1])
+    assert _is_silent(quiet_wav) is True
+
+
+def test_is_silent_returns_false_for_loud_audio() -> None:
+    """Audio with RMS above threshold is not silent."""
+    # Large values: RMS ~ 0.5, well above threshold
+    loud_wav = _make_wav([16000, -16000, 16000, -16000])
+    assert _is_silent(loud_wav) is False
+
+
+def test_is_silent_returns_true_for_empty_samples() -> None:
+    """WAV with no samples is treated as silent."""
+    empty_wav = _make_wav([])
+    assert _is_silent(empty_wav) is True
+
+
+def test_is_silent_respects_custom_threshold() -> None:
+    """Custom threshold can make quiet audio non-silent."""
+    quiet_wav = _make_wav([100, -100, 100, -100])
+    # Default threshold 0.005: quiet_wav is silent
+    assert _is_silent(quiet_wav) is True
+    # Lower threshold: same audio is not silent
+    assert _is_silent(quiet_wav, threshold=0.001) is False