voice-mode 4.1.0__py3-none-any.whl → 4.3.1__py3-none-any.whl

voice_mode/__version__.py

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

voice_mode/cli.py

@@ -57,6 +57,14 @@ def voice_mode() -> None:
     voice_mode_main_cli()
 
 
+# Audio group for audio-related commands
+@voice_mode_main_cli.group()
+@click.help_option('-h', '--help', help='Show this message and exit')
+def audio():
+    """Audio transcription and playback commands."""
+    pass
+
+
 # Service group commands
 @voice_mode_main_cli.group()
 @click.help_option('-h', '--help', help='Show this message and exit')
@@ -1361,19 +1369,36 @@ def cli():
 from voice_mode.cli_commands import exchanges as exchanges_cmd
 from voice_mode.cli_commands import transcribe as transcribe_cmd
 from voice_mode.cli_commands import pronounce_commands
+from voice_mode.cli_commands import claude
+from voice_mode.cli_commands import hook as hook_cmd
 
 # Add subcommands to legacy CLI
 cli.add_command(exchanges_cmd.exchanges)
 cli.add_command(transcribe_cmd.transcribe)
 cli.add_command(pronounce_commands.pronounce_group)
+cli.add_command(claude.claude_group)
 
 # Add exchanges to main CLI
 voice_mode_main_cli.add_command(exchanges_cmd.exchanges)
-voice_mode_main_cli.add_command(pronounce_commands.pronounce_group)
+voice_mode_main_cli.add_command(claude.claude_group)
+
+# Note: We'll add these commands after the groups are defined
+# audio group will get transcribe and play commands
+# claude group will get hook command  
+# config group will get pronounce command
 
-# Add transcribe to main CLI
-voice_mode_main_cli.add_command(transcribe_cmd.transcribe)
 
+# Now add the subcommands to their respective groups
+# Add transcribe command to audio group
+transcribe_audio_cmd = transcribe_cmd.transcribe.commands['audio']
+transcribe_audio_cmd.name = 'transcribe'
+audio.add_command(transcribe_audio_cmd)
+
+# Add hook command under claude group  
+claude.claude_group.add_command(hook_cmd.hook)
+
+# Add pronounce under config group
+config.add_command(pronounce_commands.pronounce_group)
 
 # Converse command - direct voice conversation from CLI
 @voice_mode_main_cli.command()
@@ -1751,6 +1776,69 @@ def update(force):
                 click.echo("Try running: pip install --upgrade voice-mode")
 
 
+# Sound Fonts command
+@audio.command("play")
+@click.help_option('-h', '--help')
+@click.option('-t', '--tool', help='Tool name for direct command-line usage')
+@click.option('-a', '--action', default='start', type=click.Choice(['start', 'end']), help='Action type')
+@click.option('-s', '--subagent', help='Subagent type (for Task tool)')
+def play_sound(tool, action, subagent):
+    """Play sound based on tool events (primarily for Claude Code hooks).
+    
+    This command is designed to be called by Claude Code hooks to play sounds
+    when tools are used. It reads hook data from stdin by default, or can be
+    used directly with command-line options.
+    
+    Examples:
+        echo '{"tool_name":"Task","tool_input":{"subagent_type":"mama-bear"}}' | voicemode play-sound
+        voicemode play-sound --tool Task --action start --subagent mama-bear
+    """
+    import sys
+    from .tools.sound_fonts.player import AudioPlayer
+    from .tools.sound_fonts.hook_handler import (
+        read_hook_data_from_stdin,
+        parse_claude_code_hook
+    )
+    
+    # Try to read hook data from stdin first
+    hook_data = None
+    if not sys.stdin.isatty():
+        hook_data = read_hook_data_from_stdin()
+    
+    if hook_data:
+        # Parse Claude Code hook format
+        parsed_data = parse_claude_code_hook(hook_data)
+        if not parsed_data:
+            sys.exit(1)
+            
+        tool_name = parsed_data["tool_name"]
+        action_type = parsed_data["action"]
+        subagent_type = parsed_data["subagent_type"]
+        metadata = parsed_data["metadata"]
+    else:
+        # Use command-line arguments
+        if not tool:
+            click.echo("Error: --tool is required when not reading from stdin", err=True)
+            sys.exit(1)
+            
+        tool_name = tool
+        action_type = action
+        subagent_type = subagent
+        metadata = {}
+    
+    # Play the sound
+    player = AudioPlayer()
+    success = player.play_sound_for_event(
+        tool_name=tool_name,
+        action=action_type,
+        subagent_type=subagent_type,
+        metadata=metadata
+    )
+    
+    # Silent exit for hooks - don't clutter Claude Code output
+    sys.exit(0 if success else 1)
+
+
 # Completions command
 @voice_mode_main_cli.command()
 @click.help_option('-h', '--help')

voice_mode/cli_commands/claude.py

@@ -0,0 +1,208 @@
+"""CLI commands for Claude Code message extraction."""
+
+import click
+import json
+import os
+import logging
+from pathlib import Path
+from typing import Optional, List
+from datetime import datetime
+
+from voice_mode.tools.claude_thinking import (
+    find_claude_log_file,
+    extract_messages_from_log,
+    extract_thinking_from_messages
+)
+
+logger = logging.getLogger("voice-mode")
+
+
+@click.group(name='claude')
+def claude_group():
+    """Extract messages from Claude Code conversation logs."""
+    pass
+
+
+@claude_group.command(name='messages')
+@click.option('--last-n', '-n', default=2, type=int,
+              help='Number of recent messages to extract (default: 2)')
+@click.option('--type', '-t', 'message_types', multiple=True,
+              type=click.Choice(['user', 'assistant']),
+              help='Filter by message type (can specify multiple)')
+@click.option('--format', '-f', 
+              type=click.Choice(['full', 'text', 'thinking']),
+              default='full',
+              help='Output format: full (complete), text (text only), thinking (thinking only)')
+@click.option('--working-dir', '-d', type=click.Path(exists=True),
+              help='Working directory to find logs for (defaults to CWD)')
+@click.option('--output', '-o', type=click.Path(),
+              help='Save output to file')
+@click.option('--json', 'as_json', is_flag=True,
+              help='Output as JSON (overrides format)')
+def messages_command(last_n: int, message_types: tuple, format: str,
+                    working_dir: Optional[str], output: Optional[str],
+                    as_json: bool):
+    """
+    Extract recent messages from Claude Code logs.
+    
+    Examples:
+    
+        voicemode claude messages
+        
+        voicemode claude messages -n 5 --format thinking
+        
+        voicemode claude messages --type assistant --format text
+        
+        voicemode claude messages --json -o messages.json
+    """
+    # Find log file
+    log_file = find_claude_log_file(working_dir)
+    if not log_file:
+        click.echo(f"Error: Could not find Claude Code logs for directory: {working_dir or os.getcwd()}", err=True)
+        return
+    
+    # Extract messages
+    message_type_list = list(message_types) if message_types else None
+    messages = extract_messages_from_log(log_file, last_n, message_type_list)
+    
+    if not messages:
+        click.echo("No messages found in recent logs", err=True)
+        return
+    
+    # Format output
+    if as_json:
+        content = json.dumps(messages, indent=2)
+    elif format == 'thinking':
+        thinking_texts = extract_thinking_from_messages(messages)
+        if not thinking_texts:
+            click.echo("No thinking content found", err=True)
+            return
+        content = "\n\n=== Next Thinking ===\n\n".join(thinking_texts)
+    elif format == 'text':
+        result = []
+        for msg in messages:
+            content_text = []
+            content_items = msg.get('content', [])
+            logger.debug(f"Message has {len(content_items)} content items")
+            for item in content_items:
+                if isinstance(item, dict):
+                    item_type = item.get('type')
+                    logger.debug(f"Content item type: {item_type}")
+                    if item_type == 'text':
+                        text = item.get('text', '')
+                        if text:
+                            content_text.append(text)
+                    elif item_type == 'thinking':
+                        text = item.get('text', '')
+                        if text:
+                            content_text.append(f"[Thinking: {text}]")
+            if content_text:
+                result.append(f"{msg['type'].title()}: {' '.join(content_text)}")
+        content = "\n\n".join(result)
+    else:  # full format
+        # Format as human-readable
+        result = []
+        for i, msg in enumerate(messages, 1):
+            result.append(f"=== Message {i} ===")
+            result.append(f"Type: {msg['type']}")
+            result.append(f"Timestamp: {msg.get('timestamp', 'Unknown')}")
+            if msg.get('model'):
+                result.append(f"Model: {msg['model']}")
+            
+            # Format content
+            content_items = msg.get('content', [])
+            if content_items:
+                result.append("Content:")
+                for item in content_items:
+                    if isinstance(item, dict):
+                        item_type = item.get('type', 'unknown')
+                        if item_type == 'text':
+                            result.append(f"  [Text]: {item.get('text', '')}")
+                        elif item_type == 'thinking':
+                            result.append(f"  [Thinking]: {item.get('text', '')}")
+                        elif item_type == 'tool_use':
+                            result.append(f"  [Tool Use]: {item.get('name', '')}")
+                        elif item_type == 'tool_result':
+                            result.append(f"  [Tool Result]: {item.get('content', '')[:100]}...")
+            result.append("")
+        content = "\n".join(result).strip()
+    
+    # Output
+    if output:
+        Path(output).write_text(content)
+        click.echo(f"Output saved to {output}")
+    else:
+        # Debug: ensure content is printed
+        logger.debug(f"About to output {len(content)} characters")
+        click.echo(content)
+        logger.debug("Output complete")
+
+
+@claude_group.command(name='thinking')
+@click.option('--last-n', '-n', default=1, type=int,
+              help='Number of messages to search for thinking (default: 1)')
+@click.option('--working-dir', '-d', type=click.Path(exists=True),
+              help='Working directory to find logs for (defaults to CWD)')
+def thinking_command(last_n: int, working_dir: Optional[str]):
+    """
+    Extract only thinking content from Claude Code logs.
+    
+    Convenience command equivalent to:
+    voicemode claude messages --format thinking --type assistant
+    
+    Examples:
+    
+        voicemode claude thinking
+        
+        voicemode claude thinking -n 3
+    """
+    # Delegate to messages command with thinking format
+    ctx = click.get_current_context()
+    ctx.invoke(messages_command,
+               last_n=last_n,
+               message_types=('assistant',),
+               format='thinking',
+               working_dir=working_dir,
+               output=None,
+               as_json=False)
+
+
+@claude_group.command(name='check')
+def check_command():
+    """
+    Check if Claude Code context is available.
+    
+    Shows information about the Claude Code environment including:
+    - Whether Claude Code logs are accessible
+    - Current working directory
+    - Log file location if found
+    - Last update time
+    
+    Example:
+        voicemode claude check
+    """
+    working_dir = os.getcwd()
+    log_file = find_claude_log_file(working_dir)
+    
+    click.echo(f"Working Directory: {working_dir}")
+    click.echo(f"Claude Logs Found: {'Yes' if log_file else 'No'}")
+    
+    if log_file:
+        click.echo(f"Log File: {log_file}")
+        click.echo(f"Log Size: {log_file.stat().st_size:,} bytes")
+        
+        mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+        now = datetime.now()
+        age = now - mtime
+        
+        if age.total_seconds() < 60:
+            click.echo(f"Last Updated: {int(age.total_seconds())} seconds ago")
+        elif age.total_seconds() < 3600:
+            click.echo(f"Last Updated: {int(age.total_seconds() / 60)} minutes ago")
+        else:
+            click.echo(f"Last Updated: {int(age.total_seconds() / 3600)} hours ago")
+    else:
+        project_dir = working_dir.replace('/', '-')
+        expected_path = Path.home() / '.claude' / 'projects' / project_dir
+        click.echo(f"Expected Log Location: {expected_path}")
+        click.echo("Note: Logs are only created when using Claude Code (claude.ai/code)")

voice_mode/cli_commands/hook.py

@@ -0,0 +1,209 @@
+"""
+Hook commands for Voice Mode - primarily for Claude Code integration.
+"""
+
+import click
+import sys
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+
+@click.group()
+@click.help_option('-h', '--help', help='Show this message and exit')
+def hook():
+    """Manage Voice Mode hooks and event handlers."""
+    pass
+
+
+@hook.command('stdin-receiver')
+@click.option('--tool-name', help='Override tool name (for testing)')
+@click.option('--action', type=click.Choice(['start', 'end']), help='Override action (for testing)')
+@click.option('--subagent-type', help='Override subagent type (for testing)')
+@click.option('--event', type=click.Choice(['PreToolUse', 'PostToolUse']), help='Override event (for testing)')
+@click.option('--debug', is_flag=True, help='Enable debug output')
+def stdin_receiver(tool_name, action, subagent_type, event, debug):
+    """Receive and process hook events from Claude Code via stdin.
+    
+    This command reads JSON from stdin when called by Claude Code hooks,
+    or accepts command-line arguments for testing.
+    
+    The filesystem structure defines sound mappings:
+    ~/.voicemode/soundfonts/current/PreToolUse/task/subagent/baby-bear.wav
+    
+    Examples:
+        # Called by Claude Code (reads JSON from stdin)
+        voicemode hook stdin-receiver
+        
+        # Testing with defaults
+        voicemode hook stdin-receiver --debug
+        
+        # Testing with specific values
+        voicemode hook stdin-receiver --tool-name Task --action start --subagent-type mama-bear
+    """
+    from voice_mode.tools.sound_fonts.audio_player import Player
+    
+    # Try to read JSON from stdin if available
+    hook_data = {}
+    if not sys.stdin.isatty():
+        try:
+            hook_data = json.load(sys.stdin)
+            if debug:
+                print(f"[DEBUG] Received JSON: {json.dumps(hook_data, indent=2)}", file=sys.stderr)
+        except Exception as e:
+            if debug:
+                print(f"[DEBUG] Failed to parse JSON from stdin: {e}", file=sys.stderr)
+            # Silent fail for hooks
+            sys.exit(0)
+    
+    # Extract values from JSON or use command-line overrides/defaults
+    if not tool_name:
+        tool_name = hook_data.get('tool_name', 'Task')
+    
+    if not event:
+        event_name = hook_data.get('hook_event_name', 'PreToolUse')
+    else:
+        event_name = event
+    
+    # Map event to action if not specified
+    if not action:
+        if event_name == 'PreToolUse':
+            action = 'start'
+        elif event_name == 'PostToolUse':
+            action = 'end'
+        else:
+            action = 'start'  # Default
+    
+    # Get subagent_type from tool_input if not specified
+    if not subagent_type and tool_name == 'Task':
+        tool_input = hook_data.get('tool_input', {})
+        subagent_type = tool_input.get('subagent_type', 'baby-bear')
+    elif not subagent_type:
+        subagent_type = None
+    
+    if debug:
+        print(f"[DEBUG] Processing: event={event_name}, tool={tool_name}, "
+              f"action={action}, subagent={subagent_type}", file=sys.stderr)
+    
+    # Check if sound fonts are enabled
+    from voice_mode.config import SOUNDFONTS_ENABLED
+    
+    if not SOUNDFONTS_ENABLED:
+        if debug:
+            print(f"[DEBUG] Sound fonts are disabled (VOICEMODE_SOUNDFONTS_ENABLED=false)", file=sys.stderr)
+    else:
+        # Find sound file using filesystem conventions
+        sound_file = find_sound_file(event_name, tool_name, subagent_type)
+        
+        if sound_file:
+            if debug:
+                print(f"[DEBUG] Found sound file: {sound_file}", file=sys.stderr)
+            
+            # Play the sound
+            player = Player()
+            success = player.play(str(sound_file))
+            
+            if debug:
+                if success:
+                    print(f"[DEBUG] Sound played successfully", file=sys.stderr)
+                else:
+                    print(f"[DEBUG] Failed to play sound", file=sys.stderr)
+        else:
+            if debug:
+                print(f"[DEBUG] No sound file found for this event", file=sys.stderr)
+    
+    # Always exit 0 to not disrupt Claude Code
+    sys.exit(0)
+
+
+def find_sound_file(event: str, tool: str, subagent: Optional[str] = None) -> Optional[Path]:
+    """
+    Find sound file using filesystem conventions.
+    
+    Tries paths in order (mp3 preferred over wav for size):
+    1. Most specific: {event}/{tool}/subagent/{subagent}.{mp3,wav} (Task tool only)
+    2. Tool default: {event}/{tool}/default.{mp3,wav}
+    3. Event default: {event}/default.{mp3,wav}
+    4. Global fallback: fallback.{mp3,wav}
+    
+    Args:
+        event: Event name (PreToolUse, PostToolUse)
+        tool: Tool name (lowercase)
+        subagent: Optional subagent type (lowercase)
+        
+    Returns:
+        Path to sound file if found, None otherwise
+    """
+    # Get base path (follow symlink if exists)
+    base_path = Path.home() / '.voicemode' / 'soundfonts' / 'current'
+    
+    # Resolve symlink if it exists
+    if base_path.is_symlink():
+        base_path = base_path.resolve()
+    
+    if not base_path.exists():
+        return None
+    
+    # Normalize names to lowercase for filesystem
+    event = event.lower() if event else 'pretooluse'
+    tool = tool.lower() if tool else 'default'
+    subagent = subagent.lower() if subagent else None
+    
+    # Map event names to directory names
+    event_map = {
+        'pretooluse': 'PreToolUse',
+        'posttooluse': 'PostToolUse',
+        'start': 'PreToolUse',
+        'end': 'PostToolUse'
+    }
+    event_dir = event_map.get(event, event)
+    
+    # Build list of paths to try (most specific to least specific)
+    paths_to_try = []
+    
+    # 1. Most specific: subagent sound (Task tool only)
+    if tool == 'task' and subagent:
+        # Try mp3 first (smaller), then wav
+        paths_to_try.append(base_path / event_dir / tool / 'subagent' / f'{subagent}.mp3')
+        paths_to_try.append(base_path / event_dir / tool / 'subagent' / f'{subagent}.wav')
+    
+    # 2. Tool-specific default
+    paths_to_try.append(base_path / event_dir / tool / 'default.mp3')
+    paths_to_try.append(base_path / event_dir / tool / 'default.wav')
+    
+    # 3. Event-level default
+    paths_to_try.append(base_path / event_dir / 'default.mp3')
+    paths_to_try.append(base_path / event_dir / 'default.wav')
+    
+    # 4. Global fallback
+    paths_to_try.append(base_path / 'fallback.mp3')
+    paths_to_try.append(base_path / 'fallback.wav')
+    
+    # Find first existing file
+    for path in paths_to_try:
+        if path.exists():
+            return path
+    
+    return None
+
+
+# Keep the old receiver command for backwards compatibility (deprecated)
+@hook.command('receiver', hidden=True)
+@click.argument('tool_name')
+@click.argument('action', type=click.Choice(['start', 'end', 'complete']))
+@click.argument('subagent_type', required=False)
+@click.option('--debug', is_flag=True, help='Enable debug output')
+def receiver_deprecated(tool_name, action, subagent_type, debug):
+    """[DEPRECATED] Use stdin-receiver instead."""
+    # Map old action to event
+    event = 'PreToolUse' if action == 'start' else 'PostToolUse'
+    
+    # Call the new command
+    ctx = click.get_current_context()
+    ctx.invoke(stdin_receiver, 
+               tool_name=tool_name,
+               action=action if action != 'complete' else 'end',
+               subagent_type=subagent_type,
+               event=event,
+               debug=debug)

voice_mode/config.py

@@ -101,6 +101,9 @@ def load_voicemode_env():
 # Enable audio feedback (true/false)
 # VOICEMODE_AUDIO_FEEDBACK=true
 
+# Enable sound fonts for tool use hooks (true/false)
+# VOICEMODE_SOUNDFONTS_ENABLED=false
+
 #############
 # Provider Configuration
 #############
@@ -371,6 +374,11 @@ FRONTEND_PORT = int(os.getenv("VOICEMODE_FRONTEND_PORT", "3000"))
 # Auto-enable services after installation
 SERVICE_AUTO_ENABLE = env_bool("VOICEMODE_SERVICE_AUTO_ENABLE", False)
 
+# ==================== SOUND FONTS CONFIGURATION ====================
+
+# Sound fonts are disabled by default to avoid annoying users with unexpected sounds
+SOUNDFONTS_ENABLED = env_bool("VOICEMODE_SOUNDFONTS_ENABLED", False)
+
 # ==================== AUDIO CONFIGURATION ====================
 
 # Audio parameters
@@ -555,6 +563,87 @@ def initialize_directories():
     # Create events log directory
     if EVENT_LOG_ENABLED:
         Path(EVENT_LOG_DIR).mkdir(parents=True, exist_ok=True)
+    
+    # Initialize sound fonts if not present
+    initialize_soundfonts()
+
+# ==================== SOUND FONTS INITIALIZATION ====================
+
+def initialize_soundfonts():
+    """Install default sound fonts from package data if not present."""
+    import shutil
+    import importlib.resources
+    
+    soundfonts_dir = BASE_DIR / "soundfonts"
+    default_soundfont_dir = soundfonts_dir / "default"
+    current_symlink = soundfonts_dir / "current"
+    
+    # Skip if soundfonts already exist (user has customized them)
+    if default_soundfont_dir.exists():
+        # Ensure symlink exists if directory exists
+        if not current_symlink.exists():
+            try:
+                current_symlink.symlink_to(default_soundfont_dir.resolve())
+            except OSError:
+                # Symlinks might not work on all systems
+                pass
+        return
+    
+    try:
+        # Create soundfonts directory
+        soundfonts_dir.mkdir(exist_ok=True)
+        
+        # Copy default soundfonts from package data
+        try:
+            # For Python 3.9+
+            from importlib.resources import files
+            package_soundfonts = files("voice_mode.data.soundfonts.default")
+            
+            if package_soundfonts.is_dir():
+                # Create the default directory
+                default_soundfont_dir.mkdir(exist_ok=True)
+                
+                # Recursively copy all files from package data
+                def copy_tree(src, dst):
+                    """Recursively copy directory tree from package data."""
+                    dst.mkdir(exist_ok=True)
+                    for item in src.iterdir():
+                        if item.is_file():
+                            target = dst / item.name
+                            target.write_bytes(item.read_bytes())
+                        elif item.is_dir():
+                            copy_tree(item, dst / item.name)
+                
+                # Copy entire tree structure
+                copy_tree(package_soundfonts, default_soundfont_dir)
+        except ImportError:
+            # Fallback for older Python versions
+            import pkg_resources
+            
+            # Create the default directory
+            default_soundfont_dir.mkdir(exist_ok=True)
+            
+            # List all resources in the soundfonts directory
+            resource_dir = "data/soundfonts/default"
+            if pkg_resources.resource_exists("voice_mode", resource_dir):
+                # This is a bit more complex with pkg_resources
+                # We'll need to manually copy the structure
+                pass
+        
+        # Create symlink to current soundfont (points to default)
+        if default_soundfont_dir.exists() and not current_symlink.exists():
+            try:
+                current_symlink.symlink_to(default_soundfont_dir.resolve())
+            except OSError:
+                # Symlinks might not work on all systems (e.g., Windows without admin)
+                pass
+                
+    except Exception as e:
+        # Don't fail initialization if soundfonts can't be installed
+        # They're optional and disabled by default
+        if DEBUG:
+            import logging
+            logging.getLogger("voicemode").debug(f"Could not initialize soundfonts: {e}")
 
 # ==================== UTILITY FUNCTIONS ====================
 
@@ -841,3 +930,28 @@ def get_format_export_params(format: str) -> dict:
         pass
     
     return params
+
+# ==================== THINK OUT LOUD CONFIGURATION ====================
+
+# Enable Think Out Loud mode
+THINK_OUT_LOUD_ENABLED = env_bool("VOICEMODE_THINK_OUT_LOUD", False)
+
+# Voice persona mappings for thinking roles (role:voice pairs)
+# Default: analytical:am_adam,creative:af_sarah,critical:af_bella,synthesis:af_nova
+THINKING_VOICES_STR = os.getenv(
+    "VOICEMODE_THINKING_VOICES",
+    "analytical:am_adam,creative:af_sarah,critical:af_bella,synthesis:af_nova"
+)
+
+# Parse thinking voices into a dictionary
+THINKING_VOICES = {}
+for pair in THINKING_VOICES_STR.split(","):
+    if ":" in pair:
+        role, voice = pair.strip().split(":", 1)
+        THINKING_VOICES[role.strip()] = voice.strip()
+
+# Thinking presentation style: sequential, debate, or chorus
+THINKING_STYLE = os.getenv("VOICEMODE_THINKING_STYLE", "sequential")
+
+# Whether to announce which voice is speaking
+THINKING_ANNOUNCE_VOICE = env_bool("VOICEMODE_THINKING_ANNOUNCE_VOICE", True)

voice_mode/frontend/.next/BUILD_ID

@@ -1 +1 @@
-pbDjheefW1LwCua_8mPoZ
+uZHYPdRYOObTZ3MQHekp0