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

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

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.23.0] - 2025-08-16
+
+### Added
+- **`skip_tts` parameter** - Dynamic control over text-to-speech in converse tool
+  - Add optional `skip_tts` parameter to override global `VOICEMODE_SKIP_TTS` setting
+  - When `True`: Skip TTS for faster text-only responses
+  - When `False`: Always use TTS regardless of environment setting
+  - When `None` (default): Follow `VOICEMODE_SKIP_TTS` environment variable
+  - Enables LLM to intelligently choose between voice and text-only responses
+- **`VOICEMODE_SKIP_TTS` environment variable** - Global TTS skip configuration
+  - Set to `true` for permanent text-only mode (faster responses)
+  - Can be overridden per-call with `skip_tts` parameter
+  - Useful for rapid development iterations or when voice isn't needed
+
+### Fixed
+- **Service status detection** - Correctly identify SSH-forwarded vs locally running services
+  - SSH processes listening on service ports are now recognized as port forwards
+  - Status command now shows 🔄 for forwarded services vs ✅ for local services
+  - Prevents confusion about where services are actually running
+
 ## [2.22.3] - 2025-08-16
 
 ## [2.23.0] - 2025-08-16

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

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

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

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

@@ -175,6 +175,9 @@ SAVE_TRANSCRIPTIONS = SAVE_ALL or DEBUG or os.getenv("VOICEMODE_SAVE_TRANSCRIPTI
 # Audio feedback configuration
 AUDIO_FEEDBACK_ENABLED = os.getenv("VOICEMODE_AUDIO_FEEDBACK", "true").lower() in ("true", "1", "yes", "on")
 
+# Skip TTS configuration (skip text-to-speech for faster responses)
+SKIP_TTS = os.getenv("VOICEMODE_SKIP_TTS", "false").lower() in ("true", "1", "yes", "on")
+
 # Local provider preference configuration
 PREFER_LOCAL = os.getenv("VOICEMODE_PREFER_LOCAL", "true").lower() in ("true", "1", "yes", "on")
 

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

@@ -48,6 +48,7 @@ from voice_mode.config import (
     VAD_AGGRESSIVENESS,
     SILENCE_THRESHOLD_MS,
     MIN_RECORDING_DURATION,
+    SKIP_TTS,
     VAD_CHUNK_DURATION_MS,
     INITIAL_SILENCE_GRACE_PERIOD,
     DEFAULT_LISTEN_DURATION,
@@ -1248,7 +1249,8 @@ async def converse(
     audio_format: Optional[str] = None,
     disable_silence_detection: Union[bool, str] = False,
     speed: Optional[float] = None,
-    vad_aggressiveness: Optional[int] = None
+    vad_aggressiveness: Optional[int] = None,
+    skip_tts: Optional[Union[bool, str]] = None
 ) -> str:
     """Have a voice conversation - speak a message and optionally listen for response.
     
@@ -1320,6 +1322,11 @@ async def converse(
                             
                             Use lower values (0-1) in quiet environments to catch all speech
                             Use higher values (2-3) in noisy environments to reduce false triggers
+        skip_tts: Skip text-to-speech and only show text (default: None uses VOICEMODE_SKIP_TTS env var)
+                  When True: Skip TTS for faster response, text-only output
+                  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
         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)
     
@@ -1360,6 +1367,12 @@ async def converse(
         
         Remember: Lower values (0-1) = more permissive, may detect non-speech as speech
                  Higher values (2-3) = more strict, may miss soft speech or whispers
+    
+    Skip TTS Examples:
+        - Fast iteration mode: converse("Processing your request", skip_tts=True)  # Text only, no voice
+        - Important announcement: converse("Warning: System will restart", skip_tts=False)  # Always use voice
+        - Quick confirmation: converse("Done!", skip_tts=True, wait_for_response=False)  # Fast text-only
+        - Follow user preference: converse("Hello")  # Uses VOICEMODE_SKIP_TTS setting
     """
     # Convert string booleans to actual booleans
     if isinstance(wait_for_response, str):
@@ -1368,6 +1381,16 @@ async def converse(
         disable_silence_detection = disable_silence_detection.lower() in ('true', '1', 'yes', 'on')
     if isinstance(audio_feedback, str):
         audio_feedback = audio_feedback.lower() in ('true', '1', 'yes', 'on')
+    if skip_tts is not None and isinstance(skip_tts, str):
+        skip_tts = skip_tts.lower() in ('true', '1', 'yes', 'on')
+    
+    # Determine whether to skip TTS
+    if skip_tts is not None:
+        # Parameter explicitly set, use it
+        should_skip_tts = skip_tts
+    else:
+        # Use global setting
+        should_skip_tts = SKIP_TTS
     
     # Convert string speed to float
     if speed is not None and isinstance(speed, str):
@@ -1457,15 +1480,26 @@ async def converse(
         if not wait_for_response:
             try:
                 async with audio_operation_lock:
-                    success, tts_metrics, tts_config = await text_to_speech_with_failover(
-                        message=message,
-                        voice=voice,
-                        model=tts_model,
-                        instructions=tts_instructions,
-                        audio_format=audio_format,
-                        initial_provider=tts_provider,
-                        speed=speed
-                    )
+                    if should_skip_tts:
+                        # Skip TTS entirely
+                        success = True
+                        tts_metrics = {
+                            'ttfa': 0,
+                            'generation': 0,
+                            'playback': 0,
+                            'total': 0
+                        }
+                        tts_config = {'provider': 'no-op', 'voice': 'none'}
+                    else:
+                        success, tts_metrics, tts_config = await text_to_speech_with_failover(
+                            message=message,
+                            voice=voice,
+                            model=tts_model,
+                            instructions=tts_instructions,
+                            audio_format=audio_format,
+                            initial_provider=tts_provider,
+                            speed=speed
+                        )
                     
                 # Include timing info if available
                 timing_info = ""
@@ -1589,15 +1623,26 @@ async def converse(
                 async with audio_operation_lock:
                     # Speak the message
                     tts_start = time.perf_counter()
-                    tts_success, tts_metrics, tts_config = await text_to_speech_with_failover(
-                        message=message,
-                        voice=voice,
-                        model=tts_model,
-                        instructions=tts_instructions,
-                        audio_format=audio_format,
-                        initial_provider=tts_provider,
-                        speed=speed
-                    )
+                    if should_skip_tts:
+                        # Skip TTS entirely for faster response
+                        tts_success = True
+                        tts_metrics = {
+                            'ttfa': 0,
+                            'generation': 0,
+                            'playback': 0,
+                            'total': 0
+                        }
+                        tts_config = {'provider': 'no-op', 'voice': 'none'}
+                    else:
+                        tts_success, tts_metrics, tts_config = await text_to_speech_with_failover(
+                            message=message,
+                            voice=voice,
+                            model=tts_model,
+                            instructions=tts_instructions,
+                            audio_format=audio_format,
+                            initial_provider=tts_provider,
+                            speed=speed
+                        )
                     
                     # Add TTS sub-metrics
                     if tts_metrics:

{voice_mode-2.22.3 → voice_mode-2.23.0}/voice_mode/tools/service.py

@@ -14,7 +14,7 @@ import psutil
 
 from voice_mode.server import mcp
 from voice_mode.config import WHISPER_PORT, KOKORO_PORT, LIVEKIT_PORT, SERVICE_AUTO_ENABLE
-from voice_mode.utils.services.common import find_process_by_port
+from voice_mode.utils.services.common import find_process_by_port, check_service_status
 from voice_mode.utils.services.whisper_helpers import find_whisper_server, find_whisper_model
 from voice_mode.utils.services.kokoro_helpers import find_kokoro_fastapi, has_gpu_support
 
@@ -195,10 +195,16 @@ async def status_service(service_name: str) -> str:
         port = LIVEKIT_PORT
     else:  # frontend
         port = 3000
-    proc = find_process_by_port(port)
     
-    if not proc:
-        return f"{service_name.capitalize()} is not running on port {port}"
+    status, proc = check_service_status(port)
+    
+    if status == "not_available":
+        return f"❌ {service_name.capitalize()} is not available"
+    elif status == "forwarded":
+        return f"""🔄 {service_name.capitalize()} is available via port forwarding
+   Port: {port} (forwarded)
+   Local process: Not running
+   Remote: Accessible"""
     
     try:
         with proc.oneshot():
@@ -269,7 +275,7 @@ async def status_service(service_name: str) -> str:
         if extra_info_parts:
             extra_info = "\n   " + "\n   ".join(extra_info_parts)
         
-        return f"""✅ {service_name.capitalize()} is running
+        return f"""✅ {service_name.capitalize()} is running locally
    PID: {proc.pid}
    Port: {port}
    CPU: {cpu_percent:.1f}%

voice_mode-2.23.0/voice_mode/utils/services/common.py

@@ -0,0 +1,80 @@
+"""Common utilities for service management tools."""
+
+import psutil
+import socket
+from typing import Optional, Tuple
+import logging
+
+logger = logging.getLogger("voice-mode")
+
+
+def find_process_by_port(port: int) -> Optional[psutil.Process]:
+    """Find a process listening on the specified port.
+    
+    Returns None if port is only accessible via SSH forwarding or other non-local means.
+    """
+    try:
+        for proc in psutil.process_iter(['pid', 'name']):
+            try:
+                # Skip if we can't access process info (might be another user's process)
+                if not proc.is_running():
+                    continue
+                
+                # Skip SSH processes - these are port forwards, not actual services
+                proc_name = proc.name().lower()
+                if proc_name in ['ssh', 'sshd']:
+                    continue
+                    
+                for conn in proc.connections():
+                    if conn.laddr.port == port and conn.status == 'LISTEN':
+                        # Verify this is a real local process
+                        try:
+                            # Try to access basic process info to ensure it's real
+                            _ = proc.pid
+                            _ = proc.create_time()
+                            return proc
+                        except (psutil.NoSuchProcess, psutil.AccessDenied):
+                            # Process doesn't actually exist or we can't access it
+                            continue
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+    except Exception as e:
+        logger.error(f"Error finding process by port: {e}")
+    return None
+
+
+def is_port_accessible(port: int, host: str = "127.0.0.1", timeout: float = 1.0) -> bool:
+    """Check if a port is accessible (can connect to it).
+    
+    This will return True for both locally running services and SSH-forwarded ports.
+    """
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(timeout)
+            result = sock.connect_ex((host, port))
+            return result == 0
+    except Exception as e:
+        logger.error(f"Error checking port accessibility: {e}")
+        return False
+
+
+def check_service_status(port: int) -> Tuple[str, Optional[psutil.Process]]:
+    """Check the status of a service on a given port.
+    
+    Returns:
+        Tuple of (status, process):
+        - ("local", process) if running locally
+        - ("forwarded", None) if accessible but not local
+        - ("not_available", None) if not accessible at all
+    """
+    # First check if there's a local process
+    proc = find_process_by_port(port)
+    if proc:
+        return ("local", proc)
+    
+    # No local process, check if port is accessible (might be forwarded)
+    if is_port_accessible(port):
+        return ("forwarded", None)
+    
+    # Not accessible at all
+    return ("not_available", None)

voice_mode-2.22.3/voice_mode/utils/services/common.py

@@ -1,22 +0,0 @@
-"""Common utilities for service management tools."""
-
-import psutil
-from typing import Optional
-import logging
-
-logger = logging.getLogger("voice-mode")
-
-
-def find_process_by_port(port: int) -> Optional[psutil.Process]:
-    """Find a process listening on the specified port."""
-    try:
-        for proc in psutil.process_iter(['pid', 'name']):
-            try:
-                for conn in proc.connections():
-                    if conn.laddr.port == port and conn.status == 'LISTEN':
-                        return proc
-            except (psutil.NoSuchProcess, psutil.AccessDenied):
-                continue
-    except Exception as e:
-        logger.error(f"Error finding process by port: {e}")
-    return None