voice-mode 2.27.0__py3-none-any.whl → 2.28.1__py3-none-any.whl

voice_mode/tools/services/whisper/{download_model.py → model_install.py}

@@ -14,7 +14,7 @@ logger = logging.getLogger("voice-mode")
 
 
 @mcp.tool()
-async def download_model(
+async def whisper_model_install(
     model: Union[str, List[str]] = "large-v2",
     force_download: Union[bool, str] = False,
     skip_core_ml: Union[bool, str] = False
@@ -109,11 +109,32 @@ async def download_model(
                 force_download=force_download
             )
             
-            results.append({
+            # Build comprehensive result entry
+            model_result = {
                 "model": model_name,
-                "success": result["success"],
-                "message": result.get("message", result.get("error", "Unknown error"))
-            })
+                "download_success": result["success"],
+                "message": result.get("message", result.get("error", "Unknown error")),
+                "acceleration": result.get("acceleration", "unknown")
+            }
+            
+            # Include Core ML status if available
+            if "core_ml_status" in result and not skip_core_ml:
+                core_ml = result["core_ml_status"]
+                model_result["core_ml"] = {
+                    "attempted": True,
+                    "success": core_ml.get("success", False),
+                    "error_category": core_ml.get("error_category") if not core_ml.get("success") else None,
+                    "error": core_ml.get("error") if not core_ml.get("success") else None,
+                    "fix_command": core_ml.get("install_command") if not core_ml.get("success") else None,
+                    "package_size": core_ml.get("package_size") if not core_ml.get("success") else None
+                }
+            elif skip_core_ml:
+                model_result["core_ml"] = {
+                    "attempted": False,
+                    "reason": "Skipped by user request"
+                }
+            
+            results.append(model_result)
             
             if result["success"]:
                 success_count += 1
@@ -121,18 +142,58 @@ async def download_model(
         # Summary
         total_models = len(models_to_download)
         
-        return json.dumps({
+        # Collect warnings and recommendations
+        warnings = []
+        recommendations = []
+        
+        # Check for Core ML issues
+        core_ml_failures = [r for r in results if r.get("core_ml", {}).get("attempted") and not r.get("core_ml", {}).get("success")]
+        if core_ml_failures:
+            # Group by error category
+            error_categories = {}
+            for failure in core_ml_failures:
+                category = failure["core_ml"].get("error_category", "unknown")
+                if category not in error_categories:
+                    error_categories[category] = failure["core_ml"]
+            
+            # Add warnings for each category
+            if "missing_pytorch" in error_categories:
+                warnings.append("PyTorch not installed - Core ML acceleration unavailable")
+                recommendations.append(f"Install PyTorch for Core ML: {error_categories['missing_pytorch'].get('fix_command', 'uv pip install torch')}")
+            elif "missing_coremltools" in error_categories:
+                warnings.append("CoreMLTools not installed - Core ML acceleration unavailable")
+                recommendations.append(f"Install CoreMLTools: {error_categories['missing_coremltools'].get('fix_command', 'uv pip install coremltools')}")
+            
+            # General Core ML recommendation
+            if len(core_ml_failures) == len(results):
+                recommendations.append("Models will use Metal acceleration. Core ML provides better performance on Apple Silicon.")
+        
+        summary = {
             "success": success_count > 0,
             "models_directory": str(actual_models_dir),
             "total_requested": total_models,
             "successful_downloads": success_count,
             "failed_downloads": total_models - success_count,
             "results": results,
-            "core_ml_enabled": not skip_core_ml and os.uname().machine == "arm64",
-            "recommendation": "Models downloaded successfully. You can now use them with whisper_start."
-            if success_count == total_models
-            else "Some models failed to download. Check the results for details."
-        }, indent=2)
+            "core_ml_available": not skip_core_ml and os.uname().machine == "arm64",
+        }
+        
+        # Add warnings and recommendations if present
+        if warnings:
+            summary["warnings"] = warnings
+        if recommendations:
+            summary["recommendations"] = recommendations
+        
+        # Add overall status message
+        if success_count == total_models:
+            if core_ml_failures:
+                summary["status"] = "Models downloaded successfully but Core ML conversion failed. Using Metal acceleration."
+            else:
+                summary["status"] = "Models downloaded and converted successfully. Ready to use with whisper_start."
+        else:
+            summary["status"] = "Some models failed to download. Check the results for details."
+        
+        return json.dumps(summary, indent=2)
         
     except Exception as e:
         logger.error(f"Error in download_model: {e}")

voice_mode/tools/services/whisper/model_remove.py

@@ -0,0 +1,36 @@
+"""MCP tool for removing Whisper models."""
+
+from typing import Dict, Any
+from voice_mode.tools.services.whisper.models import (
+    remove_whisper_model,
+    get_active_model,
+    format_size
+)
+
+
+async def whisper_model_remove(model_name: str, remove_coreml: bool = True) -> Dict[str, Any]:
+    """Remove an installed Whisper model.
+    
+    Args:
+        model_name: Name of model to remove
+        remove_coreml: Also remove Core ML version if exists
+        
+    Returns:
+        Dict with removal status
+    """
+    # Check if trying to remove active model
+    if model_name == get_active_model():
+        return {
+            "success": False,
+            "error": f"Cannot remove active model {model_name}. Set a different model as active first using whisper_model_active()"
+        }
+    
+    # Remove the model
+    result = remove_whisper_model(model_name, remove_coreml)
+    
+    # Format the result for better readability
+    if result["success"]:
+        result["space_freed_formatted"] = format_size(result.get("space_freed_mb", 0))
+        result["message"] = f"Successfully removed model {model_name}"
+    
+    return result

voice_mode/tools/services/whisper/models.py

@@ -1,8 +1,9 @@
 """Whisper model registry and utilities."""
 
 import os
+import warnings
 from pathlib import Path
-from typing import Dict, List, Optional, TypedDict
+from typing import Any, Dict, List, Optional, TypedDict
 from voice_mode.config import WHISPER_MODEL_PATH, WHISPER_MODEL
 
 
@@ -15,7 +16,7 @@ class ModelInfo(TypedDict):
 
 
 # Registry of all available Whisper models
-WHISPER_MODELS: Dict[str, ModelInfo] = {
+WHISPER_MODEL_REGISTRY: Dict[str, ModelInfo] = {
     "tiny": {
         "size_mb": 39,
         "languages": "Multilingual",
@@ -105,32 +106,32 @@ def get_model_directory() -> Path:
     return model_dir
 
 
-def get_current_model() -> str:
+def get_active_model() -> str:
     """Get the currently selected Whisper model."""
     # Use the configured model from config.py
     model = WHISPER_MODEL
     
     # Validate it's a known model
-    if model not in WHISPER_MODELS:
+    if model not in WHISPER_MODEL_REGISTRY:
         return "large-v2"  # Default fallback
     
     return model
 
 
-def is_model_installed(model_name: str) -> bool:
-    """Check if a model is installed."""
-    if model_name not in WHISPER_MODELS:
+def is_whisper_model_installed(model_name: str) -> bool:
+    """Check if a Whisper model is installed."""
+    if model_name not in WHISPER_MODEL_REGISTRY:
         return False
     
     model_dir = get_model_directory()
-    model_info = WHISPER_MODELS[model_name]
+    model_info = WHISPER_MODEL_REGISTRY[model_name]
     model_path = model_dir / model_info["filename"]
     
     return model_path.exists()
 
 
-def has_coreml_model(model_name: str) -> bool:
-    """Check if a Core ML model is available for the given model.
+def has_whisper_coreml_model(model_name: str) -> bool:
+    """Check if a Core ML model is available for the given Whisper model.
     
     Core ML models are only used on macOS with Apple Silicon.
     They have the extension .mlmodelc and provide faster inference.
@@ -141,23 +142,25 @@ def has_coreml_model(model_name: str) -> bool:
     if platform.system() != "Darwin":
         return False
     
-    if model_name not in WHISPER_MODELS:
+    if model_name not in WHISPER_MODEL_REGISTRY:
         return False
     
     model_dir = get_model_directory()
-    model_info = WHISPER_MODELS[model_name]
+    model_info = WHISPER_MODEL_REGISTRY[model_name]
     
-    # Core ML model would be named like ggml-large-v2-encoder.mlmodelc
-    coreml_path = model_dir / f"ggml-{model_name}-encoder.mlmodelc"
+    # Core ML models can be either compiled (.mlmodelc) or package (.mlpackage)
+    # Check for both formats
+    coreml_compiled = model_dir / f"ggml-{model_name}-encoder.mlmodelc"
+    coreml_package = model_dir / f"coreml-encoder-{model_name}.mlpackage"
     
-    return coreml_path.exists()
+    return coreml_compiled.exists() or coreml_package.exists()
 
 
-def get_installed_models() -> List[str]:
-    """Get list of installed models."""
+def get_installed_whisper_models() -> List[str]:
+    """Get list of installed Whisper models."""
     installed = []
-    for model_name in WHISPER_MODELS:
-        if is_model_installed(model_name):
+    for model_name in WHISPER_MODEL_REGISTRY:
+        if is_whisper_model_installed(model_name):
             installed.append(model_name)
     return installed
 
@@ -172,12 +175,12 @@ def get_total_size(models: Optional[List[str]] = None) -> int:
         Total size in MB
     """
     if models is None:
-        models = list(WHISPER_MODELS.keys())
+        models = list(WHISPER_MODEL_REGISTRY.keys())
     
     total = 0
     for model in models:
-        if model in WHISPER_MODELS:
-            total += WHISPER_MODELS[model]["size_mb"]
+        if model in WHISPER_MODEL_REGISTRY:
+            total += WHISPER_MODEL_REGISTRY[model]["size_mb"]
     
     return total
 
@@ -203,8 +206,8 @@ def is_apple_silicon() -> bool:
     return platform.system() == "Darwin" and platform.machine() == "arm64"
 
 
-def set_current_model(model_name: str) -> None:
-    """Set the current active Whisper model.
+def set_active_model(model_name: str) -> None:
+    """Set the active Whisper model.
     
     Args:
         model_name: Name of the model to set as active
@@ -215,7 +218,7 @@ def set_current_model(model_name: str) -> None:
     import re
     
     # Configuration file path
-    config_path = Path.home() / ".voicemode" / ".voicemode.env"
+    config_path = Path.home() / ".voicemode" / "voicemode.env"
     
     # Ensure directory exists
     config_path.parent.mkdir(parents=True, exist_ok=True)
@@ -271,4 +274,200 @@ def set_current_model(model_name: str) -> None:
     
     # Write the updated configuration
     with open(config_path, 'w') as f:
-        f.writelines(lines)
+        f.writelines(lines)
+
+
+def remove_whisper_model(model_name: str, remove_coreml: bool = True) -> Dict[str, Any]:
+    """Remove a whisper model and optionally its Core ML version.
+    
+    Args:
+        model_name: Name of the model to remove
+        remove_coreml: Also remove Core ML version if it exists
+        
+    Returns:
+        Dict with success status and space freed
+    """
+    model_dir = get_model_directory()
+    
+    if model_name not in WHISPER_MODEL_REGISTRY:
+        return {"success": False, "error": f"Model {model_name} not recognized"}
+    
+    model_info = WHISPER_MODEL_REGISTRY[model_name]
+    model_file = model_dir / model_info["filename"]
+    
+    if not model_file.exists():
+        return {"success": False, "error": f"Model {model_name} not found"}
+    
+    space_freed = model_file.stat().st_size
+    model_file.unlink()
+    
+    if remove_coreml and has_whisper_coreml_model(model_name):
+        # Remove both possible Core ML formats
+        coreml_compiled = model_dir / f"ggml-{model_name}-encoder.mlmodelc"
+        coreml_package = model_dir / f"coreml-encoder-{model_name}.mlpackage"
+        
+        if coreml_compiled.exists():
+            import shutil
+            shutil.rmtree(coreml_compiled)
+            # Estimate size since it's a directory
+            space_freed += 100 * 1024 * 1024  # Approximate 100MB
+            
+        if coreml_package.exists():
+            import shutil
+            shutil.rmtree(coreml_package)
+            space_freed += 100 * 1024 * 1024  # Approximate 100MB
+    
+    return {
+        "success": True,
+        "model": model_name,
+        "space_freed": space_freed,
+        "space_freed_mb": space_freed // (1024 * 1024)
+    }
+
+
+def benchmark_whisper_model(model_name: str, sample_file: Optional[str] = None) -> Dict[str, Any]:
+    """Run performance benchmark on a whisper model.
+    
+    Args:
+        model_name: Name of the model to benchmark
+        sample_file: Optional audio file to use (defaults to JFK sample)
+        
+    Returns:
+        Dict with benchmark results
+    """
+    import subprocess
+    import re
+    from pathlib import Path
+    
+    if not is_whisper_model_installed(model_name):
+        return {
+            "success": False,
+            "error": f"Model {model_name} is not installed"
+        }
+    
+    # Find whisper-cli binary
+    whisper_bin = Path.home() / ".voicemode" / "services" / "whisper" / "build" / "bin" / "whisper-cli"
+    if not whisper_bin.exists():
+        return {
+            "success": False,
+            "error": "Whisper CLI not found. Please install whisper.cpp first."
+        }
+    
+    # Use sample file or default JFK sample
+    if sample_file is None:
+        sample_file = Path.home() / ".voicemode" / "services" / "whisper" / "samples" / "jfk.wav"
+        if not sample_file.exists():
+            return {
+                "success": False,
+                "error": "Default sample file not found"
+            }
+    
+    model_dir = get_model_directory()
+    model_info = WHISPER_MODEL_REGISTRY[model_name]
+    model_path = model_dir / model_info["filename"]
+    
+    # Run benchmark
+    try:
+        result = subprocess.run(
+            [
+                str(whisper_bin),
+                "--model", str(model_path),
+                "--file", str(sample_file),
+                "--threads", "8",
+                "--beam-size", "1"
+            ],
+            capture_output=True,
+            text=True,
+            timeout=60
+        )
+        
+        # Parse timing information
+        output = result.stderr + result.stdout
+        
+        # Extract timings using regex
+        encode_match = re.search(r'encode time\s*=\s*([\d.]+)\s*ms', output)
+        total_match = re.search(r'total time\s*=\s*([\d.]+)\s*ms', output)
+        load_match = re.search(r'load time\s*=\s*([\d.]+)\s*ms', output)
+        
+        encode_time = float(encode_match.group(1)) if encode_match else 0
+        total_time = float(total_match.group(1)) if total_match else 0
+        load_time = float(load_match.group(1)) if load_match else 0
+        
+        # Calculate real-time factor (11 seconds for JFK sample)
+        rtf = 11000 / total_time if total_time > 0 else 0
+        
+        return {
+            "success": True,
+            "model": model_name,
+            "load_time_ms": load_time,
+            "encode_time_ms": encode_time,
+            "total_time_ms": total_time,
+            "real_time_factor": round(rtf, 1),
+            "sample_duration_s": 11.0
+        }
+        
+    except subprocess.TimeoutExpired:
+        return {
+            "success": False,
+            "error": "Benchmark timed out"
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+# Backwards compatibility - deprecated functions
+def get_current_model() -> str:
+    """DEPRECATED: Use get_active_model() instead."""
+    warnings.warn(
+        "get_current_model() is deprecated. Use get_active_model() instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return get_active_model()
+
+
+def set_current_model(model_name: str) -> None:
+    """DEPRECATED: Use set_active_model() instead."""
+    warnings.warn(
+        "set_current_model() is deprecated. Use set_active_model() instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return set_active_model(model_name)
+
+
+def is_model_installed(model_name: str) -> bool:
+    """DEPRECATED: Use is_whisper_model_installed() instead."""
+    warnings.warn(
+        "is_model_installed() is deprecated. Use is_whisper_model_installed() instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return is_whisper_model_installed(model_name)
+
+
+def get_installed_models() -> List[str]:
+    """DEPRECATED: Use get_installed_whisper_models() instead."""
+    warnings.warn(
+        "get_installed_models() is deprecated. Use get_installed_whisper_models() instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return get_installed_whisper_models()
+
+
+def has_coreml_model(model_name: str) -> bool:
+    """DEPRECATED: Use has_whisper_coreml_model() instead."""
+    warnings.warn(
+        "has_coreml_model() is deprecated. Use has_whisper_coreml_model() instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return has_whisper_coreml_model(model_name)
+
+
+# Also provide WHISPER_MODELS as alias for backwards compatibility
+WHISPER_MODELS = WHISPER_MODEL_REGISTRY