Suppress Gemini mic before output audio arrives

src/hermesbody/gemini_live.py

@@ -16,6 +16,7 @@ import logging
 import math
 import os
 import secrets
+import time
 from collections.abc import AsyncIterator, Mapping
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -347,6 +348,8 @@ class MacMiniGeminiAudioServer:
         self._audio_bytes_received = 0
         self._provider_events_sent = 0
         self._output_audio_events_sent = 0
+        self._suppress_audio_input_until = 0.0
+        self._suppressed_audio_input_frames = 0
 
     async def serve_forever(self) -> None:
         try:
@@ -446,6 +449,20 @@ class MacMiniGeminiAudioServer:
                     peak,
                     self._audio_bytes_received,
                 )
+            now = time.monotonic()
+            if now < self._suppress_audio_input_until:
+                self._suppressed_audio_input_frames += 1
+                if self._suppressed_audio_input_frames <= 5 or self._suppressed_audio_input_frames % 100 == 0:
+                    remaining_ms = int((self._suppress_audio_input_until - now) * 1000)
+                    logger.info(
+                        "Mac audio bridge suppressing input during Gemini output client #%s frame=%d remaining_ms=%d rms=%.5f peak=%.5f",
+                        client_id,
+                        self._suppressed_audio_input_frames,
+                        remaining_ms,
+                        rms,
+                        peak,
+                    )
+                return
             try:
                 returned = await _maybe_await(self.controller.send_audio_frame(frame))
             except Exception as exc:
@@ -493,13 +510,26 @@ class MacMiniGeminiAudioServer:
                     self._provider_events_sent += 1
                     if event.type == "output_audio" and event.frame is not None:
                         self._output_audio_events_sent += 1
+                        playback_seconds = len(event.frame.pcm) / float((event.frame.sample_rate or DEFAULT_OUTPUT_SAMPLE_RATE) * max(event.frame.channels, 1) * 2)
+                        self._suppress_audio_input_until = max(
+                            self._suppress_audio_input_until,
+                            time.monotonic() + playback_seconds + 0.35,
+                        )
                         logger.info(
-                            "Mac audio bridge provider event client #%s type=output_audio bytes=%d sr=%d",
+                            "Mac audio bridge provider event client #%s type=output_audio bytes=%d sr=%d suppress_ms=%d",
                             client_id,
                             len(event.frame.pcm),
                             event.frame.sample_rate,
+                            int((self._suppress_audio_input_until - time.monotonic()) * 1000),
                         )
                     else:
+                        if event.type in {"output_text", "output_transcription"}:
+                            self._suppress_audio_input_until = max(
+                                self._suppress_audio_input_until,
+                                time.monotonic() + 2.0,
+                            )
+                        if event.type in {"turn_complete"}:
+                            self._suppress_audio_input_until = min(self._suppress_audio_input_until, time.monotonic() + 0.25)
                         logger.info(
                             "Mac audio bridge provider event client #%s type=%s text=%r reason=%r data=%s",
                             client_id,

src/hermesbody/main.py

@@ -639,6 +639,12 @@ class HermesBodyCore:
                     self.movement_manager.set_processing(False)
                     if self.head_wobbler is not None:
                         self.head_wobbler.reset()
+                elif message.type in {"output_text", "output_transcription"}:
+                    # Gemini can emit text/transcription slightly before audio frames arrive.
+                    # Close the mic immediately so the tail of the user's utterance or local
+                    # speaker output doesn't interrupt the model before TTS reaches Reachy.
+                    self._suppress_mic_until = max(self._suppress_mic_until, time.monotonic() + 2.0)
+                    logger.info("Gemini output started; suppressing mic briefly: %s", message.text or message.data)
                 elif message.type == "brain_start":
                     self.movement_manager.set_processing(True)
                     logger.info("Gemini brain call started: %s", message.text or message.data)