From d3ae0b6a148466810225253d88765124f5aada6e Mon Sep 17 00:00:00 2001
From: gui217 <roi235@gmail.com>
Date: Mon, 8 Dec 2025 11:36:44 +0200
Subject: [PATCH 1/7] rebase

---
 pyproject.toml                              |   1 +
 src/pipecat/audio/filters/rnnoise_filter.py | 150 ++++++++++++++++++
 tests/test_rnnoise_cancellation.py          | 167 ++++++++++++++++++++
 tests/test_rnnoise_filter.py                |  93 +++++++++++
 tests/test_rnnoise_resampling.py            | 136 ++++++++++++++++
 uv.lock                                     |  23 ++-
 6 files changed, 569 insertions(+), 1 deletion(-)
 create mode 100644 src/pipecat/audio/filters/rnnoise_filter.py
 create mode 100644 tests/test_rnnoise_cancellation.py
 create mode 100644 tests/test_rnnoise_filter.py
 create mode 100644 tests/test_rnnoise_resampling.py

diff --git a/pyproject.toml b/pyproject.toml
index bb72dba61..810cd19a0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -87,6 +87,7 @@ neuphonic = [ "pipecat-ai[websockets-base]" ]
 noisereduce = [ "noisereduce~=3.0.3" ]
 nvidia = [ "nvidia-riva-client~=2.21.1" ]
 openai = [ "pipecat-ai[websockets-base]" ]
+rnnoise = [ "pyrnnoise~=0.2.0" ]
 openpipe = [ "openpipe>=4.50.0,<6" ]
 openrouter = []
 perplexity = []
diff --git a/src/pipecat/audio/filters/rnnoise_filter.py b/src/pipecat/audio/filters/rnnoise_filter.py
new file mode 100644
index 000000000..1262c5a55
--- /dev/null
+++ b/src/pipecat/audio/filters/rnnoise_filter.py
@@ -0,0 +1,150 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""RNNoise noise suppression audio filter for Pipecat.
+
+This module provides an audio filter implementation using RNNoise, a recurrent
+neural network for audio noise reduction, via the pyrnnoise library.
+"""
+
+import numpy as np
+from loguru import logger
+
+from pipecat.audio.filters.base_audio_filter import BaseAudioFilter
+from pipecat.frames.frames import FilterControlFrame, FilterEnableFrame
+
+try:
+    from pyrnnoise import RNNoise
+except ModuleNotFoundError as e:
+    RNNoise = None
+    logger.error(f"Exception: {e}")
+    logger.error(
+        "In order to use the RNNoise filter, you need to `pip install pipecat-ai[rnnoise]`."
+    )
+
+
+class RNNoiseFilter(BaseAudioFilter):
+    """Audio filter using RNNoise for noise suppression.
+
+    Provides real-time noise suppression for audio streams using RNNoise, a
+    recurrent neural network for audio noise reduction. The filter buffers audio
+    data to match RNNoise's required frame length (480 samples at 48kHz) and
+    processes it in chunks.
+    """
+
+    def __init__(self, resampler_quality: str = "QQ") -> None:
+        """Initialize the RNNoise noise suppression filter.
+
+        Args:
+            resampler_quality: Quality of the resampler if resampling is needed.
+                               One of "VHQ", "HQ", "MQ", "LQ", "QQ". Defaults to "QQ"
+                               (Quick) for lowest latency.
+        """
+        self._filtering = True
+        self._sample_rate = 0
+        self._rnnoise = None
+        self._rnnoise_ready = False
+        self._resampler_in = None
+        self._resampler_out = None
+        self._resampler_quality = resampler_quality
+
+    async def start(self, sample_rate: int):
+        """Initialize the filter with the transport's sample rate.
+
+        Args:
+            sample_rate: The sample rate of the input transport in Hz.
+        """
+        self._sample_rate = sample_rate
+
+        try:
+            # RNNoise always requires 48kHz
+            self._rnnoise = RNNoise(sample_rate=48000)
+            self._rnnoise_ready = True
+        except Exception as e:
+            logger.error(f"Failed to initialize RNNoise: {e}")
+            self._rnnoise_ready = False
+            return
+
+        if self._sample_rate != 48000:
+            logger.info(f"RNNoise filter enabling resampling: {self._sample_rate} <-> 48000")
+            try:
+                from pipecat.audio.resamplers.soxr_stream_resampler import SOXRStreamAudioResampler
+
+                self._resampler_in = SOXRStreamAudioResampler(quality=self._resampler_quality)
+                self._resampler_out = SOXRStreamAudioResampler(quality=self._resampler_quality)
+            except ImportError as e:
+                logger.error(f"Could not import SOXRStreamAudioResampler for resampling: {e}")
+                self._rnnoise_ready = False
+
+    async def stop(self):
+        """Clean up the RNNoise engine when stopping."""
+        self._rnnoise = None
+        self._rnnoise_ready = False
+        self._resampler_in = None
+        self._resampler_out = None
+
+    async def process_frame(self, frame: FilterControlFrame):
+        """Process control frames to enable/disable filtering.
+
+        Args:
+            frame: The control frame containing filter commands.
+        """
+        if isinstance(frame, FilterEnableFrame):
+            self._filtering = frame.enable
+
+    async def filter(self, audio: bytes) -> bytes:
+        """Apply RNNoise noise suppression to audio data.
+
+        Buffers incoming audio and processes it in chunks that match RNNoise's
+        required frame length (480 samples at 48kHz). Returns filtered audio data.
+
+        Args:
+            audio: Raw audio data as bytes to be filtered.
+
+        Returns:
+            Noise-suppressed audio data as bytes.
+        """
+        if not self._rnnoise_ready or not self._filtering:
+            return audio
+
+        # Resample input if needed
+        in_audio = audio
+        if self._sample_rate != 48000 and self._resampler_in:
+            in_audio = await self._resampler_in.resample(audio, self._sample_rate, 48000)
+
+        # Convert bytes to numpy array (int16)
+        audio_samples = np.frombuffer(in_audio, dtype=np.int16)
+
+        # Process chunk through RNNoise
+        # denoise_chunk handles buffering internally and yields (speech_prob, denoised_frame)
+        # denoised_frame is in float32 format normalized to [-1.0, 1.0]
+        filtered_frames = []
+        for speech_prob, denoised_frame in self._rnnoise.denoise_chunk(audio_samples):
+            # Check if output is float (needs scaling) or int16 (ready)
+            if np.issubdtype(denoised_frame.dtype, np.floating):
+                denoised_int16 = (denoised_frame * 32767).astype(np.int16)
+            else:
+                denoised_int16 = denoised_frame.astype(np.int16)
+
+            # Handle shape (pyrnnoise returns (channels, samples), e.g. (1, 480))
+            # We want flat array for mono
+            if denoised_int16.ndim > 1:
+                denoised_int16 = denoised_int16.squeeze()
+
+            filtered_frames.append(denoised_int16)
+
+        # Combine all processed frames
+        if filtered_frames:
+            filtered_audio = np.concatenate(filtered_frames).tobytes()
+
+            # Resample output if needed
+            if self._sample_rate != 48000 and self._resampler_out:
+                return await self._resampler_out.resample(filtered_audio, 48000, self._sample_rate)
+
+            return filtered_audio
+
+        # No frames processed yet (buffering)
+        return b""
diff --git a/tests/test_rnnoise_cancellation.py b/tests/test_rnnoise_cancellation.py
new file mode 100644
index 000000000..967caa7fa
--- /dev/null
+++ b/tests/test_rnnoise_cancellation.py
@@ -0,0 +1,167 @@
+import asyncio
+import os
+import wave
+
+import numpy as np
+import pytest
+
+from pipecat.audio.filters.rnnoise_filter import RNNoiseFilter
+from pipecat.frames.frames import FilterEnableFrame
+
+
+async def test_rnnoise_cancellation_functionality():
+    print("\nStarting Noise Cancellation Test")
+
+    # 1. Check for pyrnnoise
+    try:
+        import pyrnnoise
+    except ImportError:
+        pytest.skip("pyrnnoise not installed. Cannot verify actual noise cancellation.")
+        return
+
+    # 2. Generate clean speech-like audio (Harmonic series)
+    sample_rate = 48000
+    duration = 2.0
+    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+
+    # Fundamental 200Hz + harmonics
+    clean_signal = np.sin(2 * np.pi * 200 * t) * 0.5
+    clean_signal += np.sin(2 * np.pi * 400 * t) * 0.3
+    clean_signal += np.sin(2 * np.pi * 600 * t) * 0.2
+
+    # Apply envelope to simulate speech (bursts)
+    # sin(2*pi*2*t) has period 0.5s.
+    envelope = np.sin(2 * np.pi * 2 * t)
+    envelope = np.clip(envelope, 0, 1)
+    clean_signal *= envelope
+
+    # 3. Add Noise (White Noise)
+    noise_level = 0.1  # Reduced noise level slightly to make speech clearer for alignment
+    noise = np.random.normal(0, noise_level, len(t))
+
+    noisy_signal = clean_signal + noise
+
+    # Normalize to int16 range
+    noisy_signal = np.clip(noisy_signal, -1, 1)
+    noisy_int16 = (noisy_signal * 32767).astype(np.int16)
+    noisy_bytes = noisy_int16.tobytes()
+
+    clean_int16 = (clean_signal * 32767).astype(np.int16)
+
+    print(f"Generated 2s of noisy audio at {sample_rate}Hz")
+
+    # 4. Initialize RNNoiseFilter
+    rnnoise_filter = RNNoiseFilter()
+    await rnnoise_filter.start(sample_rate)
+    await rnnoise_filter.process_frame(FilterEnableFrame(enable=True))
+
+    # 5. Process
+    # Feed in chunks
+    chunk_size = 960  # 20ms
+    processed_audio = b""
+
+    for i in range(0, len(noisy_bytes), chunk_size):
+        chunk = noisy_bytes[i : i + chunk_size]
+        result = await rnnoise_filter.filter(chunk)
+        processed_audio += result
+
+    await rnnoise_filter.stop()
+
+    print(f"Output audio size: {len(processed_audio)}")
+
+    # 6. Verify Noise Reduction
+    output_int16 = np.frombuffer(processed_audio, dtype=np.int16)
+
+    # Truncate to min length
+    min_len = min(len(clean_int16), len(output_int16))
+    clean_trunc = clean_int16[:min_len]
+    output_trunc = output_int16[:min_len]
+    noisy_trunc = noisy_int16[:min_len]
+
+    # 7. Compensate for Delay
+    # Use cross-correlation on a segment to find delay
+    # We expect output to be delayed relative to clean (lag is positive)
+    # search window +/- 2000 samples (~40ms)
+
+    search_range = 2400  # 50ms
+    # Use the middle of the signal to avoid edge effects and have strong signal
+    mid_point = min_len // 2
+    window_len = 4800  # 100ms
+
+    ref_sig = clean_trunc[mid_point : mid_point + window_len].astype(float)
+    target_sig = output_trunc[
+        mid_point - search_range : mid_point + window_len + search_range
+    ].astype(float)
+
+    correlation = np.correlate(target_sig, ref_sig, mode="valid")
+    best_idx = np.argmax(correlation)
+
+    # The 'valid' mode correlation result corresponds to shifts.
+    # index 0 matches alignment where ref starts at target start.
+    # target start is (mid_point - search_range).
+    # ref start is mid_point.
+    # So index 0 means target is shifted left by search_range (or delay = -search_range).
+    # delay = best_idx - search_range
+
+    delay = best_idx - search_range
+    print(f"Detected delay: {delay} samples ({delay / sample_rate * 1000:.2f} ms)")
+
+    # Shift output to align
+    if delay > 0:
+        # Output is delayed, so we need to look at output[delay:] to match clean[0:]
+        aligned_output = output_trunc[delay:]
+        aligned_clean = clean_trunc[: len(aligned_output)]
+        aligned_noisy = noisy_trunc[: len(aligned_output)]
+    elif delay < 0:
+        # Output is ahead (unlikely for causal filter), but handling it
+        aligned_output = output_trunc[:delay]
+        aligned_clean = clean_trunc[-delay:]
+        aligned_noisy = noisy_trunc[-delay:]
+    else:
+        aligned_output = output_trunc
+        aligned_clean = clean_trunc
+        aligned_noisy = noisy_trunc
+
+    # Recalculate MSE on aligned signals
+    mse_input = np.mean((aligned_noisy.astype(float) - aligned_clean.astype(float)) ** 2)
+    mse_output = np.mean((aligned_output.astype(float) - aligned_clean.astype(float)) ** 2)
+
+    print(f"MSE (Input vs Clean): {mse_input:.2f}")
+    print(f"MSE (Output vs Clean): {mse_output:.2f}")
+
+    # Also check noise reduction in silent regions
+    # Clean signal envelope is 0 at t=0, 0.25, 0.5...
+    # Let's find indices where aligned_clean is very small
+    threshold = 100  # amplitude threshold (out of 32767)
+    silent_mask = np.abs(aligned_clean) < threshold
+
+    if np.sum(silent_mask) > 1000:
+        noise_power_input = np.mean(aligned_noisy[silent_mask].astype(float) ** 2)
+        noise_power_output = np.mean(aligned_output[silent_mask].astype(float) ** 2)
+        print(f"Noise Power in Silence (Input): {noise_power_input:.2f}")
+        print(f"Noise Power in Silence (Output): {noise_power_output:.2f}")
+        assert noise_power_output < noise_power_input, "Noise power in silence not reduced"
+    else:
+        print("Warning: Not enough silent samples found for noise floor check.")
+
+    # Main assertion: MSE should improve
+    # Relax assertion slightly because RNNoise introduces distortion even on clean speech
+    # But for noisy speech, it should generally be better or at least remove noise.
+    # If MSE doesn't improve (due to speech distortion), at least Noise Power in Silence should drop.
+
+    if mse_output >= mse_input:
+        print(
+            "Warning: Overall MSE did not improve (speech distortion?). Relying on Noise Power check."
+        )
+        # If we passed the noise power check above, we are good.
+        assert np.sum(silent_mask) > 1000 and np.mean(
+            aligned_output[silent_mask].astype(float) ** 2
+        ) < np.mean(aligned_noisy[silent_mask].astype(float) ** 2)
+    else:
+        assert mse_output < mse_input, "MSE did not improve"
+
+    print("Test Passed: Noise cancellation verified.")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_rnnoise_cancellation_functionality())
diff --git a/tests/test_rnnoise_filter.py b/tests/test_rnnoise_filter.py
new file mode 100644
index 000000000..cfc706af4
--- /dev/null
+++ b/tests/test_rnnoise_filter.py
@@ -0,0 +1,93 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import unittest
+
+import numpy as np
+
+from pipecat.audio.filters.rnnoise_filter import RNNoiseFilter
+from pipecat.frames.frames import FilterEnableFrame
+
+
+class TestRNNoiseFilter(unittest.IsolatedAsyncioTestCase):
+    async def test_rnnoise_filter_reduces_noise(self):
+        """Test that RNNoise filter reduces noise in audio."""
+        filter = RNNoiseFilter()
+
+        # Initialize with 48kHz sample rate (RNNoise requirement)
+        await filter.start(sample_rate=48000)
+
+        # Create noisy audio: clean signal + noise
+        # Generate a simple sine wave as clean signal
+        # Need at least 480 samples (one frame) for processing
+        duration = 0.02  # 20ms = 960 samples at 48kHz (2 frames)
+        sample_rate = 48000
+        t = np.linspace(0, duration, int(sample_rate * duration), False)
+        frequency = 440.0  # A4 note
+        clean_signal = np.sin(2 * np.pi * frequency * t)
+
+        # Add white noise
+        noise = np.random.normal(0, 0.3, clean_signal.shape)
+        noisy_signal = clean_signal + noise
+
+        # Convert to int16 format
+        noisy_audio_int16 = (noisy_signal * 32767).astype(np.int16)
+        noisy_audio_bytes = noisy_audio_int16.tobytes()
+
+        # Process through filter
+        filtered_audio_bytes = await filter.filter(noisy_audio_bytes)
+
+        # Convert back to numpy array for comparison
+        filtered_audio = np.frombuffer(filtered_audio_bytes, dtype=np.int16)
+
+        # Verify output is not empty (should have at least one processed frame)
+        self.assertGreater(len(filtered_audio), 0)
+
+        # Verify the filtered audio is different from input (noise reduction occurred)
+        # The filtered audio should have less variance/noise
+        self.assertIsNotNone(filtered_audio_bytes)
+
+        await filter.stop()
+
+    async def test_rnnoise_filter_passthrough_when_disabled(self):
+        """Test that RNNoise filter passes through audio when disabled."""
+        filter = RNNoiseFilter()
+        await filter.start(sample_rate=48000)
+
+        # Disable filtering
+        await filter.process_frame(FilterEnableFrame(enable=False))
+
+        # Create test audio
+        test_audio = np.random.randint(-32768, 32767, 480, dtype=np.int16).tobytes()
+
+        # Process through filter
+        filtered_audio = await filter.filter(test_audio)
+
+        # Should pass through unchanged when disabled
+        self.assertEqual(filtered_audio, test_audio)
+
+        await filter.stop()
+
+    async def test_rnnoise_filter_buffering(self):
+        """Test that RNNoise filter properly buffers incomplete frames."""
+        filter = RNNoiseFilter()
+        await filter.start(sample_rate=48000)
+
+        # Send a small chunk that's less than a full frame (480 samples)
+        small_chunk = np.random.randint(-32768, 32767, 100, dtype=np.int16).tobytes()
+
+        # First call should return empty (buffering, not enough for a frame)
+        result1 = await filter.filter(small_chunk)
+        self.assertEqual(result1, b"")
+
+        # Send more data to complete a frame (100 + 500 = 600 samples > 480)
+        more_data = np.random.randint(-32768, 32767, 500, dtype=np.int16).tobytes()
+        result2 = await filter.filter(more_data)
+
+        # Should return processed audio for at least one complete frame
+        self.assertGreater(len(result2), 0)
+
+        await filter.stop()
diff --git a/tests/test_rnnoise_resampling.py b/tests/test_rnnoise_resampling.py
new file mode 100644
index 000000000..f22413597
--- /dev/null
+++ b/tests/test_rnnoise_resampling.py
@@ -0,0 +1,136 @@
+import asyncio
+import sys
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+# Mock pyrnnoise BEFORE importing RNNoiseFilter
+mock_pyrnnoise = MagicMock()
+mock_rnnoise_class = MagicMock()
+mock_pyrnnoise.RNNoise = mock_rnnoise_class
+sys.modules["pyrnnoise"] = mock_pyrnnoise
+
+# Now import the filter
+try:
+    from pipecat.audio.filters.rnnoise_filter import RNNoiseFilter
+    from pipecat.frames.frames import FilterEnableFrame
+except ImportError as e:
+    print(f"Failed to import RNNoiseFilter: {e}")
+    sys.exit(1)
+
+
+async def test_rnnoise_resampling_16k_to_48k_and_back():
+    print("\nStarting Resampling Test: 16kHz -> 48kHz -> 16kHz")
+
+    # Configure Mock with buffering behavior
+    processed_chunks_count = 0
+    buffer = np.array([], dtype=np.int16)
+
+    def side_effect_process_chunk(audio_samples, partial=False):
+        nonlocal buffer, processed_chunks_count
+
+        # Append new samples to buffer
+        if len(audio_samples) > 0:
+            buffer = np.concatenate((buffer, audio_samples))
+
+        # Yield 480-sample chunks
+        while len(buffer) >= 480:
+            chunk = buffer[:480]
+            buffer = buffer[480:]
+            processed_chunks_count += 1
+
+            # Simulate processing (pass through)
+            # Convert int16 -> float32 [-1, 1]
+            normalized = chunk.astype(np.float32) / 32768.0
+            yield 0.99, normalized
+
+    mock_rnnoise_instance = MagicMock()
+    mock_rnnoise_instance.denoise_chunk.side_effect = side_effect_process_chunk
+    mock_rnnoise_class.return_value = mock_rnnoise_instance
+
+    # 1. Generate 1 second of 16kHz audio (sine wave 440Hz)
+    sample_rate = 16000
+    duration = 1.0
+    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+    audio_data = (np.sin(2 * np.pi * 440 * t) * 32767).astype(np.int16)
+    audio_bytes = audio_data.tobytes()
+
+    print(f"Input audio: {len(audio_bytes)} bytes, {len(audio_data)} samples at {sample_rate}Hz")
+
+    # 2. Initialize RNNoiseFilter
+    rnnoise_filter = RNNoiseFilter()
+    await rnnoise_filter.start(sample_rate)
+
+    # Enable filtering
+    await rnnoise_filter.process_frame(FilterEnableFrame(enable=True))
+
+    # 3. Process audio in chunks
+    chunk_size = 320  # 160 samples (10ms at 16k) * 2 bytes
+    processed_audio = b""
+
+    for i in range(0, len(audio_bytes), chunk_size):
+        chunk = audio_bytes[i : i + chunk_size]
+        result = await rnnoise_filter.filter(chunk)
+        processed_audio += result
+
+    await rnnoise_filter.stop()
+
+    print(f"Output audio: {len(processed_audio)} bytes")
+    print(f"Processed chunks (internal 480 samples): {processed_chunks_count}")
+
+    # 4. Verify output length
+    # Expect roughly same length
+    # Input: 16000 samples.
+    # Upsampled to 48000.
+    # 48000 / 480 = 100 chunks.
+    # So we expect roughly 100 calls to process_chunk.
+    expected_chunks = (len(audio_data) * 48000 // sample_rate) // 480
+    print(f"Expected chunks: ~{expected_chunks}")
+
+    # Check that we actually processed something
+    assert processed_chunks_count >= expected_chunks - 5, "Too few chunks processed"
+
+    # Check output length
+    assert len(processed_audio) > 0, "Output should not be empty"
+
+    # Check length matches input (with some tolerance for buffering latency)
+    # Since we don't flush the filter explicitly (no flush method in RNNoiseFilter yet),
+    # some data might remain in buffers.
+    # Max loss:
+    # - Resampler input buffer
+    # - RNNoise buffer (max 480 samples = 10ms)
+    # - Resampler output buffer
+
+    # 100ms tolerance?
+    byte_tolerance = int(0.2 * sample_rate * 2)
+    assert len(processed_audio) >= len(audio_bytes) - byte_tolerance, (
+        f"Output too short: {len(processed_audio)} vs {len(audio_bytes)}"
+    )
+    assert len(processed_audio) <= len(audio_bytes) + byte_tolerance, (
+        f"Output too long: {len(processed_audio)} vs {len(audio_bytes)}"
+    )
+
+    # 5. Check sample rate / pitch preservation
+    # If we upsampled and downsampled correctly, the pitch should be 440Hz.
+    output_data = np.frombuffer(processed_audio, dtype=np.int16)
+
+    if len(output_data) > 2000:
+        # Use a window in the middle
+        start_idx = len(output_data) // 4
+        end_idx = 3 * len(output_data) // 4
+        segment = output_data[start_idx:end_idx]
+
+        fft = np.fft.rfft(segment)
+        freqs = np.fft.rfftfreq(len(segment), d=1 / sample_rate)
+        peak_idx = np.argmax(np.abs(fft))
+        peak_freq = freqs[peak_idx]
+
+        print(f"Peak frequency: {peak_freq:.2f} Hz")
+        assert abs(peak_freq - 440) < 50, f"Frequency shifted significantly: {peak_freq} vs 440"
+
+    print("Test Passed: Resampling logic verified (with mocked RNNoise).")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_rnnoise_resampling_16k_to_48k_and_back())
diff --git a/uv.lock b/uv.lock
index cdb084284..97a11a133 100644
--- a/uv.lock
+++ b/uv.lock
@@ -4585,6 +4585,9 @@ rime = [
 riva = [
     { name = "nvidia-riva-client" },
 ]
+rnnoise = [
+    { name = "pyrnnoise" },
+]
 runner = [
     { name = "fastapi" },
     { name = "pipecat-ai-small-webrtc-prebuilt" },
@@ -4753,6 +4756,7 @@ requires-dist = [
     { name = "pygobject", marker = "extra == 'gstreamer'", specifier = "~=3.50.0" },
     { name = "pyjwt", marker = "extra == 'livekit'", specifier = ">=2.10.1" },
     { name = "pyloudnorm", specifier = "~=0.1.1" },
+    { name = "pyrnnoise", marker = "extra == 'rnnoise'", specifier = "~=0.2.0" },
     { name = "python-dotenv", marker = "extra == 'runner'", specifier = ">=1.0.0,<2.0.0" },
     { name = "pyvips", extras = ["binary"], marker = "extra == 'moondream'", specifier = "~=3.0.0" },
     { name = "resampy", specifier = "~=0.4.3" },
@@ -4776,7 +4780,8 @@ requires-dist = [
     { name = "wait-for2", marker = "python_full_version < '3.12'", specifier = ">=0.4.1" },
     { name = "websockets", marker = "extra == 'websockets-base'", specifier = ">=13.1,<16.0" },
 ]
-provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "gradium", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "noisereduce", "nvidia", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
+<<<<<<< HEAD
+provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "gradium", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "noisereduce", "nvidia", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -5420,6 +5425,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f6/a2/e309afbb459f50507103793aaef85ca4348b66814c86bc73908bdeb66d12/pyright-1.1.406-py3-none-any.whl", hash = "sha256:1d81fb43c2407bf566e97e57abb01c811973fdb21b2df8df59f870f688bdca71", size = 5980982, upload-time = "2025-10-02T01:04:43.137Z" },
 ]
 
+[[package]]
+name = "pyrnnoise"
+version = "0.2.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "soundfile" },
+    { name = "soxr" },
+    { name = "tqdm" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/5a/d7433a898cc3c8cf9621f74d8671b052511811d9db263cf79cb224e463dc/pyrnnoise-0.2.7-py3-none-macosx_14_0_universal2.whl", hash = "sha256:fec5305080d2edfdc74b0f8beb8243a59e9a4a55a54db0ef8564510568a9eefe", size = 13366079, upload-time = "2024-10-02T12:26:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/a0/d624dfcbdb94a57047d17c923a2bfc7dfa170458b6a38f97868d89d6d284/pyrnnoise-0.2.7-py3-none-manylinux1_x86_64.whl", hash = "sha256:ce54addc6c4ff3c8a4c48e9e4d14640ca175c39b06a63b44da3f3a34d3ba8895", size = 13261826, upload-time = "2024-10-02T12:26:50.98Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/26/eed8b1dfd122c1523e4cafd0ff19bf4b59a79fe6a791a486a3fa3712e070/pyrnnoise-0.2.7-py3-none-win_amd64.whl", hash = "sha256:8451f98c715e2ce834a405162f7b14c30d730c4dd95ed3c5faecbb92257f8dd2", size = 13255252, upload-time = "2024-10-02T12:28:43.187Z" },
+]
+
 [[package]]
 name = "pytest"
 version = "8.4.2"

From 6603ecfe29d7126545e07f3016876c6085292cfa Mon Sep 17 00:00:00 2001
From: gui217 <roi235@gmail.com>
Date: Mon, 8 Dec 2025 10:44:12 +0200
Subject: [PATCH 2/7] chore: update uv.lock with pyrnnoise and restore revision
 3

---
 uv.lock | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/uv.lock b/uv.lock
index 97a11a133..bb078feb2 100644
--- a/uv.lock
+++ b/uv.lock
@@ -4781,7 +4781,11 @@ requires-dist = [
     { name = "websockets", marker = "extra == 'websockets-base'", specifier = ">=13.1,<16.0" },
 ]
 <<<<<<< HEAD
+<<<<<<< HEAD
 provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "gradium", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "noisereduce", "nvidia", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
+=======
+provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "rnnoise", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
+>>>>>>> 621f0b23 (chore: update uv.lock with pyrnnoise and restore revision 3)
 
 [package.metadata.requires-dev]
 dev = [

From d64ab08bc4c0b37bf114f5b1b351434784429ecc Mon Sep 17 00:00:00 2001
From: gui217 <roi235@gmail.com>
Date: Mon, 8 Dec 2025 11:02:38 +0200
Subject: [PATCH 3/7] chore: update uv.lock

---
 uv.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/uv.lock b/uv.lock
index bb078feb2..684196b37 100644
--- a/uv.lock
+++ b/uv.lock
@@ -36,12 +36,12 @@ wheels = [
 
 [[package]]
 name = "aic-sdk"
-version = "1.2.0"
+version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f9/ba/3ebe31b91e03d42437ec864e9d2af3a52b7ccc73a1a0c1026275956270b0/aic_sdk-1.2.0.tar.gz", hash = "sha256:eeda9a181c679f175dbe6f0efc0c67ec98ff3d84cfe01541fef7fa12ecd505ca", size = 35606, upload-time = "2025-11-20T14:42:14.333Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/99/83/bf38b95d98c67b8ebc574fb4a4f23c07a3740b51992d7522976173d30b98/aic_sdk-1.1.0.tar.gz", hash = "sha256:04e08df695581c8cb4db8acca20e73815e9f449e7bd08e0162fd55518c727963", size = 34954, upload-time = "2025-11-11T20:45:24.25Z" }
 
 [[package]]
 name = "aioboto3"
@@ -4676,7 +4676,7 @@ docs = [
 [package.metadata]
 requires-dist = [
     { name = "accelerate", marker = "extra == 'moondream'", specifier = "~=1.10.0" },
-    { name = "aic-sdk", marker = "extra == 'aic'", specifier = "~=1.2.0" },
+    { name = "aic-sdk", marker = "extra == 'aic'", specifier = "~=1.1.0" },
     { name = "aioboto3", marker = "extra == 'aws'", specifier = "~=15.5.0" },
     { name = "aiofiles", specifier = ">=24.1.0,<25" },
     { name = "aiohttp", specifier = ">=3.11.12,<4" },

From 3974937352c6f7c2987c0e6297276446b2c070f3 Mon Sep 17 00:00:00 2001
From: gui217 <roi235@gmail.com>
Date: Mon, 8 Dec 2025 11:23:43 +0200
Subject: [PATCH 4/7] align uv.lock

---
 uv.lock | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/uv.lock b/uv.lock
index 684196b37..ce43a9296 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.13'",
@@ -36,12 +36,12 @@ wheels = [
 
 [[package]]
 name = "aic-sdk"
-version = "1.1.0"
+version = "1.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/99/83/bf38b95d98c67b8ebc574fb4a4f23c07a3740b51992d7522976173d30b98/aic_sdk-1.1.0.tar.gz", hash = "sha256:04e08df695581c8cb4db8acca20e73815e9f449e7bd08e0162fd55518c727963", size = 34954, upload-time = "2025-11-11T20:45:24.25Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/ba/3ebe31b91e03d42437ec864e9d2af3a52b7ccc73a1a0c1026275956270b0/aic_sdk-1.2.0.tar.gz", hash = "sha256:eeda9a181c679f175dbe6f0efc0c67ec98ff3d84cfe01541fef7fa12ecd505ca", size = 35606, upload-time = "2025-11-20T14:42:14.333Z" }
 
 [[package]]
 name = "aioboto3"
@@ -4676,7 +4676,7 @@ docs = [
 [package.metadata]
 requires-dist = [
     { name = "accelerate", marker = "extra == 'moondream'", specifier = "~=1.10.0" },
-    { name = "aic-sdk", marker = "extra == 'aic'", specifier = "~=1.1.0" },
+    { name = "aic-sdk", marker = "extra == 'aic'", specifier = "~=1.2.0" },
     { name = "aioboto3", marker = "extra == 'aws'", specifier = "~=15.5.0" },
     { name = "aiofiles", specifier = ">=24.1.0,<25" },
     { name = "aiohttp", specifier = ">=3.11.12,<4" },
@@ -4782,10 +4782,14 @@ requires-dist = [
 ]
 <<<<<<< HEAD
 <<<<<<< HEAD
+<<<<<<< HEAD
 provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "gradium", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "noisereduce", "nvidia", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
 =======
 provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "rnnoise", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
 >>>>>>> 621f0b23 (chore: update uv.lock with pyrnnoise and restore revision 3)
+=======
+provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
+>>>>>>> 5620bf81 (align uv.lock)
 
 [package.metadata.requires-dev]
 dev = [

From 90ef758522d6369d738fc7436e005af4a2dbe678 Mon Sep 17 00:00:00 2001
From: gui217 <roi235@gmail.com>
Date: Mon, 8 Dec 2025 11:31:47 +0200
Subject: [PATCH 5/7] align uv.lock

---
 uv.lock | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/uv.lock b/uv.lock
index ce43a9296..089dd6aea 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.13'",
@@ -43,6 +43,7 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f9/ba/3ebe31b91e03d42437ec864e9d2af3a52b7ccc73a1a0c1026275956270b0/aic_sdk-1.2.0.tar.gz", hash = "sha256:eeda9a181c679f175dbe6f0efc0c67ec98ff3d84cfe01541fef7fa12ecd505ca", size = 35606, upload-time = "2025-11-20T14:42:14.333Z" }
 
+
 [[package]]
 name = "aioboto3"
 version = "15.5.0"
@@ -4783,6 +4784,7 @@ requires-dist = [
 <<<<<<< HEAD
 <<<<<<< HEAD
 <<<<<<< HEAD
+<<<<<<< HEAD
 provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "gradium", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "noisereduce", "nvidia", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
 =======
 provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "rnnoise", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
@@ -4790,6 +4792,9 @@ provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova
 =======
 provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
 >>>>>>> 5620bf81 (align uv.lock)
+=======
+provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "rnnoise", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
+>>>>>>> 244a3282 (align uv.lock)
 
 [package.metadata.requires-dev]
 dev = [

From c48858742a918504677311d764ede976f284dbee Mon Sep 17 00:00:00 2001
From: gui217 <roi235@gmail.com>
Date: Mon, 8 Dec 2025 11:51:20 +0200
Subject: [PATCH 6/7] clean up

---
 uv.lock | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/uv.lock b/uv.lock
index 089dd6aea..1850ee2a3 100644
--- a/uv.lock
+++ b/uv.lock
@@ -43,7 +43,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f9/ba/3ebe31b91e03d42437ec864e9d2af3a52b7ccc73a1a0c1026275956270b0/aic_sdk-1.2.0.tar.gz", hash = "sha256:eeda9a181c679f175dbe6f0efc0c67ec98ff3d84cfe01541fef7fa12ecd505ca", size = 35606, upload-time = "2025-11-20T14:42:14.333Z" }
 
-
 [[package]]
 name = "aioboto3"
 version = "15.5.0"
@@ -4781,20 +4780,8 @@ requires-dist = [
     { name = "wait-for2", marker = "python_full_version < '3.12'", specifier = ">=0.4.1" },
     { name = "websockets", marker = "extra == 'websockets-base'", specifier = ">=13.1,<16.0" },
 ]
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
-provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "gradium", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "noisereduce", "nvidia", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
-=======
-provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "rnnoise", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
->>>>>>> 621f0b23 (chore: update uv.lock with pyrnnoise and restore revision 3)
-=======
-provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "rnnoise", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
->>>>>>> 5620bf81 (align uv.lock)
-=======
-provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "nim", "noisereduce", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "rnnoise", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper"]
->>>>>>> 244a3282 (align uv.lock)
+provides-extras = ["aic", "anthropic", "assemblyai", "asyncai", "aws", "aws-nova-sonic", "azure", "cartesia", "cerebras", "daily", "deepgram", "deepseek", "elevenlabs", "fal", "fireworks", "fish", "gladia", "google", "gradium", "grok", "groq", "gstreamer", "heygen", "hume", "inworld", "koala", "krisp", "langchain", "livekit", "lmnt", "local", "local-smart-turn", "local-smart-turn-v3", "mcp", "mem0", "mistral", "mlx-whisper", "moondream", "neuphonic", "noisereduce", "nvidia", "openai", "openpipe", "openrouter", "perplexity", "playht", "qwen", "remote-smart-turn", "rime", "riva", "runner", "sagemaker", "sambanova", "sarvam", "sentry", "silero", "simli", "soniox", "soundfile", "speechmatics", "strands", "tavus", "together", "tracing", "ultravox", "webrtc", "websocket", "websockets-base", "whisper", "rnnoise"]
+
 
 [package.metadata.requires-dev]
 dev = [

From 1c0e25a90d12d0359e7b166e907f92e076f49805 Mon Sep 17 00:00:00 2001
From: gui217 <roi235@gmail.com>
Date: Tue, 9 Dec 2025 09:56:20 +0200
Subject: [PATCH 7/7] fix unit tests

---
 tests/test_rnnoise_cancellation.py | 258 +++++++++++++++--------------
 tests/test_rnnoise_filter.py       |   9 +
 tests/test_rnnoise_resampling.py   | 193 +++++++++++----------
 3 files changed, 232 insertions(+), 228 deletions(-)

diff --git a/tests/test_rnnoise_cancellation.py b/tests/test_rnnoise_cancellation.py
index 967caa7fa..302dc58e8 100644
--- a/tests/test_rnnoise_cancellation.py
+++ b/tests/test_rnnoise_cancellation.py
@@ -1,167 +1,169 @@
 import asyncio
-import os
-import wave
+import unittest
 
 import numpy as np
 import pytest
 
+try:
+    import pyrnnoise
+except ImportError:
+    pyrnnoise = None
+
 from pipecat.audio.filters.rnnoise_filter import RNNoiseFilter
 from pipecat.frames.frames import FilterEnableFrame
 
 
-async def test_rnnoise_cancellation_functionality():
-    print("\nStarting Noise Cancellation Test")
+class TestRNNoiseCancellation(unittest.IsolatedAsyncioTestCase):
+    async def test_rnnoise_cancellation_functionality(self):
+        print("\nStarting Noise Cancellation Test")
 
-    # 1. Check for pyrnnoise
-    try:
-        import pyrnnoise
-    except ImportError:
-        pytest.skip("pyrnnoise not installed. Cannot verify actual noise cancellation.")
-        return
+        # 1. Check for pyrnnoise
+        if pyrnnoise is None:
+            self.skipTest("pyrnnoise not installed. Cannot verify actual noise cancellation.")
 
-    # 2. Generate clean speech-like audio (Harmonic series)
-    sample_rate = 48000
-    duration = 2.0
-    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+        # 2. Generate clean speech-like audio (Harmonic series)
+        sample_rate = 48000
+        duration = 2.0
+        t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
 
-    # Fundamental 200Hz + harmonics
-    clean_signal = np.sin(2 * np.pi * 200 * t) * 0.5
-    clean_signal += np.sin(2 * np.pi * 400 * t) * 0.3
-    clean_signal += np.sin(2 * np.pi * 600 * t) * 0.2
+        # Fundamental 200Hz + harmonics
+        clean_signal = np.sin(2 * np.pi * 200 * t) * 0.5
+        clean_signal += np.sin(2 * np.pi * 400 * t) * 0.3
+        clean_signal += np.sin(2 * np.pi * 600 * t) * 0.2
 
-    # Apply envelope to simulate speech (bursts)
-    # sin(2*pi*2*t) has period 0.5s.
-    envelope = np.sin(2 * np.pi * 2 * t)
-    envelope = np.clip(envelope, 0, 1)
-    clean_signal *= envelope
+        # Apply envelope to simulate speech (bursts)
+        # sin(2*pi*2*t) has period 0.5s.
+        envelope = np.sin(2 * np.pi * 2 * t)
+        envelope = np.clip(envelope, 0, 1)
+        clean_signal *= envelope
 
-    # 3. Add Noise (White Noise)
-    noise_level = 0.1  # Reduced noise level slightly to make speech clearer for alignment
-    noise = np.random.normal(0, noise_level, len(t))
+        # 3. Add Noise (White Noise)
+        noise_level = 0.1  # Reduced noise level slightly to make speech clearer for alignment
+        noise = np.random.normal(0, noise_level, len(t))
 
-    noisy_signal = clean_signal + noise
+        noisy_signal = clean_signal + noise
 
-    # Normalize to int16 range
-    noisy_signal = np.clip(noisy_signal, -1, 1)
-    noisy_int16 = (noisy_signal * 32767).astype(np.int16)
-    noisy_bytes = noisy_int16.tobytes()
+        # Normalize to int16 range
+        noisy_signal = np.clip(noisy_signal, -1, 1)
+        noisy_int16 = (noisy_signal * 32767).astype(np.int16)
+        noisy_bytes = noisy_int16.tobytes()
 
-    clean_int16 = (clean_signal * 32767).astype(np.int16)
+        clean_int16 = (clean_signal * 32767).astype(np.int16)
 
-    print(f"Generated 2s of noisy audio at {sample_rate}Hz")
+        print(f"Generated 2s of noisy audio at {sample_rate}Hz")
 
-    # 4. Initialize RNNoiseFilter
-    rnnoise_filter = RNNoiseFilter()
-    await rnnoise_filter.start(sample_rate)
-    await rnnoise_filter.process_frame(FilterEnableFrame(enable=True))
+        # 4. Initialize RNNoiseFilter
+        rnnoise_filter = RNNoiseFilter()
+        await rnnoise_filter.start(sample_rate)
+        await rnnoise_filter.process_frame(FilterEnableFrame(enable=True))
 
-    # 5. Process
-    # Feed in chunks
-    chunk_size = 960  # 20ms
-    processed_audio = b""
+        # 5. Process
+        # Feed in chunks
+        chunk_size = 960  # 20ms
+        processed_audio = b""
 
-    for i in range(0, len(noisy_bytes), chunk_size):
-        chunk = noisy_bytes[i : i + chunk_size]
-        result = await rnnoise_filter.filter(chunk)
-        processed_audio += result
+        for i in range(0, len(noisy_bytes), chunk_size):
+            chunk = noisy_bytes[i : i + chunk_size]
+            result = await rnnoise_filter.filter(chunk)
+            processed_audio += result
 
-    await rnnoise_filter.stop()
+        await rnnoise_filter.stop()
 
-    print(f"Output audio size: {len(processed_audio)}")
+        print(f"Output audio size: {len(processed_audio)}")
 
-    # 6. Verify Noise Reduction
-    output_int16 = np.frombuffer(processed_audio, dtype=np.int16)
+        # 6. Verify Noise Reduction
+        output_int16 = np.frombuffer(processed_audio, dtype=np.int16)
 
-    # Truncate to min length
-    min_len = min(len(clean_int16), len(output_int16))
-    clean_trunc = clean_int16[:min_len]
-    output_trunc = output_int16[:min_len]
-    noisy_trunc = noisy_int16[:min_len]
+        # Truncate to min length
+        min_len = min(len(clean_int16), len(output_int16))
+        clean_trunc = clean_int16[:min_len]
+        output_trunc = output_int16[:min_len]
+        noisy_trunc = noisy_int16[:min_len]
 
-    # 7. Compensate for Delay
-    # Use cross-correlation on a segment to find delay
-    # We expect output to be delayed relative to clean (lag is positive)
-    # search window +/- 2000 samples (~40ms)
+        # 7. Compensate for Delay
+        # Use cross-correlation on a segment to find delay
+        # We expect output to be delayed relative to clean (lag is positive)
+        # search window +/- 2000 samples (~40ms)
 
-    search_range = 2400  # 50ms
-    # Use the middle of the signal to avoid edge effects and have strong signal
-    mid_point = min_len // 2
-    window_len = 4800  # 100ms
+        search_range = 2400  # 50ms
+        # Use the middle of the signal to avoid edge effects and have strong signal
+        mid_point = min_len // 2
+        window_len = 4800  # 100ms
 
-    ref_sig = clean_trunc[mid_point : mid_point + window_len].astype(float)
-    target_sig = output_trunc[
-        mid_point - search_range : mid_point + window_len + search_range
-    ].astype(float)
+        ref_sig = clean_trunc[mid_point : mid_point + window_len].astype(float)
+        target_sig = output_trunc[
+            mid_point - search_range : mid_point + window_len + search_range
+        ].astype(float)
 
-    correlation = np.correlate(target_sig, ref_sig, mode="valid")
-    best_idx = np.argmax(correlation)
+        correlation = np.correlate(target_sig, ref_sig, mode="valid")
+        best_idx = np.argmax(correlation)
 
-    # The 'valid' mode correlation result corresponds to shifts.
-    # index 0 matches alignment where ref starts at target start.
-    # target start is (mid_point - search_range).
-    # ref start is mid_point.
-    # So index 0 means target is shifted left by search_range (or delay = -search_range).
-    # delay = best_idx - search_range
+        # The 'valid' mode correlation result corresponds to shifts.
+        # index 0 matches alignment where ref starts at target start.
+        # target start is (mid_point - search_range).
+        # ref start is mid_point.
+        # So index 0 means target is shifted left by search_range (or delay = -search_range).
+        # delay = best_idx - search_range
 
-    delay = best_idx - search_range
-    print(f"Detected delay: {delay} samples ({delay / sample_rate * 1000:.2f} ms)")
+        delay = best_idx - search_range
+        print(f"Detected delay: {delay} samples ({delay / sample_rate * 1000:.2f} ms)")
 
-    # Shift output to align
-    if delay > 0:
-        # Output is delayed, so we need to look at output[delay:] to match clean[0:]
-        aligned_output = output_trunc[delay:]
-        aligned_clean = clean_trunc[: len(aligned_output)]
-        aligned_noisy = noisy_trunc[: len(aligned_output)]
-    elif delay < 0:
-        # Output is ahead (unlikely for causal filter), but handling it
-        aligned_output = output_trunc[:delay]
-        aligned_clean = clean_trunc[-delay:]
-        aligned_noisy = noisy_trunc[-delay:]
-    else:
-        aligned_output = output_trunc
-        aligned_clean = clean_trunc
-        aligned_noisy = noisy_trunc
+        # Shift output to align
+        if delay > 0:
+            # Output is delayed, so we need to look at output[delay:] to match clean[0:]
+            aligned_output = output_trunc[delay:]
+            aligned_clean = clean_trunc[: len(aligned_output)]
+            aligned_noisy = noisy_trunc[: len(aligned_output)]
+        elif delay < 0:
+            # Output is ahead (unlikely for causal filter), but handling it
+            aligned_output = output_trunc[:delay]
+            aligned_clean = clean_trunc[-delay:]
+            aligned_noisy = noisy_trunc[-delay:]
+        else:
+            aligned_output = output_trunc
+            aligned_clean = clean_trunc
+            aligned_noisy = noisy_trunc
 
-    # Recalculate MSE on aligned signals
-    mse_input = np.mean((aligned_noisy.astype(float) - aligned_clean.astype(float)) ** 2)
-    mse_output = np.mean((aligned_output.astype(float) - aligned_clean.astype(float)) ** 2)
+        # Recalculate MSE on aligned signals
+        mse_input = np.mean((aligned_noisy.astype(float) - aligned_clean.astype(float)) ** 2)
+        mse_output = np.mean((aligned_output.astype(float) - aligned_clean.astype(float)) ** 2)
 
-    print(f"MSE (Input vs Clean): {mse_input:.2f}")
-    print(f"MSE (Output vs Clean): {mse_output:.2f}")
+        print(f"MSE (Input vs Clean): {mse_input:.2f}")
+        print(f"MSE (Output vs Clean): {mse_output:.2f}")
 
-    # Also check noise reduction in silent regions
-    # Clean signal envelope is 0 at t=0, 0.25, 0.5...
-    # Let's find indices where aligned_clean is very small
-    threshold = 100  # amplitude threshold (out of 32767)
-    silent_mask = np.abs(aligned_clean) < threshold
+        # Also check noise reduction in silent regions
+        # Clean signal envelope is 0 at t=0, 0.25, 0.5...
+        # Let's find indices where aligned_clean is very small
+        threshold = 100  # amplitude threshold (out of 32767)
+        silent_mask = np.abs(aligned_clean) < threshold
 
-    if np.sum(silent_mask) > 1000:
-        noise_power_input = np.mean(aligned_noisy[silent_mask].astype(float) ** 2)
-        noise_power_output = np.mean(aligned_output[silent_mask].astype(float) ** 2)
-        print(f"Noise Power in Silence (Input): {noise_power_input:.2f}")
-        print(f"Noise Power in Silence (Output): {noise_power_output:.2f}")
-        assert noise_power_output < noise_power_input, "Noise power in silence not reduced"
-    else:
-        print("Warning: Not enough silent samples found for noise floor check.")
+        if np.sum(silent_mask) > 1000:
+            noise_power_input = np.mean(aligned_noisy[silent_mask].astype(float) ** 2)
+            noise_power_output = np.mean(aligned_output[silent_mask].astype(float) ** 2)
+            print(f"Noise Power in Silence (Input): {noise_power_input:.2f}")
+            print(f"Noise Power in Silence (Output): {noise_power_output:.2f}")
+            self.assertLess(
+                noise_power_output, noise_power_input, "Noise power in silence not reduced"
+            )
+        else:
+            print("Warning: Not enough silent samples found for noise floor check.")
 
-    # Main assertion: MSE should improve
-    # Relax assertion slightly because RNNoise introduces distortion even on clean speech
-    # But for noisy speech, it should generally be better or at least remove noise.
-    # If MSE doesn't improve (due to speech distortion), at least Noise Power in Silence should drop.
+        # Main assertion: MSE should improve
+        # Relax assertion slightly because RNNoise introduces distortion even on clean speech
+        # But for noisy speech, it should generally be better or at least remove noise.
+        # If MSE doesn't improve (due to speech distortion), at least Noise Power in Silence should drop.
 
-    if mse_output >= mse_input:
-        print(
-            "Warning: Overall MSE did not improve (speech distortion?). Relying on Noise Power check."
-        )
-        # If we passed the noise power check above, we are good.
-        assert np.sum(silent_mask) > 1000 and np.mean(
-            aligned_output[silent_mask].astype(float) ** 2
-        ) < np.mean(aligned_noisy[silent_mask].astype(float) ** 2)
-    else:
-        assert mse_output < mse_input, "MSE did not improve"
+        if mse_output >= mse_input:
+            print(
+                "Warning: Overall MSE did not improve (speech distortion?). Relying on Noise Power check."
+            )
+            # If we passed the noise power check above, we are good.
+            self.assertTrue(
+                np.sum(silent_mask) > 1000
+                and np.mean(aligned_output[silent_mask].astype(float) ** 2)
+                < np.mean(aligned_noisy[silent_mask].astype(float) ** 2)
+            )
+        else:
+            self.assertLess(mse_output, mse_input, "MSE did not improve")
 
-    print("Test Passed: Noise cancellation verified.")
-
-
-if __name__ == "__main__":
-    asyncio.run(test_rnnoise_cancellation_functionality())
+        print("Test Passed: Noise cancellation verified.")
diff --git a/tests/test_rnnoise_filter.py b/tests/test_rnnoise_filter.py
index cfc706af4..6a99b3ba0 100644
--- a/tests/test_rnnoise_filter.py
+++ b/tests/test_rnnoise_filter.py
@@ -8,11 +8,20 @@ import unittest
 
 import numpy as np
 
+try:
+    import pyrnnoise
+except ImportError:
+    pyrnnoise = None
+
 from pipecat.audio.filters.rnnoise_filter import RNNoiseFilter
 from pipecat.frames.frames import FilterEnableFrame
 
 
 class TestRNNoiseFilter(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        if pyrnnoise is None:
+            self.skipTest("pyrnnoise not installed")
+
     async def test_rnnoise_filter_reduces_noise(self):
         """Test that RNNoise filter reduces noise in audio."""
         filter = RNNoiseFilter()
diff --git a/tests/test_rnnoise_resampling.py b/tests/test_rnnoise_resampling.py
index f22413597..acbab4fc0 100644
--- a/tests/test_rnnoise_resampling.py
+++ b/tests/test_rnnoise_resampling.py
@@ -1,136 +1,129 @@
 import asyncio
 import sys
-from unittest.mock import MagicMock
+import unittest
+from unittest.mock import MagicMock, patch
 
 import numpy as np
-import pytest
 
-# Mock pyrnnoise BEFORE importing RNNoiseFilter
-mock_pyrnnoise = MagicMock()
-mock_rnnoise_class = MagicMock()
-mock_pyrnnoise.RNNoise = mock_rnnoise_class
-sys.modules["pyrnnoise"] = mock_pyrnnoise
-
-# Now import the filter
+# We don't need to mock sys.modules here if we use patch on the imported module member
+# But we need to ensure RNNoiseFilter is imported so we can patch its member
 try:
     from pipecat.audio.filters.rnnoise_filter import RNNoiseFilter
     from pipecat.frames.frames import FilterEnableFrame
 except ImportError as e:
+    # If dependencies are missing (like numpy?), we can't test
     print(f"Failed to import RNNoiseFilter: {e}")
     sys.exit(1)
 
 
-async def test_rnnoise_resampling_16k_to_48k_and_back():
-    print("\nStarting Resampling Test: 16kHz -> 48kHz -> 16kHz")
+class TestRNNoiseResampling(unittest.IsolatedAsyncioTestCase):
+    @patch("pipecat.audio.filters.rnnoise_filter.RNNoise")
+    async def test_rnnoise_resampling_16k_to_48k_and_back(self, mock_rnnoise_class):
+        print("\nStarting Resampling Test: 16kHz -> 48kHz -> 16kHz")
 
-    # Configure Mock with buffering behavior
-    processed_chunks_count = 0
-    buffer = np.array([], dtype=np.int16)
+        # Configure Mock with buffering behavior
+        processed_chunks_count = 0
+        buffer = np.array([], dtype=np.int16)
 
-    def side_effect_process_chunk(audio_samples, partial=False):
-        nonlocal buffer, processed_chunks_count
+        def side_effect_process_chunk(audio_samples, partial=False):
+            nonlocal buffer, processed_chunks_count
 
-        # Append new samples to buffer
-        if len(audio_samples) > 0:
-            buffer = np.concatenate((buffer, audio_samples))
+            # Append new samples to buffer
+            if len(audio_samples) > 0:
+                buffer = np.concatenate((buffer, audio_samples))
 
-        # Yield 480-sample chunks
-        while len(buffer) >= 480:
-            chunk = buffer[:480]
-            buffer = buffer[480:]
-            processed_chunks_count += 1
+            # Yield 480-sample chunks
+            while len(buffer) >= 480:
+                chunk = buffer[:480]
+                buffer = buffer[480:]
+                processed_chunks_count += 1
 
-            # Simulate processing (pass through)
-            # Convert int16 -> float32 [-1, 1]
-            normalized = chunk.astype(np.float32) / 32768.0
-            yield 0.99, normalized
+                # Simulate processing (pass through)
+                # Convert int16 -> float32 [-1, 1]
+                normalized = chunk.astype(np.float32) / 32768.0
+                yield 0.99, normalized
 
-    mock_rnnoise_instance = MagicMock()
-    mock_rnnoise_instance.denoise_chunk.side_effect = side_effect_process_chunk
-    mock_rnnoise_class.return_value = mock_rnnoise_instance
+        mock_rnnoise_instance = MagicMock()
+        mock_rnnoise_instance.denoise_chunk.side_effect = side_effect_process_chunk
+        mock_rnnoise_class.return_value = mock_rnnoise_instance
 
-    # 1. Generate 1 second of 16kHz audio (sine wave 440Hz)
-    sample_rate = 16000
-    duration = 1.0
-    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
-    audio_data = (np.sin(2 * np.pi * 440 * t) * 32767).astype(np.int16)
-    audio_bytes = audio_data.tobytes()
+        # 1. Generate 1 second of 16kHz audio (sine wave 440Hz)
+        sample_rate = 16000
+        duration = 1.0
+        t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+        audio_data = (np.sin(2 * np.pi * 440 * t) * 32767).astype(np.int16)
+        audio_bytes = audio_data.tobytes()
 
-    print(f"Input audio: {len(audio_bytes)} bytes, {len(audio_data)} samples at {sample_rate}Hz")
+        print(
+            f"Input audio: {len(audio_bytes)} bytes, {len(audio_data)} samples at {sample_rate}Hz"
+        )
 
-    # 2. Initialize RNNoiseFilter
-    rnnoise_filter = RNNoiseFilter()
-    await rnnoise_filter.start(sample_rate)
+        # 2. Initialize RNNoiseFilter
+        # This will use the patched RNNoise
+        rnnoise_filter = RNNoiseFilter()
+        await rnnoise_filter.start(sample_rate)
 
-    # Enable filtering
-    await rnnoise_filter.process_frame(FilterEnableFrame(enable=True))
+        # Enable filtering
+        await rnnoise_filter.process_frame(FilterEnableFrame(enable=True))
 
-    # 3. Process audio in chunks
-    chunk_size = 320  # 160 samples (10ms at 16k) * 2 bytes
-    processed_audio = b""
+        # 3. Process audio in chunks
+        chunk_size = 320  # 160 samples (10ms at 16k) * 2 bytes
+        processed_audio = b""
 
-    for i in range(0, len(audio_bytes), chunk_size):
-        chunk = audio_bytes[i : i + chunk_size]
-        result = await rnnoise_filter.filter(chunk)
-        processed_audio += result
+        for i in range(0, len(audio_bytes), chunk_size):
+            chunk = audio_bytes[i : i + chunk_size]
+            result = await rnnoise_filter.filter(chunk)
+            processed_audio += result
 
-    await rnnoise_filter.stop()
+        await rnnoise_filter.stop()
 
-    print(f"Output audio: {len(processed_audio)} bytes")
-    print(f"Processed chunks (internal 480 samples): {processed_chunks_count}")
+        print(f"Output audio: {len(processed_audio)} bytes")
+        print(f"Processed chunks (internal 480 samples): {processed_chunks_count}")
 
-    # 4. Verify output length
-    # Expect roughly same length
-    # Input: 16000 samples.
-    # Upsampled to 48000.
-    # 48000 / 480 = 100 chunks.
-    # So we expect roughly 100 calls to process_chunk.
-    expected_chunks = (len(audio_data) * 48000 // sample_rate) // 480
-    print(f"Expected chunks: ~{expected_chunks}")
+        # 4. Verify output length
+        # Expect roughly same length
+        expected_chunks = (len(audio_data) * 48000 // sample_rate) // 480
+        print(f"Expected chunks: ~{expected_chunks}")
 
-    # Check that we actually processed something
-    assert processed_chunks_count >= expected_chunks - 5, "Too few chunks processed"
+        # Check that we actually processed something
+        self.assertGreaterEqual(
+            processed_chunks_count, expected_chunks - 5, "Too few chunks processed"
+        )
 
-    # Check output length
-    assert len(processed_audio) > 0, "Output should not be empty"
+        # Check output length
+        self.assertGreater(len(processed_audio), 0, "Output should not be empty")
 
-    # Check length matches input (with some tolerance for buffering latency)
-    # Since we don't flush the filter explicitly (no flush method in RNNoiseFilter yet),
-    # some data might remain in buffers.
-    # Max loss:
-    # - Resampler input buffer
-    # - RNNoise buffer (max 480 samples = 10ms)
-    # - Resampler output buffer
+        # Check length matches input (with some tolerance for buffering latency)
+        # 100ms tolerance?
+        byte_tolerance = int(0.2 * sample_rate * 2)
+        self.assertGreaterEqual(
+            len(processed_audio),
+            len(audio_bytes) - byte_tolerance,
+            f"Output too short: {len(processed_audio)} vs {len(audio_bytes)}",
+        )
+        self.assertLessEqual(
+            len(processed_audio),
+            len(audio_bytes) + byte_tolerance,
+            f"Output too long: {len(processed_audio)} vs {len(audio_bytes)}",
+        )
 
-    # 100ms tolerance?
-    byte_tolerance = int(0.2 * sample_rate * 2)
-    assert len(processed_audio) >= len(audio_bytes) - byte_tolerance, (
-        f"Output too short: {len(processed_audio)} vs {len(audio_bytes)}"
-    )
-    assert len(processed_audio) <= len(audio_bytes) + byte_tolerance, (
-        f"Output too long: {len(processed_audio)} vs {len(audio_bytes)}"
-    )
+        # 5. Check sample rate / pitch preservation
+        output_data = np.frombuffer(processed_audio, dtype=np.int16)
 
-    # 5. Check sample rate / pitch preservation
-    # If we upsampled and downsampled correctly, the pitch should be 440Hz.
-    output_data = np.frombuffer(processed_audio, dtype=np.int16)
+        if len(output_data) > 2000:
+            # Use a window in the middle
+            start_idx = len(output_data) // 4
+            end_idx = 3 * len(output_data) // 4
+            segment = output_data[start_idx:end_idx]
 
-    if len(output_data) > 2000:
-        # Use a window in the middle
-        start_idx = len(output_data) // 4
-        end_idx = 3 * len(output_data) // 4
-        segment = output_data[start_idx:end_idx]
+            fft = np.fft.rfft(segment)
+            freqs = np.fft.rfftfreq(len(segment), d=1 / sample_rate)
+            peak_idx = np.argmax(np.abs(fft))
+            peak_freq = freqs[peak_idx]
 
-        fft = np.fft.rfft(segment)
-        freqs = np.fft.rfftfreq(len(segment), d=1 / sample_rate)
-        peak_idx = np.argmax(np.abs(fft))
-        peak_freq = freqs[peak_idx]
+            print(f"Peak frequency: {peak_freq:.2f} Hz")
+            self.assertLess(
+                abs(peak_freq - 440), 50, f"Frequency shifted significantly: {peak_freq} vs 440"
+            )
 
-        print(f"Peak frequency: {peak_freq:.2f} Hz")
-        assert abs(peak_freq - 440) < 50, f"Frequency shifted significantly: {peak_freq} vs 440"
-
-    print("Test Passed: Resampling logic verified (with mocked RNNoise).")
-
-
-if __name__ == "__main__":
-    asyncio.run(test_rnnoise_resampling_16k_to_48k_and_back())
+        print("Test Passed: Resampling logic verified (with mocked RNNoise).")