voice-mode 2.32.0__py3-none-any.whl → 2.33.2__py3-none-any.whl

voice_mode/frontend/.next/types/app/api/connection-details/route.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-foqe1vzl/voice_mode-2.32.0/voice_mode/frontend/app/api/connection-details/route.ts
+// File: /tmp/build-via-sdist-tlxizmx7/voice_mode-2.33.2/voice_mode/frontend/app/api/connection-details/route.ts
 import * as entry from '../../../../../app/api/connection-details/route.js'
 import type { NextRequest } from 'next/server.js'
 

voice_mode/frontend/.next/types/app/layout.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-foqe1vzl/voice_mode-2.32.0/voice_mode/frontend/app/layout.tsx
+// File: /tmp/build-via-sdist-tlxizmx7/voice_mode-2.33.2/voice_mode/frontend/app/layout.tsx
 import * as entry from '../../../app/layout.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/.next/types/app/page.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-foqe1vzl/voice_mode-2.32.0/voice_mode/frontend/app/page.tsx
+// File: /tmp/build-via-sdist-tlxizmx7/voice_mode-2.33.2/voice_mode/frontend/app/page.tsx
 import * as entry from '../../../app/page.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/package-lock.json

@@ -1774,9 +1774,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.208",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.208.tgz",
-      "integrity": "sha512-ozZyibehoe7tOhNaf16lKmljVf+3npZcJIEbJRVftVsmAg5TeA1mGS9dVCZzOwr2xT7xK15V0p7+GZqSPgkuPg==",
+      "version": "1.5.209",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.209.tgz",
+      "integrity": "sha512-Xoz0uMrim9ZETCQt8UgM5FxQF9+imA7PBpokoGcZloA1uw2LeHzTlip5cb5KOAsXZLjh/moN2vReN3ZjJmjI9A==",
       "dev": true,
       "license": "ISC"
     },

voice_mode/prompts/converse.py

@@ -10,7 +10,6 @@ def converse() -> str:
         "Using tools from voice-mode, have an ongoing two-way conversation",
         "End the chat when the user indicates they want to end it",
         "Keep your utterances brief unless a longer response is requested or necessary",
-        "Listen for up to 120 seconds per response"
     ]
     
     return "\n".join(f"- {instruction}" for instruction in instructions)

voice_mode/templates/__init__.py

@@ -0,0 +1 @@
+# Templates package for Voice Mode

voice_mode/templates/launchd/com.voicemode.whisper.plist

@@ -1,32 +1,26 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<!-- com.voicemode.whisper.plist v1.0.0 -->
-<!-- Last updated: 2025-01-25 -->
-<!-- Compatible with: whisper.cpp v1.5.0+ -->
+<!-- com.voicemode.whisper.plist v1.1.0 -->
+<!-- Last updated: 2025-08-25 -->
+<!-- Uses unified startup script for dynamic model selection -->
 <plist version="1.0">
 <dict>
     <key>Label</key>
     <string>com.voicemode.whisper</string>
     <key>ProgramArguments</key>
     <array>
-        <string>{WHISPER_BIN}</string>
-        <string>--host</string>
-        <string>0.0.0.0</string>
-        <string>--port</string>
-        <string>{WHISPER_PORT}</string>
-        <string>--model</string>
-        <string>{MODEL_FILE}</string>
+        <string>{START_SCRIPT_PATH}</string>
     </array>
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
     <true/>
     <key>StandardOutPath</key>
-    <string>{LOG_DIR}/whisper.out.log</string>
+    <string>{LOG_DIR}/whisper/whisper.out.log</string>
     <key>StandardErrorPath</key>
-    <string>{LOG_DIR}/whisper.err.log</string>
+    <string>{LOG_DIR}/whisper/whisper.err.log</string>
     <key>WorkingDirectory</key>
-    <string>{WORKING_DIR}</string>
+    <string>{INSTALL_DIR}</string>
     <key>EnvironmentVariables</key>
     <dict>
         <key>PATH</key>

voice_mode/templates/scripts/__init__.py

@@ -0,0 +1 @@
+# Script templates for Voice Mode services

voice_mode/templates/scripts/start-whisper-server.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+
+# Whisper Service Startup Script
+# This script is used by both macOS (launchd) and Linux (systemd) to start the whisper service
+# It sources the voicemode.env file to get configuration, especially VOICEMODE_WHISPER_MODEL
+
+# Determine whisper directory (script is in bin/, whisper root is parent)
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WHISPER_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Voicemode configuration directory
+VOICEMODE_DIR="$HOME/.voicemode"
+LOG_DIR="$VOICEMODE_DIR/logs/whisper"
+
+# Create log directory if it doesn't exist
+mkdir -p "$LOG_DIR"
+
+# Log file for this script (separate from whisper server logs)
+STARTUP_LOG="$LOG_DIR/startup.log"
+
+# Source voicemode configuration if it exists
+if [ -f "$VOICEMODE_DIR/voicemode.env" ]; then
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Sourcing voicemode.env" >> "$STARTUP_LOG"
+    source "$VOICEMODE_DIR/voicemode.env"
+else
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Warning: voicemode.env not found" >> "$STARTUP_LOG"
+fi
+
+# Model selection with environment variable support
+MODEL_NAME="${VOICEMODE_WHISPER_MODEL:-base}"
+MODEL_PATH="$WHISPER_DIR/models/ggml-$MODEL_NAME.bin"
+
+echo "[$(date '+%Y-%m-%d %H:%M:%S')] Starting whisper-server with model: $MODEL_NAME" >> "$STARTUP_LOG"
+
+# Check if model exists
+if [ ! -f "$MODEL_PATH" ]; then
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Error: Model $MODEL_NAME not found at $MODEL_PATH" >> "$STARTUP_LOG"
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Available models:" >> "$STARTUP_LOG"
+    ls -1 "$WHISPER_DIR/models/" 2>/dev/null | grep "^ggml-.*\.bin$" >> "$STARTUP_LOG"
+    
+    # Try to find any available model as fallback
+    FALLBACK_MODEL=$(ls -1 "$WHISPER_DIR/models/" 2>/dev/null | grep "^ggml-.*\.bin$" | head -1)
+    if [ -n "$FALLBACK_MODEL" ]; then
+        MODEL_PATH="$WHISPER_DIR/models/$FALLBACK_MODEL"
+        echo "[$(date '+%Y-%m-%d %H:%M:%S')] Using fallback model: $FALLBACK_MODEL" >> "$STARTUP_LOG"
+    else
+        echo "[$(date '+%Y-%m-%d %H:%M:%S')] Fatal: No whisper models found" >> "$STARTUP_LOG"
+        exit 1
+    fi
+fi
+
+# Port configuration (with environment variable support)
+WHISPER_PORT="${VOICEMODE_WHISPER_PORT:-2022}"
+
+# Determine server binary location
+# Check new CMake build location first, then legacy location
+if [ -f "$WHISPER_DIR/build/bin/whisper-server" ]; then
+    SERVER_BIN="$WHISPER_DIR/build/bin/whisper-server"
+elif [ -f "$WHISPER_DIR/server" ]; then
+    SERVER_BIN="$WHISPER_DIR/server"
+else
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Error: whisper-server binary not found" >> "$STARTUP_LOG"
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Checked: $WHISPER_DIR/build/bin/whisper-server" >> "$STARTUP_LOG"
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Checked: $WHISPER_DIR/server" >> "$STARTUP_LOG"
+    exit 1
+fi
+
+echo "[$(date '+%Y-%m-%d %H:%M:%S')] Using binary: $SERVER_BIN" >> "$STARTUP_LOG"
+echo "[$(date '+%Y-%m-%d %H:%M:%S')] Model path: $MODEL_PATH" >> "$STARTUP_LOG"
+echo "[$(date '+%Y-%m-%d %H:%M:%S')] Port: $WHISPER_PORT" >> "$STARTUP_LOG"
+
+# Start whisper-server
+# Using exec to replace this script process with whisper-server
+cd "$WHISPER_DIR"
+exec "$SERVER_BIN" \
+    --host 0.0.0.0 \
+    --port "$WHISPER_PORT" \
+    --model "$MODEL_PATH" \
+    --inference-path /v1/audio/transcriptions \
+    --threads 8

voice_mode/tools/services/whisper/install.py

@@ -11,6 +11,11 @@ from pathlib import Path
 from typing import Dict, Any, Optional, Union
 import asyncio
 import aiohttp
+try:
+    from importlib.resources import files
+except ImportError:
+    # Python < 3.9 fallback
+    from importlib_resources import files
 
 from voice_mode.server import mcp
 from voice_mode.config import SERVICE_AUTO_ENABLE
@@ -28,7 +33,7 @@ logger = logging.getLogger("voice-mode")
 @mcp.tool()
 async def whisper_install(
     install_dir: Optional[str] = None,
-    model: str = "large-v2",
+    model: str = "base",
     use_gpu: Optional[Union[bool, str]] = None,
     force_reinstall: Union[bool, str] = False,
     auto_enable: Optional[Union[bool, str]] = None,
@@ -42,7 +47,7 @@ async def whisper_install(
     Args:
         install_dir: Directory to install whisper.cpp (default: ~/.voicemode/whisper.cpp)
         model: Whisper model to download (tiny, base, small, medium, large-v2, large-v3, etc.)
-               Default is large-v2 for best accuracy. Note: large models require ~3GB RAM.
+               Default is base for good balance of speed and accuracy (142MB).
         use_gpu: Enable GPU support if available (default: auto-detect)
         force_reinstall: Force reinstallation even if already installed
         auto_enable: Enable service after install. If None, uses VOICEMODE_SERVICE_AUTO_ENABLE config.
@@ -214,7 +219,8 @@ async def whisper_install(
         if is_macos:
             # On macOS, always enable Metal
             cmake_flags.append("-DGGML_METAL=ON")
-            # On Apple Silicon, also enable Core ML for better performance
+            # On Apple Silicon, also enable Core ML support with fallback
+            # This allows using CoreML models if available, but falls back to Metal if not
             if platform.machine() == "arm64":
                 cmake_flags.append("-DWHISPER_COREML=ON")
                 cmake_flags.append("-DWHISPER_COREML_ALLOW_FALLBACK=ON")
@@ -302,59 +308,34 @@ async def whisper_install(
         if 'original_dir' in locals():
             os.chdir(original_dir)
         
-        # Create start script for whisper-server
-        logger.info("Creating whisper-server start script...")
-        start_script_content = f"""#!/bin/bash
-
-# Configuration
-WHISPER_DIR="{install_dir}"
-LOG_FILE="{os.path.join(voicemode_dir, 'whisper-server.log')}"
-
-# Source voicemode configuration if it exists
-if [ -f "{voicemode_dir}/voicemode.env" ]; then
-    source "{voicemode_dir}/voicemode.env"
-fi
-
-# Model selection with environment variable support
-MODEL_NAME="${{VOICEMODE_WHISPER_MODEL:-{model}}}"
-MODEL_PATH="$WHISPER_DIR/models/ggml-$MODEL_NAME.bin"
-
-# Check if model exists
-if [ ! -f "$MODEL_PATH" ]; then
-    echo "Error: Model $MODEL_NAME not found at $MODEL_PATH" >> "$LOG_FILE"
-    echo "Available models:" >> "$LOG_FILE"
-    ls -1 "$WHISPER_DIR/models/" | grep "^ggml-.*\\.bin$" >> "$LOG_FILE"
-    exit 1
-fi
-
-echo "Starting whisper-server with model: $MODEL_NAME" >> "$LOG_FILE"
-
-# Note: whisper-server is now built as part of the main build target
-
-# Determine server binary location
-if [ -f "$WHISPER_DIR/build/bin/whisper-server" ]; then
-    SERVER_BIN="$WHISPER_DIR/build/bin/whisper-server"
-elif [ -f "$WHISPER_DIR/server" ]; then
-    SERVER_BIN="$WHISPER_DIR/server"
-else
-    echo "Error: whisper-server binary not found" >> "$LOG_FILE"
-    exit 1
-fi
-
-# Start whisper-server
-cd "$WHISPER_DIR"
-exec "$SERVER_BIN" \\
-    --model "$MODEL_PATH" \\
-    --host 0.0.0.0 \\
-    --port 2022 \\
-    --inference-path /v1/audio/transcriptions \\
-    --threads 8 \\
-    >> "$LOG_FILE" 2>&1
-"""
-        
-        start_script_path = os.path.join(install_dir, "start-whisper-server.sh")
+        # Copy template start script for whisper-server
+        logger.info("Installing whisper-server start script from template...")
+        
+        # Create bin directory
+        bin_dir = os.path.join(install_dir, "bin")
+        os.makedirs(bin_dir, exist_ok=True)
+        
+        # Copy template script
+        template_content = None
+        
+        # First try to load from source if running in development
+        source_template = Path(__file__).parent.parent.parent / "templates" / "scripts" / "start-whisper-server.sh"
+        if source_template.exists():
+            logger.info(f"Loading template from source: {source_template}")
+            template_content = source_template.read_text()
+        else:
+            # Try loading from package resources
+            try:
+                template_resource = files("voice_mode.templates.scripts").joinpath("start-whisper-server.sh")
+                template_content = template_resource.read_text()
+                logger.info("Loaded template from package resources")
+            except Exception as e:
+                logger.warning(f"Failed to load template script: {e}. Using fallback inline script.")
+        
+        # Create the start script (whether template was loaded from file or created inline)
+        start_script_path = os.path.join(bin_dir, "start-whisper-server.sh")
         with open(start_script_path, 'w') as f:
-            f.write(start_script_content)
+            f.write(template_content)
         os.chmod(start_script_path, 0o755)
         
         # Install launchagent on macOS
@@ -370,33 +351,22 @@ exec "$SERVER_BIN" \\
             plist_name = "com.voicemode.whisper.plist"
             plist_path = os.path.join(launchagents_dir, plist_name)
             
-            plist_content = f"""<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>com.voicemode.whisper</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>{start_script_path}</string>
-    </array>
-    <key>WorkingDirectory</key>
-    <string>{install_dir}</string>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>StandardOutPath</key>
-    <string>{os.path.join(voicemode_dir, 'logs', 'whisper', 'whisper.out.log')}</string>
-    <key>StandardErrorPath</key>
-    <string>{os.path.join(voicemode_dir, 'logs', 'whisper', 'whisper.err.log')}</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin</string>
-    </dict>
-</dict>
-</plist>"""
+            # Load plist template
+            # First try to load from source if running in development
+            source_template = Path(__file__).parent.parent.parent / "templates" / "launchd" / "com.voicemode.whisper.plist"
+            if source_template.exists():
+                logger.info(f"Loading plist template from source: {source_template}")
+                plist_content = source_template.read_text()
+            else:
+                # Load from package resources
+                template_resource = files("voice_mode.templates.launchd").joinpath("com.voicemode.whisper.plist")
+                plist_content = template_resource.read_text()
+                logger.info("Loaded plist template from package resources")
+            
+            # Replace placeholders
+            plist_content = plist_content.replace("{START_SCRIPT_PATH}", start_script_path)
+            plist_content = plist_content.replace("{LOG_DIR}", os.path.join(voicemode_dir, 'logs'))
+            plist_content = plist_content.replace("{INSTALL_DIR}", install_dir)
             
             with open(plist_path, 'w') as f:
                 f.write(plist_content)
@@ -444,9 +414,8 @@ exec "$SERVER_BIN" \\
                 "start_script": start_script_path,
                 "message": f"Successfully installed whisper.cpp {current_version} with {gpu_type} support and whisper-server on port 2022{enable_message}{' (' + migration_msg + ')' if migration_msg else ''}"
             }
-        
-        # Install systemd service on Linux
         elif system == "Linux":
+            # Install systemd service on Linux
             logger.info("Installing systemd user service for whisper-server...")
             systemd_user_dir = os.path.expanduser("~/.config/systemd/user")
             os.makedirs(systemd_user_dir, exist_ok=True)
@@ -459,23 +428,22 @@ exec "$SERVER_BIN" \\
             service_path = os.path.join(systemd_user_dir, service_name)
             
             service_content = f"""[Unit]
-Description=Whisper.cpp Speech Recognition Server
-After=network.target
+    Description=Whisper.cpp Speech Recognition Server
+    After=network.target
 
-[Service]
-Type=simple
-ExecStart={start_script_path}
-Restart=on-failure
-RestartSec=10
-WorkingDirectory={install_dir}
-StandardOutput=append:{os.path.join(voicemode_dir, 'logs', 'whisper', 'whisper.out.log')}
-StandardError=append:{os.path.join(voicemode_dir, 'logs', 'whisper', 'whisper.err.log')}
-Environment="PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/cuda/bin"
-Environment="VOICEMODE_WHISPER_MODEL={model}"
+    [Service]
+    Type=simple
+    ExecStart={start_script_path}
+    Restart=on-failure
+    RestartSec=10
+    WorkingDirectory={install_dir}
+    StandardOutput=append:{os.path.join(voicemode_dir, 'logs', 'whisper', 'whisper.out.log')}
+    StandardError=append:{os.path.join(voicemode_dir, 'logs', 'whisper', 'whisper.err.log')}
+    Environment="PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/cuda/bin"
 
-[Install]
-WantedBy=default.target
-"""
+    [Install]
+    WantedBy=default.target
+    """
             
             with open(service_path, 'w') as f:
                 f.write(service_content)
@@ -510,49 +478,49 @@ WantedBy=default.target
             current_version = get_current_version(Path(install_dir))
             return {
                 "success": True,
-                "install_path": install_dir,
-                "model_path": model_path,
-                "gpu_enabled": use_gpu,
-                "gpu_type": gpu_type,
-                "version": current_version,
-                "performance_info": {
-                    "system": system,
-                    "gpu_acceleration": gpu_type,
-                    "model": model,
-                    "binary_path": main_path if 'main_path' in locals() else os.path.join(install_dir, "main"),
-                    "server_port": 2022,
-                    "server_url": "http://localhost:2022"
-                },
-                "systemd_service": service_path,
-                "systemd_enabled": systemd_enabled,
-                "start_script": start_script_path,
-                "message": f"Successfully installed whisper.cpp {current_version} with {gpu_type} support. {systemd_message}{enable_message}{' (' + migration_msg + ')' if migration_msg else ''}"
+            "install_path": install_dir,
+            "model_path": model_path,
+            "gpu_enabled": use_gpu,
+            "gpu_type": gpu_type,
+            "version": current_version,
+            "performance_info": {
+                "system": system,
+                "gpu_acceleration": gpu_type,
+                "model": model,
+                "binary_path": main_path if 'main_path' in locals() else os.path.join(install_dir, "main"),
+                "server_port": 2022,
+                "server_url": "http://localhost:2022"
+            },
+            "systemd_service": service_path,
+            "systemd_enabled": systemd_enabled,
+            "start_script": start_script_path,
+            "message": f"Successfully installed whisper.cpp {current_version} with {gpu_type} support. {systemd_message}{enable_message}{' (' + migration_msg + ')' if migration_msg else ''}"
             }
-        
+    
         else:
             # Handle auto_enable for other systems (if we add Windows support later)
             enable_message = ""
             if auto_enable is None:
-                auto_enable = SERVICE_AUTO_ENABLE
+              auto_enable = SERVICE_AUTO_ENABLE
             
             if auto_enable:
-                logger.info("Auto-enable not supported on this platform")
+              logger.info("Auto-enable not supported on this platform")
             
             current_version = get_current_version(Path(install_dir))
             return {
                 "success": True,
-                "install_path": install_dir,
-                "model_path": model_path,
-                "gpu_enabled": use_gpu,
-                "gpu_type": gpu_type,
-                "version": current_version,
-                "performance_info": {
-                    "system": system,
-                    "gpu_acceleration": gpu_type,
-                    "model": model,
-                    "binary_path": main_path if 'main_path' in locals() else os.path.join(install_dir, "main")
-                },
-                "message": f"Successfully installed whisper.cpp {current_version} with {gpu_type} support{enable_message}{' (' + migration_msg + ')' if migration_msg else ''}"
+            "install_path": install_dir,
+            "model_path": model_path,
+            "gpu_enabled": use_gpu,
+            "gpu_type": gpu_type,
+            "version": current_version,
+            "performance_info": {
+                "system": system,
+                "gpu_acceleration": gpu_type,
+                "model": model,
+                "binary_path": main_path if 'main_path' in locals() else os.path.join(install_dir, "main")
+            },
+            "message": f"Successfully installed whisper.cpp {current_version} with {gpu_type} support{enable_message}{' (' + migration_msg + ')' if migration_msg else ''}"
             }
         
     except subprocess.CalledProcessError as e:
@@ -569,4 +537,4 @@ WantedBy=default.target
         return {
             "success": False,
             "error": str(e)
-        }
+        }

voice_mode/tools/services/whisper/model_install.py

@@ -127,7 +127,8 @@ async def whisper_model_install(
             result = await download_whisper_model(
                 model_name,
                 actual_models_dir,
-                force_download=force_download
+                force_download=force_download,
+                skip_core_ml=skip_core_ml
             )
             
             # Build comprehensive result entry
@@ -242,58 +243,48 @@ async def _handle_coreml_dependencies(
     if skip_core_ml:
         return {"continue": True}
     
-    # Check if torch is already installed
-    try:
-        import torch
-        logger.info("PyTorch already installed for CoreML support")
-        return {"continue": True}
-    except ImportError:
-        pass
+    # Check if the CoreML environment already exists
+    whisper_dir = Path.home() / ".voicemode" / "services" / "whisper"
+    venv_coreml = whisper_dir / "venv-coreml" / "bin" / "python"
+    
+    if venv_coreml.exists():
+        # Test if it has the required packages
+        try:
+            result = subprocess.run(
+                [str(venv_coreml), "-c", "import torch, coremltools, whisper"],
+                capture_output=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                logger.info("CoreML environment already exists and is valid")
+                # Return with a flag indicating CoreML is ready
+                return {
+                    "continue": True,
+                    "coreml_ready": True,
+                    "coreml_deps_note": "CoreML environment exists and is valid"
+                }
+        except:
+            pass
     
-    # Check if user wants to install torch
+    # Check if user wants to create CoreML environment
     if not install_torch and not auto_confirm:
         return {
             "continue": False,
             "success": False,
             "requires_confirmation": True,
-            "message": "CoreML requires PyTorch (~2.5GB). Rerun with install_torch=True to confirm.",
-            "recommendation": "Set install_torch=True for CoreML acceleration (2-3x faster)"
+            "message": "CoreML conversion requires a dedicated Python environment with PyTorch. Setup may download up to 2.5GB if packages aren't cached.",
+            "recommendation": "💡 Set install_torch=True for CoreML acceleration (2-3x faster)"
         }
     
-    # Install CoreML dependencies
-    logger.info("Installing CoreML dependencies...")
+    # Note: We don't actually install CoreML dependencies in the voicemode environment anymore
+    # The CoreML conversion uses its own dedicated environment in ~/.voicemode/services/whisper/venv-coreml
+    # This is handled automatically by whisper_helpers.convert_to_coreml()
     
-    try:
-        # Detect environment and install appropriately
-        packages = ["torch>=2.0.0", "coremltools>=7.0", "transformers", "ane-transformers"]
-        
-        # Try UV first (most common)
-        if subprocess.run(["which", "uv"], capture_output=True).returncode == 0:
-            cmd = ["uv", "pip", "install"] + packages
-            logger.info("Installing via UV...")
-        else:
-            # Fallback to pip
-            cmd = [sys.executable, "-m", "pip", "install"] + packages
-            logger.info("Installing via pip...")
-        
-        # Run installation
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            logger.info("CoreML dependencies installed successfully")
-            return {"continue": True, "coreml_deps_installed": True}
-        else:
-            logger.warning(f"Failed to install CoreML dependencies: {result.stderr}")
-            return {
-                "continue": True,
-                "coreml_deps_failed": True,
-                "warning": "CoreML dependencies installation failed. Models will use Metal acceleration."
-            }
-            
-    except Exception as e:
-        logger.warning(f"Error installing CoreML dependencies: {e}")
-        return {
-            "continue": True,
-            "coreml_deps_failed": True,
-            "warning": f"CoreML setup error: {str(e)}. Models will use Metal acceleration."
-        }
+    logger.info("CoreML dependencies will be handled by the conversion process")
+    
+    # We still return success to continue with the model download
+    # The actual CoreML environment setup happens during conversion
+    return {
+        "continue": True,
+        "coreml_deps_note": "CoreML environment will be created during conversion if needed"
+    }

voice_mode/tools/services/whisper/models.py

@@ -113,7 +113,7 @@ def get_active_model() -> str:
     
     # Validate it's a known model
     if model not in WHISPER_MODEL_REGISTRY:
-        return "large-v2"  # Default fallback
+        return "base"  # Default fallback
     
     return model