crates/chunker/src/stream.rs (1)

48-50: 🛠️ Refactor suggestion

as_stream() is rebuilt on every poll – this can replay the source

let stream = this.source.as_stream(); followed by pin!(stream) runs on each poll_next call, which
creates a brand-new stream every time.
If as_stream() yields a fresh iterator starting from the beginning (which is typical), the chunker will
loop forever on the first samples or duplicate audio.

Store the pinned stream once inside the struct instead:

-pub struct ChunkStream<S: AsyncSource + Unpin> {
+pub struct ChunkStream<S: AsyncSource + Unpin, St> {
     source: S,
-    vad: VoiceActivityDetector,
+    stream: Pin<Box<St>>,
     vad: VoiceActivityDetector,
@@
-        Self {
-            source,
-            vad,
-            buffer: Vec::new(),
-            max_duration,
-        }
+        let stream = Box::pin(source.as_stream());
+        Self { source, stream, vad, buffer: Vec::new(), max_duration }

plugins/local-stt/src/server.rs (1)

149-157: VAD configuration looks good but could be more robust.

The implementation correctly configures the VoiceActivityDetector with appropriate parameters for speech recognition. The sample rate of 16kHz and chunk size of 512 samples are reasonable values for voice detection.

However, using expect() for error handling could be improved for production code.

Consider handling potential errors more gracefully:

- let vad = VoiceActivityDetector::builder()
-     .sample_rate(sample_rate)
-     .chunk_size(512usize)
-     .build()
-     .expect("vad config is valid");
+ let vad = match VoiceActivityDetector::builder()
+     .sample_rate(sample_rate)
+     .chunk_size(512usize)
+     .build() {
+         Ok(vad) => vad,
+         Err(e) => {
+             tracing::error!("Failed to build VAD: {}", e);
+             // Either return an error or fall back to default parameters
+             return;
+         }
+     };

Additionally, consider making these parameters configurable rather than hardcoded, which would make the system more adaptable to different audio conditions.

crates/chunker/src/lib.rs (2)

9-15: Return ChunkStream without consuming the VAD instance

The chunks method currently takes vad by value, which moves the detector into the ChunkStream.
That prevents re-using the same configured detector for issuing multiple independent chunk streams from the
same audio source (e.g. different max-duration settings), and also means the caller loses access to the VAD
for any other purpose.

If the underlying type implements Clone (it does) and is Send + Sync safe, consider taking the argument
by &VoiceActivityDetector and cloning internally, or alternatively by impl Into<VoiceActivityDetector>
to give the caller more flexibility.

---

48-56: Avoid panicking when the temp directory does not yet exist

std::fs::remove_dir_all returns ErrorKind::NotFound when the directory is missing.
Unwrapping on that error makes the test unnecessarily brittle.

-        std::fs::remove_dir_all("tmp/english_1").unwrap();
+        let _ = std::fs::remove_dir_all("tmp/english_1");

(or check for the error explicitly).

crates/chunker/src/stream.rs (2)

79-85: Duplicated logic – extract helper for final chunk creation

The three identical blocks that convert speech into a SamplesBuffer could be factored into a small helper
to reduce repetition and future maintenance overhead.

---

90-105: Expose threshold & padding as parameters

filter_speech_chunks hard-codes a 0.75 probability threshold and 3-frame padding.
Different environments may require tuning. Consider propagating these values from the public API or from the
builder of ChunkStream.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

crates/chunker/src/lib.rs (1)

48-49: Error handling in tests could be improved

The call to remove_dir_all will panic if the directory doesn't exist, which could cause test failures in clean environments.

Consider handling the case where the directory doesn't exist:

-std::fs::remove_dir_all("tmp/english_1").unwrap();
+let _ = std::fs::remove_dir_all("tmp/english_1"); // Ignore errors if directory doesn't exist

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

crates/chunker/src/stream.rs (2)

63-71: Consider skipping instead of terminating when buffer is empty

When the source stream ends with leftover data but no speech is detected, the current implementation returns Poll::Ready(None), which signals the end of the stream. This might prematurely terminate processing if there's more data to come.

Replace the early-return with a different approach to avoid terminating the stream prematurely:

Poll::Ready(None) if !this.buffer.is_empty() => {
    let data = std::mem::take(&mut this.buffer);
    let speech = filter_speech_chunks(&mut this.vad, data);
-   if speech.is_empty() {
-       return Poll::Ready(None);
-   } else {
+   if !speech.is_empty() {
        return Poll::Ready(Some(SamplesBuffer::new(1, sample_rate, speech)));
    }
+   // No speech detected in the final buffer, just signal end of stream
+   return Poll::Ready(None);
}

---

87-103: 🛠️ Refactor suggestion

Make VAD parameters configurable

The filter_speech_chunks function uses hardcoded values for the threshold (0.75) and window size (3) in the VAD processing. These should be configurable parameters to allow tuning for different audio conditions and use cases.

// helper function to filter speech chunks
fn filter_speech_chunks<D: IntoIterator<Item = f32>>(
    vad: &mut VoiceActivityDetector,
    data: D,
+   threshold: f32,
+   window_size: usize,
) -> Vec<f32> {
    data.into_iter()
-       .label(vad, 0.75, 3)
+       .label(vad, threshold, window_size)
        .filter_map(|label| {
            if label.is_speech() {
                Some(label.into_iter())
            } else {
                None
            }
        })
        .flatten()
        .collect()
}

Then update the call sites to provide appropriate values:

- let speech = filter_speech_chunks(&mut this.vad, data);
+ let speech = filter_speech_chunks(&mut this.vad, data, 0.75, 3);

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro