voice-mode 2.28.0__tar.gz → 2.28.2__tar.gz

{voice_mode-2.28.0 → voice_mode-2.28.2}/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.28.2] - 2025-08-24
+
+### Fixed
+- **Improved noise filtering in VAD (Voice Activity Detection)**
+  - Fixed issue where nose blowing and similar non-speech sounds were detected as speech
+  - Adjusted VAD aggressiveness handling to better filter continuous non-speech audio
+  - Prevents false positives from breathing sounds, sniffles, and ambient noise
+  - Improves overall speech detection accuracy
+
+## [2.28.1] - 2025-08-24
+
+### Added
+- **Standardized project naming as VoiceMode MCP**
+  - Consistent branding across all documentation and code
+  - Updated project descriptions and metadata
+  - Renamed internal references from "voice-mode" to "VoiceMode MCP"
+  - Maintains backward compatibility with existing installations
+
+### Fixed
+- **CoreML fallback for whisper.cpp on Apple Silicon**
+  - Added proper error handling when CoreML models fail to load
+  - Automatically falls back to CPU processing if CoreML initialization fails
+  - Prevents whisper-server crashes on systems with CoreML issues
+  - Improves reliability on various macOS configurations
+
 ## [2.28.0] - 2025-08-23
 
 ### Added

{voice_mode-2.28.0 → voice_mode-2.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-mode
-Version: 2.28.0
+Version: 2.28.2
 Summary: VoiceMode - Voice interaction capabilities for AI assistants (formerly voice-mcp)
 Project-URL: Homepage, https://github.com/mbailey/voicemode
 Project-URL: Repository, https://github.com/mbailey/voicemode

{voice_mode-2.28.0 → voice_mode-2.28.2}/voice_mode/__version__.py

@@ -1,3 +1,3 @@
 # This file is automatically updated by 'make release'
 # Do not edit manually
-__version__ = "2.28.0"
+__version__ = "2.28.2"

{voice_mode-2.28.0 → voice_mode-2.28.2}/voice_mode/config.py

@@ -291,6 +291,12 @@ INITIAL_SILENCE_GRACE_PERIOD = float(os.getenv("VOICEMODE_INITIAL_SILENCE_GRACE_
 # Default listen duration for converse tool
 DEFAULT_LISTEN_DURATION = float(os.getenv("VOICEMODE_DEFAULT_LISTEN_DURATION", "120.0"))  # Default 120s listening time
 
+# Audio feedback pip/chime configuration
+# Leading silence before pips to allow Bluetooth devices to wake up
+PIP_LEADING_SILENCE = float(os.getenv("VOICEMODE_PIP_LEADING_SILENCE", "0.1"))  # Default 0.1s - minimal delay for Bluetooth
+# Trailing silence after pips to prevent cutoff
+PIP_TRAILING_SILENCE = float(os.getenv("VOICEMODE_PIP_TRAILING_SILENCE", "0.2"))  # Default 0.2s - reduced for responsiveness
+
 # Audio format configuration
 AUDIO_FORMAT = os.getenv("VOICEMODE_AUDIO_FORMAT", "pcm").lower()
 TTS_AUDIO_FORMAT = os.getenv("VOICEMODE_TTS_AUDIO_FORMAT", "pcm").lower()  # Default to PCM for optimal streaming

{voice_mode-2.28.0 → voice_mode-2.28.2}/voice_mode/core.py

@@ -395,8 +395,9 @@ async def text_to_speech(
                         if event_logger:
                             event_logger.log_event(event_logger.TTS_PLAYBACK_START)
                         
-                        # Add 100ms of silence at the beginning to prevent clipping
-                        silence_duration = 0.1  # seconds
+                        # Add configurable silence at the beginning to prevent clipping
+                        from .config import PIP_LEADING_SILENCE
+                        silence_duration = PIP_LEADING_SILENCE  # seconds
                         silence_samples = int(audio.frame_rate * silence_duration)
                         # Match the shape of the samples array exactly
                         if samples.ndim == 1:
@@ -507,13 +508,21 @@ async def text_to_speech(
         return False, metrics
 
 
-def generate_chime(frequencies: list, duration: float = 0.1, sample_rate: int = SAMPLE_RATE) -> np.ndarray:
+def generate_chime(
+    frequencies: list, 
+    duration: float = 0.1, 
+    sample_rate: int = SAMPLE_RATE,
+    leading_silence: Optional[float] = None,
+    trailing_silence: Optional[float] = None
+) -> np.ndarray:
     """Generate a chime sound with given frequencies.
     
     Args:
         frequencies: List of frequencies to play in sequence
         duration: Duration of each tone in seconds
         sample_rate: Sample rate for audio generation
+        leading_silence: Optional override for leading silence duration (seconds)
+        trailing_silence: Optional override for trailing silence duration (seconds)
         
     Returns:
         Numpy array of audio samples
@@ -521,12 +530,30 @@ def generate_chime(frequencies: list, duration: float = 0.1, sample_rate: int =
     samples_per_tone = int(sample_rate * duration)
     fade_samples = int(sample_rate * 0.01)  # 10ms fade
     
+    # Determine amplitude based on output device
+    amplitude = 0.0375  # Default (very quiet)
+    try:
+        import sounddevice as sd
+        default_output = sd.default.device[1]
+        if default_output is not None:
+            devices = sd.query_devices()
+            device_name = devices[default_output]['name'].lower()
+            # Check for Bluetooth devices (AirPods, Bluetooth headphones, etc)
+            if 'airpod' in device_name or 'bluetooth' in device_name or 'bt' in device_name:
+                amplitude = 0.15  # Higher amplitude for Bluetooth devices
+                logger.debug(f"Bluetooth device detected ({devices[default_output]['name']}), using amplitude {amplitude}")
+            else:
+                amplitude = 0.075  # Moderate amplitude for built-in speakers
+                logger.debug(f"Built-in speaker detected ({devices[default_output]['name']}), using amplitude {amplitude}")
+    except Exception as e:
+        logger.debug(f"Could not detect output device type: {e}, using default amplitude {amplitude}")
+    
     all_samples = []
     
     for freq in frequencies:
         # Generate sine wave
         t = np.linspace(0, duration, samples_per_tone, False)
-        tone = 0.0375 * np.sin(2 * np.pi * freq * t)  # 0.0375 amplitude for extremely quiet volume
+        tone = amplitude * np.sin(2 * np.pi * freq * t)
         
         # Apply fade in/out to prevent clicks
         fade_in = np.linspace(0, 1, fade_samples)
@@ -540,21 +567,55 @@ def generate_chime(frequencies: list, duration: float = 0.1, sample_rate: int =
     # Concatenate all tones
     chime = np.concatenate(all_samples)
     
+    # Import config values if not overridden
+    from .config import PIP_LEADING_SILENCE, PIP_TRAILING_SILENCE
+    
+    # Use parameter overrides or fall back to config
+    actual_leading_silence = leading_silence if leading_silence is not None else PIP_LEADING_SILENCE
+    actual_trailing_silence = trailing_silence if trailing_silence is not None else PIP_TRAILING_SILENCE
+    
+    # Add leading silence for Bluetooth wake-up time
+    # This prevents the beginning of the chime from being cut off
+    silence_samples = int(sample_rate * actual_leading_silence)
+    silence = np.zeros(silence_samples)
+    
+    # Add trailing silence to prevent end cutoff
+    trailing_silence_samples = int(sample_rate * actual_trailing_silence)
+    trailing_silence = np.zeros(trailing_silence_samples)
+    
+    # Combine: leading silence + chime + trailing silence
+    chime_with_buffer = np.concatenate([silence, chime, trailing_silence])
+    
     # Convert to 16-bit integer
-    chime_int16 = (chime * 32767).astype(np.int16)
+    chime_int16 = (chime_with_buffer * 32767).astype(np.int16)
     
     return chime_int16
 
 
-async def play_chime_start(sample_rate: int = SAMPLE_RATE) -> bool:
+async def play_chime_start(
+    sample_rate: int = SAMPLE_RATE,
+    leading_silence: Optional[float] = None,
+    trailing_silence: Optional[float] = None
+) -> bool:
     """Play the recording start chime (ascending tones).
     
+    Args:
+        sample_rate: Sample rate for audio
+        leading_silence: Optional override for leading silence duration (seconds)
+        trailing_silence: Optional override for trailing silence duration (seconds)
+    
     Returns:
         True if chime played successfully, False otherwise
     """
     try:
         import sounddevice as sd
-        chime = generate_chime([800, 1000], duration=0.1, sample_rate=sample_rate)
+        chime = generate_chime(
+            [800, 1000], 
+            duration=0.1, 
+            sample_rate=sample_rate,
+            leading_silence=leading_silence,
+            trailing_silence=trailing_silence
+        )
         sd.play(chime, sample_rate)
         sd.wait()
         return True
@@ -563,15 +624,30 @@ async def play_chime_start(sample_rate: int = SAMPLE_RATE) -> bool:
         return False
 
 
-async def play_chime_end(sample_rate: int = SAMPLE_RATE) -> bool:
+async def play_chime_end(
+    sample_rate: int = SAMPLE_RATE,
+    leading_silence: Optional[float] = None,
+    trailing_silence: Optional[float] = None
+) -> bool:
     """Play the recording end chime (descending tones).
     
+    Args:
+        sample_rate: Sample rate for audio
+        leading_silence: Optional override for leading silence duration (seconds)
+        trailing_silence: Optional override for trailing silence duration (seconds)
+    
     Returns:
         True if chime played successfully, False otherwise
     """
     try:
         import sounddevice as sd
-        chime = generate_chime([1000, 800], duration=0.1, sample_rate=sample_rate)
+        chime = generate_chime(
+            [1000, 800], 
+            duration=0.1, 
+            sample_rate=sample_rate,
+            leading_silence=leading_silence,
+            trailing_silence=trailing_silence
+        )
         sd.play(chime, sample_rate)
         sd.wait()
         return True

{voice_mode-2.28.0 → voice_mode-2.28.2}/voice_mode/tools/converse.py

@@ -784,7 +784,9 @@ async def play_audio_feedback(
     style: str = "whisper", 
     feedback_type: Optional[str] = None,
     voice: str = "nova",
-    model: str = "gpt-4o-mini-tts"
+    model: str = "gpt-4o-mini-tts",
+    pip_leading_silence: Optional[float] = None,
+    pip_trailing_silence: Optional[float] = None
 ) -> None:
     """Play an audio feedback chime
     
@@ -796,6 +798,8 @@ async def play_audio_feedback(
         feedback_type: Kept for compatibility, not used
         voice: Kept for compatibility, not used
         model: Kept for compatibility, not used
+        pip_leading_silence: Optional override for leading silence duration
+        pip_trailing_silence: Optional override for trailing silence duration
     """
     # Use parameter override if provided, otherwise use global setting
     if enabled is False:
@@ -810,11 +814,17 @@ async def play_audio_feedback(
         return
     
     try:
-        # Play appropriate chime
+        # Play appropriate chime with optional delay overrides
         if text == "listening":
-            await play_chime_start()
+            await play_chime_start(
+                leading_silence=pip_leading_silence,
+                trailing_silence=pip_trailing_silence
+            )
         elif text == "finished":
-            await play_chime_end()
+            await play_chime_end(
+                leading_silence=pip_leading_silence,
+                trailing_silence=pip_trailing_silence
+            )
     except Exception as e:
         logger.debug(f"Audio feedback failed: {e}")
         # Don't interrupt the main flow if feedback fails
@@ -1314,7 +1324,9 @@ async def converse(
     disable_silence_detection: Union[bool, str] = False,
     speed: Optional[float] = None,
     vad_aggressiveness: Optional[int] = None,
-    skip_tts: Optional[Union[bool, str]] = None
+    skip_tts: Optional[Union[bool, str]] = None,
+    pip_leading_silence: Optional[float] = None,
+    pip_trailing_silence: Optional[float] = None
 ) -> str:
     """Have a voice conversation - speak a message and optionally listen for response.
     
@@ -1391,6 +1403,10 @@ async def converse(
                   When False: Always use TTS regardless of environment setting
                   When None: Follow VOICEMODE_SKIP_TTS environment variable
                   Useful for rapid development iterations or when voice isn't needed
+        pip_leading_silence: Override leading silence before chimes (default: None uses VOICEMODE_PIP_LEADING_SILENCE env var)
+                             Time in seconds to add before the chime starts (e.g., 1.0 for Bluetooth devices)
+        pip_trailing_silence: Override trailing silence after chimes (default: None uses VOICEMODE_PIP_TRAILING_SILENCE env var)
+                              Time in seconds to add after the chime ends (e.g., 0.5 to prevent cutoff)
         If wait_for_response is False: Confirmation that message was spoken
         If wait_for_response is True: The voice response received (or error/timeout message)
     
@@ -1797,7 +1813,14 @@ async def converse(
                     await asyncio.sleep(0.5)
                     
                     # Play "listening" feedback sound
-                    await play_audio_feedback("listening", openai_clients, audio_feedback, audio_feedback_style or "whisper")
+                    await play_audio_feedback(
+                        "listening", 
+                        openai_clients, 
+                        audio_feedback, 
+                        audio_feedback_style or "whisper",
+                        pip_leading_silence=pip_leading_silence,
+                        pip_trailing_silence=pip_trailing_silence
+                    )
                     
                     # Record response
                     logger.info(f"🎤 Listening for {listen_duration} seconds...")
@@ -1821,7 +1844,14 @@ async def converse(
                         })
                     
                     # Play "finished" feedback sound
-                    await play_audio_feedback("finished", openai_clients, audio_feedback, audio_feedback_style or "whisper")
+                    await play_audio_feedback(
+                        "finished", 
+                        openai_clients, 
+                        audio_feedback, 
+                        audio_feedback_style or "whisper",
+                        pip_leading_silence=pip_leading_silence,
+                        pip_trailing_silence=pip_trailing_silence
+                    )
                     
                     # Mark the end of recording - this is when user expects response to start
                     user_done_time = time.perf_counter()

{voice_mode-2.28.0 → voice_mode-2.28.2}/voice_mode/tools/services/whisper/install.py

@@ -217,7 +217,8 @@ async def whisper_install(
             # On Apple Silicon, also enable Core ML for better performance
             if platform.machine() == "arm64":
                 cmake_flags.append("-DWHISPER_COREML=ON")
-                logger.info("Enabling Core ML support for Apple Silicon")
+                cmake_flags.append("-DWHISPER_COREML_ALLOW_FALLBACK=ON")
+                logger.info("Enabling Core ML support with fallback for Apple Silicon")
         elif is_linux and use_gpu:
             cmake_flags.append("-DGGML_CUDA=ON")