voice-mode 2.32.0__py3-none-any.whl → 2.33.0__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-wr79qxwc/voice_mode-2.33.0/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-wr79qxwc/voice_mode-2.33.0/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-wr79qxwc/voice_mode-2.33.0/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/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/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.
@@ -302,59 +307,117 @@ 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
+        # 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.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.")
+        
+        # Fallback to inline script if template not found
+        if template_content is None:
+            template_content = f"""#!/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"
 
-# Configuration
-WHISPER_DIR="{install_dir}"
-LOG_FILE="{os.path.join(voicemode_dir, 'whisper-server.log')}"
+# 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
-    source "{voicemode_dir}/voicemode.env"
+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:-{model}}}"
+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 "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
+    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
 
-echo "Starting whisper-server with model: $MODEL_NAME" >> "$LOG_FILE"
-
-# Note: whisper-server is now built as part of the main build target
+# 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 "Error: whisper-server binary not found" >> "$LOG_FILE"
+    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" \\
-    --model "$MODEL_PATH" \\
     --host 0.0.0.0 \\
-    --port 2022 \\
+    --port "$WHISPER_PORT" \\
+    --model "$MODEL_PATH" \\
     --inference-path /v1/audio/transcriptions \\
-    --threads 8 \\
-    >> "$LOG_FILE" 2>&1
+    --threads 8
 """
         
-        start_script_path = os.path.join(install_dir, "start-whisper-server.sh")
+        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
@@ -471,7 +534,6 @@ 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}"
 
 [Install]
 WantedBy=default.target

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
 

voice_mode/utils/services/coreml_setup.py

@@ -0,0 +1,234 @@
+"""Setup and manage CoreML Python environment for whisper.cpp."""
+
+import os
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger("voice-mode")
+
+
+def setup_coreml_venv(whisper_dir: Path, force: bool = False) -> Dict[str, Any]:
+    """
+    Setup a dedicated Python virtual environment for CoreML conversion.
+    
+    Uses whisper.cpp's requirements-coreml.txt to ensure compatibility.
+    
+    Args:
+        whisper_dir: Path to whisper.cpp installation
+        force: Force recreation of venv even if it exists
+        
+    Returns:
+        Dict with 'success' and 'python_path' or 'error'
+    """
+    venv_dir = whisper_dir / "venv-coreml"
+    venv_python = venv_dir / "bin" / "python"
+    requirements_file = whisper_dir / "models" / "requirements-coreml.txt"
+    
+    # Check if requirements file exists
+    if not requirements_file.exists():
+        return {
+            "success": False,
+            "error": f"CoreML requirements file not found at {requirements_file}"
+        }
+    
+    # Check if venv already exists and is valid
+    if venv_python.exists() and not force:
+        # Test if the venv has the required packages
+        try:
+            result = subprocess.run(
+                [str(venv_python), "-c", "import torch, coremltools, whisper, ane_transformers"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                logger.info(f"CoreML venv already exists and is valid at {venv_dir}")
+                return {
+                    "success": True,
+                    "python_path": str(venv_python),
+                    "message": "Using existing CoreML virtual environment"
+                }
+        except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+            logger.info("Existing CoreML venv is incomplete, will recreate")
+    
+    # Create or recreate venv
+    logger.info(f"Creating CoreML virtual environment at {venv_dir}")
+    
+    try:
+        # Remove existing venv if force or invalid
+        if venv_dir.exists() and (force or not venv_python.exists()):
+            import shutil
+            shutil.rmtree(venv_dir, ignore_errors=True)
+        
+        # Try to use Python 3.11 as recommended by whisper.cpp
+        python_cmd = None
+        for python_version in ["python3.11", "python3.10", "python3.9", "python3"]:
+            if subprocess.run(["which", python_version], capture_output=True).returncode == 0:
+                # Check actual version
+                version_result = subprocess.run(
+                    [python_version, "--version"],
+                    capture_output=True,
+                    text=True
+                )
+                if version_result.returncode == 0:
+                    version = version_result.stdout.strip()
+                    logger.info(f"Found {version}")
+                    # Strongly prefer 3.11 as recommended
+                    if "3.11" in version:
+                        python_cmd = python_version
+                        logger.info("Using Python 3.11 (recommended for CoreML)")
+                        break
+                    elif "3.10" in version or "3.9" in version:
+                        if python_cmd is None:  # Use as fallback if no 3.11
+                            python_cmd = python_version
+                    elif python_cmd is None:
+                        python_cmd = python_version  # Use as last resort
+        
+        if python_cmd is None:
+            return {
+                "success": False,
+                "error": "No suitable Python version found. Python 3.9-3.11 recommended for CoreML."
+            }
+        
+        # Create venv
+        logger.info(f"Creating venv with {python_cmd}")
+        result = subprocess.run(
+            [python_cmd, "-m", "venv", str(venv_dir)],
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            return {
+                "success": False,
+                "error": f"Failed to create venv: {result.stderr}"
+            }
+        
+        # Upgrade pip
+        logger.info("Upgrading pip in CoreML venv")
+        subprocess.run(
+            [str(venv_python), "-m", "pip", "install", "--upgrade", "pip"],
+            capture_output=True,
+            text=True
+        )
+        
+        # Install requirements with proper versions
+        # Based on whisper.cpp documentation and coremltools compatibility
+        # Python 3.11 is recommended, torch 2.5.0 is known to work with coremltools
+        logger.info("Installing CoreML requirements with compatible versions")
+        packages = [
+            "torch==2.5.0",  # Specific version mentioned in whisper.cpp for coremltools compatibility
+            "coremltools>=7.0",
+            "openai-whisper",
+            "ane_transformers"
+        ]
+        
+        # Try installing all at once first
+        result = subprocess.run(
+            [str(venv_python), "-m", "pip", "install"] + packages,
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            # Try installing packages one by one if bulk install fails
+            logger.warning("Bulk install failed, trying packages individually")
+            
+            failed_packages = []
+            for package in packages:
+                logger.info(f"Installing {package}")
+                result = subprocess.run(
+                    [str(venv_python), "-m", "pip", "install", package],
+                    capture_output=True,
+                    text=True
+                )
+                if result.returncode != 0:
+                    logger.warning(f"Failed to install {package}: {result.stderr}")
+                    failed_packages.append(package)
+            
+            if failed_packages:
+                return {
+                    "success": False,
+                    "error": f"Failed to install packages: {', '.join(failed_packages)}",
+                    "partial": True,
+                    "python_path": str(venv_python)
+                }
+        
+        # Verify installation
+        logger.info("Verifying CoreML dependencies")
+        result = subprocess.run(
+            [str(venv_python), "-c", "import torch, coremltools, whisper, ane_transformers; print('All packages imported successfully')"],
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode == 0:
+            logger.info("CoreML virtual environment created successfully")
+            return {
+                "success": True,
+                "python_path": str(venv_python),
+                "message": "CoreML virtual environment created with all dependencies"
+            }
+        else:
+            return {
+                "success": True,  # Partial success
+                "python_path": str(venv_python),
+                "warning": "Some packages may be missing but environment was created",
+                "verification_error": result.stderr
+            }
+            
+    except Exception as e:
+        logger.error(f"Error setting up CoreML venv: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+def get_coreml_python(whisper_dir: Path) -> Optional[str]:
+    """
+    Get the path to Python executable with CoreML dependencies.
+    
+    Checks in order:
+    1. Dedicated venv-coreml environment
+    2. Existing venv environment (if it has CoreML packages)
+    3. None if no suitable environment found
+    
+    Args:
+        whisper_dir: Path to whisper.cpp installation
+        
+    Returns:
+        Path to Python executable or None
+    """
+    # Check dedicated CoreML venv first
+    venv_coreml_python = whisper_dir / "venv-coreml" / "bin" / "python"
+    if venv_coreml_python.exists():
+        # Quick check if it has required packages
+        try:
+            result = subprocess.run(
+                [str(venv_coreml_python), "-c", "import torch, coremltools"],
+                capture_output=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                return str(venv_coreml_python)
+        except:
+            pass
+    
+    # Check existing venv as fallback
+    venv_python = whisper_dir / "venv" / "bin" / "python"
+    if venv_python.exists():
+        try:
+            result = subprocess.run(
+                [str(venv_python), "-c", "import torch, coremltools, whisper"],
+                capture_output=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                return str(venv_python)
+        except:
+            pass
+    
+    return None