voice-mode 2.23.0__tar.gz → 2.25.0__tar.gz

{voice_mode-2.23.0 → voice_mode-2.25.0}/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.25.0] - 2025-08-18
+
+### Fixed
+- **uvx command refresh flag** - Add --refresh flag to all uvx commands in installer
+  - Ensures latest version is always fetched when running voice-mode commands
+  - Fixes issues with cached old versions being used
+  - Applies to service installation, uninstallation, and status commands
+- **Performance optimization** - Significantly improved help command performance
+  - Lazy load heavy imports (numpy, scipy, webrtcvad) only when needed
+  - Help command now runs 10x faster (from ~1.5s to ~0.15s)
+  - Faster MCP server startup time for better user experience
+- **Config path expansion** - Fixed tilde expansion for user home directories
+  - Configuration paths now properly expand `~` to user home directory
+  - Fixes issues with paths like `~/Models/kokoro` not being found
+  - Added comprehensive tests for path expansion functionality
+- **Frontend imports** - Corrected import statements to use single module
+  - Fixed import errors in livekit frontend commands
+  - All frontend commands now properly import from frontend module
+
+## [2.24.0] - 2025-08-16
+
+### Added
+- **Enhanced Voice Activity Detection** - Improved silence detection behavior
+  - VAD now waits indefinitely for speech before starting silence detection
+  - No more timeouts when user hasn't started speaking yet
+  - Silent recordings are not sent to STT, reducing API costs and preventing hallucinations
+  - Returns "No speech detected" message instead of processing silence
+  - Significantly improves user experience for voice interactions
+- **VAD debugging mode** - Comprehensive debugging for Voice Activity Detection
+  - New `VOICEMODE_VAD_DEBUG` environment variable enables detailed VAD logging
+  - Shows real-time speech detection decisions, state transitions, and timing
+  - Helps diagnose issues where recording stops before speech or cuts off early
+  - Added test script `scripts/test-vad-enhancement.py` for VAD testing
+  - Documented in `docs/vad-debugging.md` with common issues and solutions
+
 ## [2.23.0] - 2025-08-16
 
 ### Added
@@ -29,8 +64,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [2.22.3] - 2025-08-16
 
-## [2.23.0] - 2025-08-16
-
 ### Fixed
 - **Service auto-enable error** - Fix 'FunctionTool' object is not callable
   - Changed whisper and kokoro installers to use `enable_service` function instead of MCP tool

{voice_mode-2.23.0 → voice_mode-2.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-mode
-Version: 2.23.0
+Version: 2.25.0
 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.23.0 → voice_mode-2.25.0}/voice_mode/__version__.py

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

{voice_mode-2.23.0 → voice_mode-2.25.0}/voice_mode/cli.py

@@ -6,7 +6,6 @@ import sys
 import os
 import warnings
 import click
-from .server import main as voice_mode_main
 
 # Suppress known deprecation warnings for better user experience
 # These apply to both CLI commands and MCP server operation
@@ -47,6 +46,7 @@ def voice_mode_main_cli(ctx, debug):
     if ctx.invoked_subcommand is None:
         # No subcommand - run MCP server
         # Note: warnings are already suppressed at module level unless debug is enabled
+        from .server import main as voice_mode_main
         voice_mode_main()
 
 
@@ -74,36 +74,14 @@ def livekit():
     pass
 
 
-# Import service functions
-from voice_mode.tools.service import (
-    status_service, start_service, stop_service, restart_service,
-    enable_service, disable_service, view_logs, update_service_files
-)
-
-# Import install/uninstall functions
-from voice_mode.tools.services.kokoro.install import kokoro_install
-from voice_mode.tools.services.kokoro.uninstall import kokoro_uninstall
-from voice_mode.tools.services.whisper.install import whisper_install
-from voice_mode.tools.services.whisper.uninstall import whisper_uninstall
-from voice_mode.tools.services.whisper.download_model import download_model
-from voice_mode.tools.services.livekit.install import livekit_install
-from voice_mode.tools.services.livekit.uninstall import livekit_uninstall
-from voice_mode.tools.services.livekit.frontend import livekit_frontend_start, livekit_frontend_stop, livekit_frontend_status, livekit_frontend_open, livekit_frontend_logs, livekit_frontend_install
-
-# Import configuration management functions
-from voice_mode.tools.configuration_management import update_config, list_config_keys
-
-# Import diagnostic functions - extract the actual async functions from the tools
-from voice_mode.tools.diagnostics import voice_mode_info
-from voice_mode.tools.devices import check_audio_devices
-from voice_mode.tools.voice_registry import voice_registry
-from voice_mode.tools.dependencies import check_audio_dependencies
+# Service functions are imported lazily in their respective command handlers to improve startup time
 
 
 # Kokoro service commands
 @kokoro.command()
 def status():
     """Show Kokoro service status."""
+    from voice_mode.tools.service import status_service
     result = asyncio.run(status_service("kokoro"))
     click.echo(result)
 
@@ -111,6 +89,7 @@ def status():
 @kokoro.command()
 def start():
     """Start Kokoro service."""
+    from voice_mode.tools.service import start_service
     result = asyncio.run(start_service("kokoro"))
     click.echo(result)
 
@@ -118,6 +97,7 @@ def start():
 @kokoro.command()
 def stop():
     """Stop Kokoro service."""
+    from voice_mode.tools.service import stop_service
     result = asyncio.run(stop_service("kokoro"))
     click.echo(result)
 
@@ -125,6 +105,7 @@ def stop():
 @kokoro.command()
 def restart():
     """Restart Kokoro service."""
+    from voice_mode.tools.service import restart_service
     result = asyncio.run(restart_service("kokoro"))
     click.echo(result)
 
@@ -132,6 +113,7 @@ def restart():
 @kokoro.command()
 def enable():
     """Enable Kokoro service to start at boot/login."""
+    from voice_mode.tools.service import enable_service
     result = asyncio.run(enable_service("kokoro"))
     click.echo(result)
 
@@ -139,6 +121,7 @@ def enable():
 @kokoro.command()
 def disable():
     """Disable Kokoro service from starting at boot/login."""
+    from voice_mode.tools.service import disable_service
     result = asyncio.run(disable_service("kokoro"))
     click.echo(result)
 
@@ -147,6 +130,7 @@ def disable():
 @click.option('--lines', '-n', default=50, help='Number of log lines to show')
 def logs(lines):
     """View Kokoro service logs."""
+    from voice_mode.tools.service import view_logs
     result = asyncio.run(view_logs("kokoro", lines))
     click.echo(result)
 
@@ -154,6 +138,7 @@ def logs(lines):
 @kokoro.command("update-service-files")
 def kokoro_update_service_files():
     """Update Kokoro service files to latest version."""
+    from voice_mode.tools.service import update_service_files
     result = asyncio.run(update_service_files("kokoro"))
     click.echo(result)
 
@@ -193,6 +178,7 @@ def health():
 @click.option('--auto-enable/--no-auto-enable', default=None, help='Enable service at boot/login')
 def install(install_dir, port, force, version, auto_enable):
     """Install kokoro-fastapi TTS service."""
+    from voice_mode.tools.services.kokoro.install import kokoro_install
     result = asyncio.run(kokoro_install.fn(
         install_dir=install_dir,
         port=port,
@@ -227,6 +213,7 @@ def install(install_dir, port, force, version, auto_enable):
 @click.confirmation_option(prompt='Are you sure you want to uninstall Kokoro?')
 def uninstall(remove_models, remove_all_data):
     """Uninstall kokoro-fastapi service and optionally remove data."""
+    from voice_mode.tools.services.kokoro.uninstall import kokoro_uninstall
     result = asyncio.run(kokoro_uninstall.fn(
         remove_models=remove_models,
         remove_all_data=remove_all_data
@@ -260,6 +247,7 @@ def uninstall(remove_models, remove_all_data):
 @whisper.command()
 def status():
     """Show Whisper service status."""
+    from voice_mode.tools.service import status_service
     result = asyncio.run(status_service("whisper"))
     click.echo(result)
 
@@ -267,6 +255,7 @@ def status():
 @whisper.command()
 def start():
     """Start Whisper service."""
+    from voice_mode.tools.service import start_service
     result = asyncio.run(start_service("whisper"))
     click.echo(result)
 
@@ -274,6 +263,7 @@ def start():
 @whisper.command()
 def stop():
     """Stop Whisper service."""
+    from voice_mode.tools.service import stop_service
     result = asyncio.run(stop_service("whisper"))
     click.echo(result)
 
@@ -281,6 +271,7 @@ def stop():
 @whisper.command()
 def restart():
     """Restart Whisper service."""
+    from voice_mode.tools.service import restart_service
     result = asyncio.run(restart_service("whisper"))
     click.echo(result)
 
@@ -288,6 +279,7 @@ def restart():
 @whisper.command()
 def enable():
     """Enable Whisper service to start at boot/login."""
+    from voice_mode.tools.service import enable_service
     result = asyncio.run(enable_service("whisper"))
     click.echo(result)
 
@@ -295,6 +287,7 @@ def enable():
 @whisper.command()
 def disable():
     """Disable Whisper service from starting at boot/login."""
+    from voice_mode.tools.service import disable_service
     result = asyncio.run(disable_service("whisper"))
     click.echo(result)
 
@@ -303,6 +296,7 @@ def disable():
 @click.option('--lines', '-n', default=50, help='Number of log lines to show')
 def logs(lines):
     """View Whisper service logs."""
+    from voice_mode.tools.service import view_logs
     result = asyncio.run(view_logs("whisper", lines))
     click.echo(result)
 
@@ -310,6 +304,7 @@ def logs(lines):
 @whisper.command("update-service-files")
 def whisper_update_service_files():
     """Update Whisper service files to latest version."""
+    from voice_mode.tools.service import update_service_files
     result = asyncio.run(update_service_files("whisper"))
     click.echo(result)
 
@@ -350,6 +345,7 @@ def health():
 @click.option('--auto-enable/--no-auto-enable', default=None, help='Enable service at boot/login')
 def install(install_dir, model, use_gpu, force, version, auto_enable):
     """Install whisper.cpp STT service with automatic system detection."""
+    from voice_mode.tools.services.whisper.install import whisper_install
     result = asyncio.run(whisper_install.fn(
         install_dir=install_dir,
         model=model,
@@ -394,6 +390,7 @@ def install(install_dir, model, use_gpu, force, version, auto_enable):
 @click.confirmation_option(prompt='Are you sure you want to uninstall Whisper?')
 def uninstall(remove_models, remove_all_data):
     """Uninstall whisper.cpp and optionally remove models and data."""
+    from voice_mode.tools.services.whisper.uninstall import whisper_uninstall
     result = asyncio.run(whisper_uninstall.fn(
         remove_models=remove_models,
         remove_all_data=remove_all_data
@@ -437,6 +434,7 @@ def download_model_cmd(model, force, skip_core_ml):
     medium, medium.en, large-v1, large-v2, large-v3, large-v3-turbo
     """
     import json
+    from voice_mode.tools.services.whisper.download_model import download_model
     result = asyncio.run(download_model.fn(
         model=model,
         force_download=force,
@@ -478,6 +476,7 @@ def download_model_cmd(model, force, skip_core_ml):
 @livekit.command()
 def status():
     """Show LiveKit service status."""
+    from voice_mode.tools.service import status_service
     result = asyncio.run(status_service("livekit"))
     click.echo(result)
 
@@ -485,6 +484,7 @@ def status():
 @livekit.command()
 def start():
     """Start LiveKit service."""
+    from voice_mode.tools.service import start_service
     result = asyncio.run(start_service("livekit"))
     click.echo(result)
 
@@ -492,6 +492,7 @@ def start():
 @livekit.command()
 def stop():
     """Stop LiveKit service."""
+    from voice_mode.tools.service import stop_service
     result = asyncio.run(stop_service("livekit"))
     click.echo(result)
 
@@ -499,6 +500,7 @@ def stop():
 @livekit.command()
 def restart():
     """Restart LiveKit service."""
+    from voice_mode.tools.service import restart_service
     result = asyncio.run(restart_service("livekit"))
     click.echo(result)
 
@@ -506,6 +508,7 @@ def restart():
 @livekit.command()
 def enable():
     """Enable LiveKit service to start at boot/login."""
+    from voice_mode.tools.service import enable_service
     result = asyncio.run(enable_service("livekit"))
     click.echo(result)
 
@@ -513,6 +516,7 @@ def enable():
 @livekit.command()
 def disable():
     """Disable LiveKit service from starting at boot/login."""
+    from voice_mode.tools.service import disable_service
     result = asyncio.run(disable_service("livekit"))
     click.echo(result)
 
@@ -521,6 +525,7 @@ def disable():
 @click.option('--lines', '-n', default=50, help='Number of log lines to show')
 def logs(lines):
     """View LiveKit service logs."""
+    from voice_mode.tools.service import view_logs
     result = asyncio.run(view_logs("livekit", lines))
     click.echo(result)
 
@@ -528,6 +533,7 @@ def logs(lines):
 @livekit.command()
 def update():
     """Update LiveKit service files to the latest version."""
+    from voice_mode.tools.service import update_service_files
     result = asyncio.run(update_service_files("livekit"))
     
     if result.get("success"):
@@ -546,6 +552,7 @@ def update():
 @click.option('--auto-enable/--no-auto-enable', default=None, help='Enable service at boot/login')
 def install(install_dir, port, force, version, auto_enable):
     """Install LiveKit server with development configuration."""
+    from voice_mode.tools.services.livekit.install import livekit_install
     result = asyncio.run(livekit_install.fn(
         install_dir=install_dir,
         port=port,
@@ -583,6 +590,7 @@ def install(install_dir, port, force, version, auto_enable):
 @click.confirmation_option(prompt='Are you sure you want to uninstall LiveKit?')
 def uninstall(remove_config, remove_all_data):
     """Uninstall LiveKit server and optionally remove configuration and data."""
+    from voice_mode.tools.services.livekit.uninstall import livekit_uninstall
     result = asyncio.run(livekit_uninstall.fn(
         remove_config=remove_config,
         remove_all_data=remove_all_data
@@ -615,6 +623,7 @@ def frontend():
 @click.option('--auto-enable/--no-auto-enable', default=None, help='Enable service after installation (default: from config)')
 def frontend_install(auto_enable):
     """Install and setup LiveKit Voice Assistant Frontend."""
+    from voice_mode.tools.services.livekit.frontend import livekit_frontend_install
     result = asyncio.run(livekit_frontend_install.fn(auto_enable=auto_enable))
     
     if result.get('success'):
@@ -642,6 +651,7 @@ def frontend_install(auto_enable):
 @click.option('--host', default='127.0.0.1', help='Host to bind to (default: 127.0.0.1)')
 def frontend_start(port, host):
     """Start the LiveKit Voice Assistant Frontend."""
+    from voice_mode.tools.services.livekit.frontend import livekit_frontend_start
     result = asyncio.run(livekit_frontend_start.fn(port=port, host=host))
     
     if result.get('success'):
@@ -663,6 +673,7 @@ def frontend_start(port, host):
 @frontend.command("stop")
 def frontend_stop():
     """Stop the LiveKit Voice Assistant Frontend."""
+    from voice_mode.tools.services.livekit.frontend import livekit_frontend_stop
     result = asyncio.run(livekit_frontend_stop.fn())
     
     if result.get('success'):
@@ -674,6 +685,7 @@ def frontend_stop():
 @frontend.command("status")
 def frontend_status():
     """Check status of the LiveKit Voice Assistant Frontend."""
+    from voice_mode.tools.services.livekit.frontend import livekit_frontend_status
     result = asyncio.run(livekit_frontend_status.fn())
     
     if 'error' in result:
@@ -701,6 +713,7 @@ def frontend_open():
     
     Starts the frontend if not already running, then opens it in the default browser.
     """
+    from voice_mode.tools.services.livekit.frontend import livekit_frontend_open
     result = asyncio.run(livekit_frontend_open.fn())
     
     if result.get('success'):
@@ -723,11 +736,13 @@ def frontend_logs(lines, follow):
     """
     if follow:
         # For following, run tail -f directly
+        from voice_mode.tools.services.livekit.frontend import livekit_frontend_logs
         result = asyncio.run(livekit_frontend_logs.fn(follow=True))
         if result.get('success'):
             click.echo(f"📂 Log file: {result['log_file']}")
             click.echo("🔄 Following logs (press Ctrl+C to stop)...")
             try:
+                import subprocess
                 subprocess.run(["tail", "-f", result['log_file']])
             except KeyboardInterrupt:
                 click.echo("\n✅ Stopped following logs")
@@ -735,6 +750,7 @@ def frontend_logs(lines, follow):
             click.echo(f"❌ Error: {result.get('error', 'Unknown error')}")
     else:
         # Show last N lines
+        from voice_mode.tools.services.livekit.frontend import livekit_frontend_logs
         result = asyncio.run(livekit_frontend_logs.fn(lines=lines, follow=False))
         if result.get('success'):
             click.echo(f"📂 Log file: {result['log_file']}")
@@ -748,6 +764,7 @@ def frontend_logs(lines, follow):
 @frontend.command("enable")
 def frontend_enable():
     """Enable frontend service to start automatically at boot/login."""
+    from voice_mode.tools.service import enable_service
     result = asyncio.run(enable_service("frontend"))
     # enable_service returns a string, not a dict
     click.echo(result)
@@ -756,6 +773,7 @@ def frontend_enable():
 @frontend.command("disable")
 def frontend_disable():
     """Disable frontend service from starting automatically."""
+    from voice_mode.tools.service import disable_service
     result = asyncio.run(disable_service("frontend"))
     # disable_service returns a string, not a dict
     click.echo(result)
@@ -827,6 +845,7 @@ def config():
 @config.command("list")
 def config_list():
     """List all configuration keys with their descriptions."""
+    from voice_mode.tools.configuration_management import list_config_keys
     result = asyncio.run(list_config_keys.fn())
     click.echo(result)
 
@@ -873,6 +892,7 @@ def config_get(key):
 @click.argument('value')
 def config_set(key, value):
     """Set a configuration value."""
+    from voice_mode.tools.configuration_management import update_config
     result = asyncio.run(update_config.fn(key, value))
     click.echo(result)
 
@@ -887,6 +907,7 @@ def diag():
 @diag.command()
 def info():
     """Show voice-mode installation information."""
+    from voice_mode.tools.diagnostics import voice_mode_info
     result = asyncio.run(voice_mode_info.fn())
     click.echo(result)
 
@@ -894,6 +915,7 @@ def info():
 @diag.command()
 def devices():
     """List available audio input and output devices."""
+    from voice_mode.tools.devices import check_audio_devices
     result = asyncio.run(check_audio_devices.fn())
     click.echo(result)
 
@@ -901,6 +923,7 @@ def devices():
 @diag.command()
 def registry():
     """Show voice provider registry with all discovered endpoints."""
+    from voice_mode.tools.voice_registry import voice_registry
     result = asyncio.run(voice_registry.fn())
     click.echo(result)
 
@@ -909,6 +932,7 @@ def registry():
 def dependencies():
     """Check system audio dependencies and provide installation guidance."""
     import json
+    from voice_mode.tools.dependencies import check_audio_dependencies
     result = asyncio.run(check_audio_dependencies.fn())
     
     if isinstance(result, dict):

{voice_mode-2.23.0 → voice_mode-2.25.0}/voice_mode/config.py

@@ -149,19 +149,29 @@ def env_bool(env_var: str, default: bool = False) -> bool:
     value = os.getenv(env_var, "").lower()
     return value in ("true", "1", "yes", "on") if value else default
 
+# Helper function to expand paths with tilde
+def expand_path(path_str: str) -> Path:
+    """Expand tilde and environment variables in path strings."""
+    # First expand any environment variables
+    expanded = os.path.expandvars(path_str)
+    # Then expand tilde
+    expanded = os.path.expanduser(expanded)
+    return Path(expanded)
+
 # Base directory for all voicemode data
-BASE_DIR = Path(os.getenv("VOICEMODE_BASE_DIR", str(Path.home() / ".voicemode")))
+BASE_DIR = expand_path(os.getenv("VOICEMODE_BASE_DIR", str(Path.home() / ".voicemode")))
 
 # Unified directory structure
 AUDIO_DIR = BASE_DIR / "audio"
 TRANSCRIPTIONS_DIR = BASE_DIR / "transcriptions"
 LOGS_DIR = BASE_DIR / "logs"
 # CONFIG_DIR = BASE_DIR / "config"  # Removed - config stored in .voicemode.env file instead
-MODELS_DIR = Path(os.getenv("VOICEMODE_MODELS_DIR", str(BASE_DIR / "models")))
+MODELS_DIR = expand_path(os.getenv("VOICEMODE_MODELS_DIR", str(BASE_DIR / "models")))
 
 # Debug configuration
 DEBUG = os.getenv("VOICEMODE_DEBUG", "").lower() in ("true", "1", "yes", "on")
 TRACE_DEBUG = os.getenv("VOICEMODE_DEBUG", "").lower() == "trace"
+VAD_DEBUG = os.getenv("VOICEMODE_VAD_DEBUG", "").lower() in ("true", "1", "yes", "on")
 DEBUG_DIR = LOGS_DIR / "debug"  # Debug files now go under logs
 
 # Master save-all configuration
@@ -224,14 +234,14 @@ LIVEKIT_API_SECRET = os.getenv("LIVEKIT_API_SECRET", "secret")
 WHISPER_MODEL = os.getenv("VOICEMODE_WHISPER_MODEL", "large-v2")
 WHISPER_PORT = int(os.getenv("VOICEMODE_WHISPER_PORT", "2022"))
 WHISPER_LANGUAGE = os.getenv("VOICEMODE_WHISPER_LANGUAGE", "auto")
-WHISPER_MODEL_PATH = os.getenv("VOICEMODE_WHISPER_MODEL_PATH", str(BASE_DIR / "models" / "whisper"))
+WHISPER_MODEL_PATH = expand_path(os.getenv("VOICEMODE_WHISPER_MODEL_PATH", str(BASE_DIR / "models" / "whisper")))
 
 # ==================== KOKORO CONFIGURATION ====================
 
 # Kokoro-specific configuration
 KOKORO_PORT = int(os.getenv("VOICEMODE_KOKORO_PORT", "8880"))
-KOKORO_MODELS_DIR = os.getenv("VOICEMODE_KOKORO_MODELS_DIR", str(BASE_DIR / "models" / "kokoro"))
-KOKORO_CACHE_DIR = os.getenv("VOICEMODE_KOKORO_CACHE_DIR", str(BASE_DIR / "cache" / "kokoro"))
+KOKORO_MODELS_DIR = expand_path(os.getenv("VOICEMODE_KOKORO_MODELS_DIR", str(BASE_DIR / "models" / "kokoro")))
+KOKORO_CACHE_DIR = expand_path(os.getenv("VOICEMODE_KOKORO_CACHE_DIR", str(BASE_DIR / "cache" / "kokoro")))
 KOKORO_DEFAULT_VOICE = os.getenv("VOICEMODE_KOKORO_DEFAULT_VOICE", "af_sky")
 
 # ==================== LIVEKIT CONFIGURATION ====================

{voice_mode-2.23.0 → voice_mode-2.25.0}/voice_mode/tools/converse.py

@@ -32,6 +32,7 @@ from voice_mode.config import (
     CHANNELS,
     DEBUG,
     DEBUG_DIR,
+    VAD_DEBUG,
     SAVE_AUDIO,
     AUDIO_DIR,
     OPENAI_API_KEY,
@@ -872,7 +873,7 @@ def record_audio(duration: float) -> np.ndarray:
             sys.stderr = original_stderr
 
 
-def record_audio_with_silence_detection(max_duration: float, disable_silence_detection: bool = False, min_duration: float = 0.0, vad_aggressiveness: Optional[int] = None) -> np.ndarray:
+def record_audio_with_silence_detection(max_duration: float, disable_silence_detection: bool = False, min_duration: float = 0.0, vad_aggressiveness: Optional[int] = None) -> Tuple[np.ndarray, bool]:
     """Record audio from microphone with automatic silence detection.
     
     Uses WebRTC VAD to detect when the user stops speaking and automatically
@@ -885,21 +886,25 @@ def record_audio_with_silence_detection(max_duration: float, disable_silence_det
         vad_aggressiveness: VAD aggressiveness level (0-3). If None, uses VAD_AGGRESSIVENESS from config
         
     Returns:
-        Numpy array of recorded audio samples
+        Tuple of (audio_data, speech_detected):
+            - audio_data: Numpy array of recorded audio samples
+            - speech_detected: Boolean indicating if speech was detected during recording
     """
     
     logger.info(f"record_audio_with_silence_detection called - VAD_AVAILABLE={VAD_AVAILABLE}, DISABLE_SILENCE_DETECTION={DISABLE_SILENCE_DETECTION}, min_duration={min_duration}")
     
     if not VAD_AVAILABLE:
         logger.warning("webrtcvad not available, falling back to fixed duration recording")
-        return record_audio(max_duration)
+        # For fallback, assume speech is present since we can't detect
+        return (record_audio(max_duration), True)
     
     if DISABLE_SILENCE_DETECTION or disable_silence_detection:
         if disable_silence_detection:
             logger.info("Silence detection disabled for this interaction by request")
         else:
             logger.info("Silence detection disabled globally via VOICEMODE_DISABLE_SILENCE_DETECTION")
-        return record_audio(max_duration)
+        # For fallback, assume speech is present since we can't detect
+        return (record_audio(max_duration), True)
     
     logger.info(f"🎤 Recording with silence detection (max {max_duration}s)...")
     
@@ -940,6 +945,16 @@ def record_audio_with_silence_detection(max_duration: float, disable_silence_det
                     f"Min duration: {MIN_RECORDING_DURATION}s, "
                     f"Initial grace period: {INITIAL_SILENCE_GRACE_PERIOD}s")
         
+        if VAD_DEBUG:
+            logger.info(f"[VAD_DEBUG] Starting VAD recording with config:")
+            logger.info(f"[VAD_DEBUG]   max_duration: {max_duration}s")
+            logger.info(f"[VAD_DEBUG]   min_duration: {min_duration}s")
+            logger.info(f"[VAD_DEBUG]   effective_min_duration: {max(MIN_RECORDING_DURATION, min_duration)}s")
+            logger.info(f"[VAD_DEBUG]   VAD aggressiveness: {effective_vad_aggressiveness}")
+            logger.info(f"[VAD_DEBUG]   Silence threshold: {SILENCE_THRESHOLD_MS}ms")
+            logger.info(f"[VAD_DEBUG]   Sample rate: {SAMPLE_RATE}Hz (VAD using {vad_sample_rate}Hz)")
+            logger.info(f"[VAD_DEBUG]   Chunk duration: {VAD_CHUNK_DURATION_MS}ms")
+        
         def audio_callback(indata, frames, time, status):
             """Callback for continuous audio stream"""
             if status:
@@ -979,35 +994,53 @@ def record_audio_with_silence_detection(max_duration: float, disable_silence_det
                         # Check if chunk contains speech
                         try:
                             is_speech = vad.is_speech(chunk_bytes, vad_sample_rate)
+                            if VAD_DEBUG:
+                                # Log VAD decision every 500ms for less spam
+                                if int(recording_duration * 1000) % 500 == 0:
+                                    rms = np.sqrt(np.mean(chunk.astype(float)**2))
+                                    logger.info(f"[VAD_DEBUG] t={recording_duration:.1f}s: speech={is_speech}, RMS={rms:.0f}, state={'WAITING' if not speech_detected else 'ACTIVE'}")
                         except Exception as vad_e:
                             logger.warning(f"VAD error: {vad_e}, treating as speech")
                             is_speech = True
                         
-                        if is_speech:
-                            if not speech_detected:
-                                logger.debug("Speech detected, recording...")
-                            speech_detected = True
-                            silence_duration_ms = 0
+                        # State machine for speech detection
+                        if not speech_detected:
+                            # WAITING_FOR_SPEECH state
+                            if is_speech:
+                                logger.info("🎤 Speech detected, starting active recording")
+                                if VAD_DEBUG:
+                                    logger.info(f"[VAD_DEBUG] STATE CHANGE: WAITING_FOR_SPEECH -> SPEECH_ACTIVE at t={recording_duration:.1f}s")
+                                speech_detected = True
+                                silence_duration_ms = 0
+                            # No timeout in this state - just keep waiting
+                            # The only exit is speech detection or max_duration
                         else:
-                            silence_duration_ms += VAD_CHUNK_DURATION_MS
-                            if speech_detected and silence_duration_ms % 200 == 0:  # Log every 200ms
-                                logger.debug(f"Silence: {silence_duration_ms}ms")
+                            # We have detected speech at some point
+                            if is_speech:
+                                # SPEECH_ACTIVE state - reset silence counter
+                                silence_duration_ms = 0
+                            else:
+                                # SILENCE_AFTER_SPEECH state - accumulate silence
+                                silence_duration_ms += VAD_CHUNK_DURATION_MS
+                                if VAD_DEBUG and silence_duration_ms % 100 == 0:  # More frequent logging in debug mode
+                                    logger.info(f"[VAD_DEBUG] Accumulating silence: {silence_duration_ms}/{SILENCE_THRESHOLD_MS}ms, t={recording_duration:.1f}s")
+                                elif silence_duration_ms % 200 == 0:  # Log every 200ms
+                                    logger.debug(f"Silence: {silence_duration_ms}ms")
+                                
+                                # Check if we should stop due to silence threshold
+                                # Use the larger of MIN_RECORDING_DURATION (global) or min_duration (parameter)
+                                effective_min_duration = max(MIN_RECORDING_DURATION, min_duration)
+                                if recording_duration >= effective_min_duration and silence_duration_ms >= SILENCE_THRESHOLD_MS:
+                                    logger.info(f"✓ Silence threshold reached after {recording_duration:.1f}s of recording")
+                                    if VAD_DEBUG:
+                                        logger.info(f"[VAD_DEBUG] STOP: silence_duration={silence_duration_ms}ms >= threshold={SILENCE_THRESHOLD_MS}ms")
+                                        logger.info(f"[VAD_DEBUG] STOP: recording_duration={recording_duration:.1f}s >= min_duration={effective_min_duration}s")
+                                    stop_recording = True
+                                elif VAD_DEBUG and recording_duration < effective_min_duration:
+                                    if int(recording_duration * 1000) % 500 == 0:  # Log every 500ms
+                                        logger.info(f"[VAD_DEBUG] Min duration not met: {recording_duration:.1f}s < {effective_min_duration}s")
                         
                         recording_duration += chunk_duration_s
-                        
-                        # Check stop conditions
-                        # Use the larger of MIN_RECORDING_DURATION (global) or min_duration (parameter)
-                        effective_min_duration = max(MIN_RECORDING_DURATION, min_duration)
-                        if speech_detected and recording_duration >= effective_min_duration:
-                            if silence_duration_ms >= SILENCE_THRESHOLD_MS:
-                                logger.info(f"✓ Silence detected after {recording_duration:.1f}s (min: {effective_min_duration:.1f}s), stopping recording")
-                                stop_recording = True
-                        
-                        # Also stop if we haven't detected any speech after a grace period
-                        # Give user time to start speaking
-                        if not speech_detected and recording_duration >= INITIAL_SILENCE_GRACE_PERIOD:
-                            logger.info(f"No speech detected after {INITIAL_SILENCE_GRACE_PERIOD}s grace period, stopping recording")
-                            stop_recording = True
                             
                     except queue.Empty:
                         # No audio data available, continue waiting
@@ -1019,17 +1052,26 @@ def record_audio_with_silence_detection(max_duration: float, disable_silence_det
             # Concatenate all chunks
             if chunks:
                 full_recording = np.concatenate(chunks)
-                logger.info(f"✓ Recorded {len(full_recording)} samples ({recording_duration:.1f}s)")
+                
+                if not speech_detected:
+                    logger.info(f"✓ Recording completed ({recording_duration:.1f}s) - No speech detected")
+                    if VAD_DEBUG:
+                        logger.info(f"[VAD_DEBUG] FINAL STATE: No speech was ever detected during recording")
+                else:
+                    logger.info(f"✓ Recorded {len(full_recording)} samples ({recording_duration:.1f}s) with speech")
+                    if VAD_DEBUG:
+                        logger.info(f"[VAD_DEBUG] FINAL STATE: Speech was detected, recording complete")
                 
                 if DEBUG:
                     # Calculate RMS for debug
                     rms = np.sqrt(np.mean(full_recording.astype(float) ** 2))
                     logger.debug(f"Recording stats - RMS: {rms:.2f}, Speech detected: {speech_detected}")
                 
-                return full_recording
+                # Return tuple: (audio_data, speech_detected)
+                return (full_recording, speech_detected)
             else:
                 logger.warning("No audio chunks recorded")
-                return np.array([])
+                return (np.array([]), False)
                 
         except Exception as e:
             logger.error(f"Recording with VAD failed: {e}")
@@ -1042,7 +1084,8 @@ def record_audio_with_silence_detection(max_duration: float, disable_silence_det
             logger.error(f"\n{help_message}")
             
             logger.info("Falling back to fixed duration recording")
-            return record_audio(max_duration)
+            # For fallback, assume speech is present since we can't detect
+            return (record_audio(max_duration), True)
             
         finally:
             # Restore stdio
@@ -1056,7 +1099,8 @@ def record_audio_with_silence_detection(max_duration: float, disable_silence_det
     except Exception as e:
         logger.error(f"VAD initialization failed: {e}")
         logger.info("Falling back to fixed duration recording")
-        return record_audio(max_duration)
+        # For fallback, assume speech is present since we can't detect
+        return (record_audio(max_duration), True)
 
 
 async def check_livekit_available() -> bool:
@@ -1713,7 +1757,7 @@ async def converse(
                     
                     record_start = time.perf_counter()
                     logger.debug(f"About to call record_audio_with_silence_detection with duration={listen_duration}, disable_silence_detection={disable_silence_detection}, min_duration={min_listen_duration}, vad_aggressiveness={vad_aggressiveness}")
-                    audio_data = await asyncio.get_event_loop().run_in_executor(
+                    audio_data, speech_detected = await asyncio.get_event_loop().run_in_executor(
                         None, record_audio_with_silence_detection, listen_duration, disable_silence_detection, min_listen_duration, vad_aggressiveness
                     )
                     timings['record'] = time.perf_counter() - record_start
@@ -1736,14 +1780,27 @@ async def converse(
                         result = "Error: Could not record audio"
                         return result
                     
-                    # Convert to text
-                    # Log STT start
-                    if event_logger:
-                        event_logger.log_event(event_logger.STT_START)
-                    
-                    stt_start = time.perf_counter()
-                    response_text = await speech_to_text(audio_data, SAVE_AUDIO, AUDIO_DIR if SAVE_AUDIO else None, transport)
-                    timings['stt'] = time.perf_counter() - stt_start
+                    # Check if no speech was detected
+                    if not speech_detected:
+                        logger.info("No speech detected during recording - skipping STT processing")
+                        response_text = None
+                        timings['stt'] = 0.0
+                        
+                        # Still save the audio if configured
+                        if SAVE_AUDIO and AUDIO_DIR:
+                            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                            audio_path = os.path.join(AUDIO_DIR, f"no_speech_{timestamp}.wav")
+                            write(audio_path, SAMPLE_RATE, audio_data)
+                            logger.debug(f"Saved no-speech audio to: {audio_path}")
+                    else:
+                        # Convert to text
+                        # Log STT start
+                        if event_logger:
+                            event_logger.log_event(event_logger.STT_START)
+                        
+                        stt_start = time.perf_counter()
+                        response_text = await speech_to_text(audio_data, SAVE_AUDIO, AUDIO_DIR if SAVE_AUDIO else None, transport)
+                        timings['stt'] = time.perf_counter() - stt_start
                     
                     # Log STT complete
                     if event_logger: