add FasterWhisper as new default provider in favor of whispercpp (#279)

* implement FasterWhisper as first-class STT provider

* untie whispercpp in favor of fasterwhisper

* add OS acknowledgement

Author: Shackless

README.md

@@ -41,7 +41,8 @@ Since version 2.0, Wingman AI Core acts as a "backend" API (using FastAPI and Py
   - OpenAI Whisper
   - Azure Whisper
   - Azure Speech
-  - whispercpp (local, bundled with Wingman AI)
+  - whispercpp (local, needs to be installed separately)
+  - FasterWhisper (local, default)
   - Wingman Pro (Azure Speech or Azure Whisper)
 - **Text-to-speech** (TTS) providers:
   - OpenAI TTS
@@ -138,9 +139,9 @@ You can use any LLM offering an OpenAI-compatible API and connect it to Wingman
 ### Windows
 
 - Download the installer of the latest version from [wingman-ai.com](https://www.wingman-ai.com).
+- If you have an NVIDIA RTX GPU, install the latest [CUDA driver](https://developer.nvidia.com/cuda-downloads) from NVIDIA to speed up the transcription process significantly.
 - Install it to a directory of your choice and start the client `Wingman AI.exe`.
   - The client will will auto-start `Wingman AI Core.exe` in the background
-  - The client will auto-start `whispercpp` in the background. If you have an NVIDIA RTX GPU, install the latest CUDA driver from NVIDIA and enable GPU acceleration in the Settings view.
 
 If that doesn't work for some reason, try starting `Wingman AI Core.exe` manually and check the terminal or your **logs** directory for errors.
 
@@ -271,7 +272,9 @@ We would like to thank their creators for their great work and contributions to
 - [scipy](https://github.com/scipy/scipy) - BSD 3, © 2001-2002 Enthought, Inc. 2003-2023, SciPy Developers
 - [sounddevice](https://github.com/spatialaudio/python-sounddevice/) - MIT, © 2015-2023 Matthias Geier
 - [soundfile](https://github.com/bastibe/python-soundfile) - BSD 3, © 2013 Bastian Bechtold
-- [uvicorn](https://github.com/encode/uvicorn) - BSD 3, © 2017-presen, Encode OSS Ltd. All rights reserved.
+- [uvicorn](https://github.com/encode/uvicorn) - BSD 3, © 2017-present, Encode OSS Ltd. All rights reserved.
+- [whispercpp](https://github.com/ggerganov/whisper.cpp) - MIT, © 2023-2024 The ggml authors
+- [FasterWhisper](https://github.com/SYSTRAN/faster-whisper) - MIT, © 2023 SYSTRAN
 
 ### Individual persons
 

api/enums.py

@@ -79,6 +79,7 @@ class MistralModel(Enum):
     MISTRAL_MEDIUM = "mistral-medium-latest"
     MISTRAL_LARGE = "mistral-large-latest"
 
+
 class PerplexityModel(Enum):
     """https://docs.perplexity.ai/guides/model-cards"""
 
@@ -90,6 +91,7 @@ class PerplexityModel(Enum):
     LLAMA3_8B = "llama-3.1-8b-instruct"
     LLAMA3_70B = "llama-3.1-70b-instruct"
 
+
 class GoogleAiModel(Enum):
     GEMINI_1_5_FLASH = "gemini-1.5-flash"
     GEMINI_1_5_PRO = "gemini-1.5-pro"
@@ -136,13 +138,15 @@ class SttProvider(Enum):
     AZURE = "azure"
     AZURE_SPEECH = "azure_speech"
     WHISPERCPP = "whispercpp"
+    FASTER_WHISPER = "fasterwhisper"
     WINGMAN_PRO = "wingman_pro"
 
 
 class VoiceActivationSttProvider(Enum):
     OPENAI = "openai"
     AZURE = "azure"
     WHISPERCPP = "whispercpp"
+    FASTER_WHISPER = "fasterwhisper"
     WINGMAN_PRO = "wingman_pro"
 
 
@@ -175,6 +179,7 @@ class RecordingDevice(Enum):
     MOUSE = "mouse"
     JOYSTICK = "joystick"
 
+
 class WingmanProRegion(Enum):
     EUROPE = "europe"
     USA = "usa"
@@ -246,9 +251,11 @@ class TtsVoiceGenderEnumModel(BaseEnumModel):
 class MistralModelEnumModel(BaseEnumModel):
     model: MistralModel
 
+
 class PerplexityModelEnumModel(BaseEnumModel):
     model: PerplexityModel
 
+
 class GoogleAiModelEnumModel(BaseEnumModel):
     model: GoogleAiModel
 

api/interface.py

@@ -111,12 +111,19 @@ class AudioSettings(BaseModel):
 
 
 class WhispercppSettings(BaseModel):
+    enable: bool
     host: str
     port: int
-    model: str
-    language: str
-    translate_to_english: bool
-    use_cuda: bool
+
+
+class FasterWhisperSettings(BaseModel):
+    model_config = ConfigDict(protected_namespaces=())
+    """tiny, tiny.en, base, base.en, small, small.en, distil-small.en, medium, medium.en, distil-medium.en, large-v1, large-v2, large-v3, large, distil-large-v2, distil-large-v3, large-v3-turbo, or turbo"""
+    model_size: str
+    """default (model original), auto (fastest available on device), int8, int8_float16 etc. - see https://opennmt.net/CTranslate2/quantization.html#quantize-on-model-conversion"""
+    compute_type: str
+    """cpu, cuda, auto"""
+    device: str
 
 
 class XVASynthSettings(BaseModel):
@@ -133,9 +140,25 @@ class WhispercppSttConfig(BaseModel):
     temperature: float
 
 
+class FasterWhisperSttConfig(BaseModel):
+    beam_size: int
+    language: Optional[str] = None
+    hotwords: Optional[str] = None
+    best_of: int
+    temperature: float
+    no_speech_threshold: float
+    multilingual: bool
+    language_detection_threshold: float
+
+
 class WhispercppTranscript(BaseModel):
     text: str
+
+
+class FasterWhisperTranscript(BaseModel):
+    text: str
     language: str
+    language_probability: float
 
 
 class AzureInstanceConfig(BaseModel):
@@ -387,7 +410,9 @@ class VoiceActivationSettings(BaseModel):
 
     azure: AzureSttConfig
     whispercpp: WhispercppSettings
+    fasterwhisper: FasterWhisperSettings
     whispercpp_config: WhispercppSttConfig
+    fasterwhisper_config: FasterWhisperSttConfig
 
 
 class FeaturesConfig(BaseModel):
@@ -470,6 +495,7 @@ class CommandJoystickConfig(BaseModel):
     guid: Optional[str] = None
     """The joystick GUID to use. Optional."""
 
+
 class CommandActionConfig(BaseModel):
     keyboard: Optional[CommandKeyboardConfig] = None
     """The keyboard configuration for this action. Optional."""
@@ -618,6 +644,7 @@ class NestedConfig(BaseModel):
     azure: AzureConfig
     xvasynth: XVASynthTtsConfig
     whispercpp: WhispercppSttConfig
+    fasterwhisper: FasterWhisperSttConfig
     wingman_pro: WingmanProConfig
     perplexity: PerplexityConfig
     commands: Optional[list[CommandConfig]] = None
@@ -650,6 +677,7 @@ class BasicWingmanConfig(BaseModel):
     azure: AzureConfig
     xvasynth: XVASynthTtsConfig
     whispercpp: WhispercppSttConfig
+    fasterwhisper: FasterWhisperSttConfig
     wingman_pro: WingmanProConfig
     perplexity: PerplexityConfig
 

providers/faster_whisper.py

@@ -0,0 +1,76 @@
+from faster_whisper import WhisperModel
+from api.interface import (
+    FasterWhisperSettings,
+    FasterWhisperTranscript,
+    FasterWhisperSttConfig,
+    WingmanInitializationError,
+)
+from services.printr import Printr
+
+
+class FasterWhisper:
+    def __init__(
+        self,
+        settings: FasterWhisperSettings,
+    ):
+        self.settings = settings
+        self.current_model = None
+        self.printr = Printr()
+        self.model = WhisperModel(
+            settings.model_size,
+            device=settings.device,
+            compute_type=settings.compute_type,
+        )
+
+    def transcribe(
+        self,
+        config: FasterWhisperSttConfig,
+        wingman_name: str,
+        filename: str,
+    ):
+        try:
+            segments, info = self.model.transcribe(
+                filename,
+                without_timestamps=True,
+                beam_size=config.beam_size,
+                best_of=config.best_of,
+                temperature=config.temperature,
+                hotwords=(
+                    wingman_name
+                    if not config.hotwords
+                    else ",".join([wingman_name, config.hotwords])
+                ),
+                no_speech_threshold=config.no_speech_threshold,
+                language=config.language,
+                multilingual=False if config.language else config.multilingual,
+                language_detection_threshold=(
+                    None if config.language else config.language_detection_threshold
+                ),
+            )
+            segments = list(segments)
+            text = ""
+            for segment in segments:
+                text += segment.text.strip()
+
+            return FasterWhisperTranscript(
+                text=text,
+                language=info.language,
+                language_probability=info.language_probability,
+            )
+
+        except FileNotFoundError:
+            self.printr.toast_error(
+                f"FasterWhisper file to transcript'{filename}' not found."
+            )
+
+    def update_settings(self, settings: FasterWhisperSettings):
+        self.settings = settings
+        self.model = WhisperModel(
+            settings.model_size,
+            device=settings.device,
+            compute_type=settings.compute_type,
+        )
+        self.printr.print("FasterWhisper settings updated.", server_only=True)
+
+    def validate(self, errors: list[WingmanInitializationError]):
+        pass

providers/whispercpp.py

@@ -1,50 +1,34 @@
-from time import sleep
-from os import path
-import platform
-import subprocess
 import requests
-from api.enums import LogType
-from api.interface import WhispercppSettings, WhispercppSttConfig, WhispercppTranscript
+from api.enums import LogType, WingmanInitializationErrorType
+from api.interface import (
+    WhispercppSettings,
+    WhispercppSttConfig,
+    WhispercppTranscript,
+    WingmanInitializationError,
+)
 from services.printr import Printr
 
-STANDARD_DIR = "whispercpp"
-CUDA_DIR = "whispercpp-cuda"
-MODELS_DIR = "whispercpp-models"
-SERVER_EXE = "whisper-server.exe"
-
 
 class Whispercpp:
     def __init__(
         self,
         settings: WhispercppSettings,
-        app_root_path: str,
-        app_is_bundled: bool,
     ):
         self.settings = settings
-        self.current_model = None
-        self.running_process = None
         self.printr = Printr()
 
-        self.is_windows = platform.system() == "Windows"
-        if self.is_windows:
-            # move one dir up, out of _internal (if bundled)
-            app_dir = path.dirname(app_root_path) if app_is_bundled else app_root_path
-            self.models_dir = path.join(app_dir, MODELS_DIR)
-            self.standard_dir = path.join(app_dir, STANDARD_DIR)
-            self.cuda_dir = path.join(app_dir, CUDA_DIR)
-
-            if self.__validate():
-                self.start_server()
-        else:
-            self.__validate()
-
     def transcribe(
         self,
         filename: str,
         config: WhispercppSttConfig,
         response_format: str = "json",
         timeout: int = 10,
     ):
+        if not self.settings.enable:
+            self.printr.toast_error(
+                text="Whispercpp must be enabled and configured in the Settings view."
+            )
+            return None
         try:
             with open(filename, "rb") as file:
                 response = requests.post(
@@ -60,7 +44,6 @@ def transcribe(
                 # Wrap response.json = {"text":"transcription"} into a Pydantic model for typesafe further processing
                 return WhispercppTranscript(
                     text=response.json()["text"].strip(),
-                    language=self.settings.language,
                 )
         except requests.HTTPError as e:
             self.printr.toast_error(
@@ -77,136 +60,25 @@ def transcribe(
                 f"whispercpp file to transcript'{filename}' not found."
             )
 
-    def start_server(self):
-        if self.__is_server_running() or not self.is_windows:
-            self.printr.print(
-                f"whispercpp connected on {self.settings.host}:{self.settings.port}. Using model '{self.settings.model}' and language '{self.settings.language}'.",
-                server_only=True,
-                color=LogType.HIGHLIGHT,
-            )
-            return True
-
-        args = [
-            path.join(
-                self.cuda_dir if self.settings.use_cuda else self.standard_dir,
-                SERVER_EXE,
-            ),
-            "--port",
-            str(self.settings.port),
-            "-m",
-            path.join(self.models_dir, self.settings.model),
-            "-l",
-            self.settings.language,
-        ]
-        if self.settings.translate_to_english:
-            args.append("-tr")
-
-        try:
-            self.stop_server()
-            self.running_process = subprocess.Popen(args)
-            self.current_model = self.settings.model
-            sleep(2)
-            is_running = self.__is_server_running()
-            if is_running:
-                self.printr.print(
-                    f"whispercpp server started on {self.settings.host}:{self.settings.port}.",
-                    server_only=True,
-                    color=LogType.HIGHLIGHT,
-                )
-            else:
-                self.printr.toast_error(
-                    text="Failed to start whispercpp server. Please start it manually."
-                )
-            return is_running
-        except Exception:
-            self.printr.toast_error(
-                text="Failed to start whispercpp server. Please start it manually."
-            )
-            return False
-
-    def stop_server(self):
-        if self.running_process:
-            self.running_process.kill()
-            self.running_process.wait()
-            self.running_process = None
-            self.printr.print(
-                "whispercpp server stopped.", server_only=True, color=LogType.HIGHLIGHT
-            )
-
     def update_settings(self, settings: WhispercppSettings):
-        requires_restart = (
-            self.settings.host != settings.host
-            or self.settings.port != settings.port
-            or self.settings.use_cuda != settings.use_cuda
-            or self.settings.language != settings.language
-            or self.settings.translate_to_english != settings.translate_to_english
-        )
-        if self.__validate():
-            self.settings = settings
-
-            if requires_restart:
-                self.stop_server()
-                self.start_server()
-            else:
-                self.change_model()
-
-            self.printr.print("whispercpp settings updated.", server_only=True)
-
-    def change_model(self, timeout=10):
-        if not self.is_windows:
-            return
-
-        if self.current_model != self.settings.model:
-            response = requests.post(
-                f"{self.settings.host}:{self.settings.port}/load",
-                data={"model": path.join(self.models_dir, self.settings.model)},
-                timeout=timeout,
-            )
-            response.raise_for_status()
-            self.current_model = self.settings.model
-
-    def __validate(self):
-        if not self.is_windows:
-            if not self.__is_server_running():
-                self.printr.print(
-                    text=f"Please start whispercpp server manually on {self.settings.host}:{self.settings.port}.",
-                    color=LogType.ERROR,
-                    server_only=True,
-                )
-                return False
-            else:
-                self.printr.print(
-                    text=f"whispercpp connected on {self.settings.host}:{self.settings.port} (manually started on non-Windows OS).",
-                    color=LogType.HIGHLIGHT,
-                    server_only=True,
+        self.settings = settings
+        self.printr.print("whispercpp settings updated.", server_only=True)
+
+    def validate(self, wingman_name: str, errors: list[WingmanInitializationError]):
+        if not self.__is_server_running():
+            errors.append(
+                WingmanInitializationError(
+                    wingman_name=wingman_name,
+                    message=f"Please start whispercpp server manually on {self.settings.host}:{self.settings.port}, then restart Wingman AI.",
+                    error_type=WingmanInitializationErrorType.INVALID_CONFIG,
                 )
-            return True
-
-        # On Windows:
-        model_path = path.join(self.models_dir, self.settings.model)
-        if not path.exists(model_path):
-            self.printr.print(
-                text=f"whispercpp is missing model file '{model_path}'.",
-                color=LogType.ERROR,
-                server_only=True,
-            )
-            return False
-        if not path.exists(self.cuda_dir):
-            self.printr.print(
-                text=f"whispercpp is missing directory '{self.cuda_dir}'.",
-                color=LogType.ERROR,
-                server_only=True,
             )
-            return False
-        if not path.exists(self.standard_dir):
+        else:
             self.printr.print(
-                text=f"whispercpp is missing directory '{self.standard_dir}'.",
-                color=LogType.ERROR,
+                text=f"whispercpp connected on {self.settings.host}:{self.settings.port}.",
+                color=LogType.HIGHLIGHT,
                 server_only=True,
             )
-            return False
-
-        return True
 
     def __is_server_running(self, timeout=5):
         try:

requirements.txt

@@ -2,6 +2,7 @@ azure-cognitiveservices-speech==1.42.0
 edge-tts==7.0.0
 elevenlabslib==0.31.3
 fastapi==0.115.7
+faster_whisper==1.1.1
 google-generativeai==0.8.4
 markdown==3.7
 numpy==1.26.4

services/config_manager.py

@@ -952,6 +952,7 @@ def merge_configs(self, default: Config, wingman):
             "elevenlabs",
             "azure",
             "whispercpp",
+            "fasterwhisper",
             "xvasynth",
             "wingman_pro",
             "perplexity",

services/config_migration_service.py

@@ -138,7 +138,7 @@ def migrate_settings(old: dict, new: dict) -> dict:
             self.log("- applied new split whispercpp settings/config structure")
 
             old["xvasynth"] = new["xvasynth"]
-            self.log("- adding new XVASynth settings")
+            self.log("- added new XVASynth settings")
 
             old.pop("audio", None)
             self.log("- removed audio device settings because DirectSound was removed")
@@ -348,12 +348,36 @@ def migrate_wingman(old: dict, new: Optional[dict]) -> dict:
 
     def migrate_162_to_170(self):
         def migrate_settings(old: dict, new: dict) -> dict:
+            old["voice_activation"]["whispercpp"].pop("use_cuda", None)
+            old["voice_activation"]["whispercpp"].pop("language", None)
+            old["voice_activation"]["whispercpp"].pop("translate_to_english", None)
+            self.log("- removed old whispercpp settings (if there were any)")
+
+            old["voice_activation"]["whispercpp"]["enable"] = False
+            self.log("- disabled whispercpp by default")
+
+            old["voice_activation"]["fasterwhisper"] = new["voice_activation"][
+                "fasterwhisper"
+            ]
+            old["voice_activation"]["fasterwhisper_config"] = new["voice_activation"][
+                "fasterwhisper_config"
+            ]
+            self.log("- added new fasterwhisper settings and config")
             return old
 
         def migrate_defaults(old: dict, new: dict) -> dict:
+            old["fasterwhisper"] = new["fasterwhisper"]
+            self.log("- added new properties: fasterwhisper")
+
+            old["features"]["stt_provider"] = "fasterwhisper"
+            self.log("- made fasterwhisper new default STT provider")
+
             return old
 
         def migrate_wingman(old: dict, new: Optional[dict]) -> dict:
+            if old.get("features", {}).get("stt_provider") == "whispercpp":
+                old["features"]["stt_provider"] = "fasterwhisper"
+                self.log("- changed STT provider from whispercpp to fasterwhisper")
             return old
 
         self.migrate(

services/config_service.py

@@ -370,9 +370,11 @@ async def save_basic_wingman_config(
         except ValueError:
             wingman_config.azure.tts.voice = basic_config.voice
 
-        reload_config = (wingman_config.record_joystick_button != basic_config.record_joystick_button
-                        or wingman_config.record_mouse_button != basic_config.record_mouse_button
-                        or wingman_file.name != wingman_config.name)
+        reload_config = (
+            wingman_config.record_joystick_button != basic_config.record_joystick_button
+            or wingman_config.record_mouse_button != basic_config.record_mouse_button
+            or wingman_file.name != wingman_config.name
+        )
 
         wingman_config.record_joystick_button = basic_config.record_joystick_button
         wingman_config.record_mouse_button = basic_config.record_mouse_button
@@ -390,6 +392,7 @@ async def save_basic_wingman_config(
         wingman_config.azure = basic_config.azure
         wingman_config.xvasynth = basic_config.xvasynth
         wingman_config.whispercpp = basic_config.whispercpp
+        wingman_config.fasterwhisper = basic_config.fasterwhisper
         wingman_config.wingman_pro = basic_config.wingman_pro
         wingman_config.perplexity = basic_config.perplexity
 

services/module_manager.py

@@ -12,6 +12,7 @@
     SkillConfig,
     WingmanConfig,
 )
+from providers.faster_whisper import FasterWhisper
 from providers.whispercpp import Whispercpp
 from providers.xvasynth import XVASynth
 from services.audio_library import AudioLibrary
@@ -54,6 +55,7 @@ def create_wingman_dynamically(
         audio_player: AudioPlayer,
         audio_library: AudioLibrary,
         whispercpp: Whispercpp,
+        fasterwhisper: FasterWhisper,
         xvasynth: XVASynth,
         tower: "Tower",
     ):
@@ -66,6 +68,7 @@ def create_wingman_dynamically(
             audio_player (AudioPlayer): The audio player handling the playback of audio files.
             audio_library (AudioLibrary): The audio library handling the storage and retrieval of audio files.
             whispercpp (Whispercpp): The Whispercpp provider for speech-to-text.
+            fasterwhisper (FasterWhisper): The FasterWhisper provider for speech-to-text.
             xvasynth (XVASynth): The XVASynth provider for text-to-speech.
             tower (Tower): The Tower instance, that manages loaded Wingmen.
         """
@@ -91,6 +94,7 @@ def create_wingman_dynamically(
             audio_player=audio_player,
             audio_library=audio_library,
             whispercpp=whispercpp,
+            fasterwhisper=fasterwhisper,
             xvasynth=xvasynth,
             tower=tower,
         )
@@ -151,9 +155,7 @@ def add_to_sys_path(path_to_add: str):
 
     @staticmethod
     def read_available_skill_configs() -> list[tuple[str, str]]:
-        skill_dirs = [
-            get_writable_dir(SKILLS_DIR)
-        ]
+        skill_dirs = [get_writable_dir(SKILLS_DIR)]
 
         if os.path.isdir(SKILLS_DIR):
             skill_dirs.append(SKILLS_DIR)
@@ -168,12 +170,16 @@ def read_available_skill_configs() -> list[tuple[str, str]]:
                 # Check if the path is a directory (to avoid non-folder files)
                 if os.path.isdir(skill_path):
                     # Construct the path to the default_config.yaml file
-                    default_config_path = os.path.join(skill_path, "default_config.yaml")
+                    default_config_path = os.path.join(
+                        skill_path, "default_config.yaml"
+                    )
 
                     # Check if the default_config.yaml file exists
                     if os.path.isfile(default_config_path):
                         # Add the skill name and the default_config.yaml file path to the list
-                        skills_default_configs.update({skill_name: (skill_name, default_config_path)})
+                        skills_default_configs.update(
+                            {skill_name: (skill_name, default_config_path)}
+                        )
 
         return list(skills_default_configs.values())
 

services/settings_service.py

@@ -8,6 +8,7 @@
     AudioDeviceSettings,
     SettingsConfig,
 )
+from providers.faster_whisper import FasterWhisper
 from providers.whispercpp import Whispercpp
 from providers.xvasynth import XVASynth
 from services.config_manager import ConfigManager
@@ -25,6 +26,7 @@ def __init__(self, config_manager: ConfigManager, config_service: ConfigService)
         self.settings = self.get_settings()
         self.settings_events = PubSub()
         self.whispercpp: Whispercpp = None
+        self.fasterwhisper: FasterWhisper = None
         self.xvasynth: XVASynth = None
 
         self.router = APIRouter()
@@ -44,8 +46,11 @@ def __init__(self, config_manager: ConfigManager, config_service: ConfigService)
             tags=tags,
         )
 
-    def initialize(self, whispercpp: Whispercpp, xvasynth: XVASynth):
+    def initialize(
+        self, whispercpp: Whispercpp, fasterwhisper: FasterWhisper, xvasynth: XVASynth
+    ):
         self.whispercpp = whispercpp
+        self.fasterwhisper = fasterwhisper
         self.xvasynth = xvasynth
 
     # GET /settings
@@ -84,6 +89,16 @@ async def save_settings(self, settings: SettingsConfig):
             return
         self.whispercpp.update_settings(settings=settings.voice_activation.whispercpp)
 
+        # FasterWhisper
+        if not self.fasterwhisper:
+            self.printr.toast_error(
+                "FasterWhisper is not initialized. Please run SettingsService.initialize()",
+            )
+            return
+        self.fasterwhisper.update_settings(
+            settings=settings.voice_activation.fasterwhisper
+        )
+
         # XVASynth
         if not self.xvasynth:
             self.printr.toast_error(

services/tower.py

@@ -6,6 +6,7 @@
     WingmanInitializationError,
     ConfigDirInfo,
 )
+from providers.faster_whisper import FasterWhisper
 from providers.whispercpp import Whispercpp
 from providers.xvasynth import XVASynth
 from services.audio_player import AudioPlayer
@@ -29,6 +30,7 @@ def __init__(
         audio_player: AudioPlayer,
         audio_library: AudioLibrary,
         whispercpp: Whispercpp,
+        fasterwhisper: FasterWhisper,
         xvasynth: XVASynth,
     ):
         self.audio_player = audio_player
@@ -40,6 +42,7 @@ def __init__(
         self.disabled_wingmen: list[WingmanConfig] = []
         self.log_source_name = "Tower"
         self.whispercpp = whispercpp
+        self.fasterwhisper = fasterwhisper
         self.xvasynth = xvasynth
 
     async def instantiate_wingmen(self, settings: SettingsConfig):
@@ -94,6 +97,7 @@ async def __instantiate_wingman(
                     audio_player=self.audio_player,
                     audio_library=self.audio_library,
                     whispercpp=self.whispercpp,
+                    fasterwhisper=self.fasterwhisper,
                     xvasynth=self.xvasynth,
                     tower=self,
                 )
@@ -105,6 +109,7 @@ async def __instantiate_wingman(
                     audio_player=self.audio_player,
                     audio_library=self.audio_library,
                     whispercpp=self.whispercpp,
+                    fasterwhisper=self.fasterwhisper,
                     xvasynth=self.xvasynth,
                     tower=self,
                 )
@@ -215,7 +220,9 @@ def disable_wingman(self, wingman_name: str):
     def save_wingman(self, wingman_name: str):
         for wingman in self.wingmen:
             if wingman.name == wingman_name:
-                for wingman_file in self.config_manager.get_wingmen_configs(self.config_dir):
+                for wingman_file in self.config_manager.get_wingmen_configs(
+                    self.config_dir
+                ):
                     if wingman_file.name == wingman_name:
                         self.config_manager.save_wingman_config(
                             config_dir=self.config_dir,

templates/configs/defaults.yaml

@@ -39,7 +39,7 @@ prompts:
     (END of "skills")
 features:
   tts_provider: wingman_pro
-  stt_provider: whispercpp
+  stt_provider: fasterwhisper
   conversation_provider: wingman_pro
   image_generation_provider: wingman_pro
   use_generic_instant_responses: false
@@ -103,6 +103,13 @@ azure:
       - de-DE
 whispercpp:
   temperature: 0.0
+fasterwhisper:
+  beam_size: 1
+  best_of: 2
+  temperature: 0
+  no_speech_threshold: 0.7
+  language_detection_threshold: 0.5
+  multilingual: false
 xvasynth:
   voice:
     model_directory: ""

templates/configs/settings.yaml

@@ -13,12 +13,20 @@ voice_activation:
   whispercpp:
     host: http://127.0.0.1
     port: 8080
-    model: ggml-base.bin
-    language: auto
-    translate_to_english: false
-    use_cuda: false
+    enable: false
   whispercpp_config:
     temperature: 0.0
+  fasterwhisper:
+    model_size: base
+    device: auto
+    compute_type: auto
+  fasterwhisper_config:
+    beam_size: 1
+    best_of: 2
+    temperature: 0
+    no_speech_threshold: 0.7
+    language_detection_threshold: 0.5
+    multilingual: false
 wingman_pro:
   base_url: https://wingman-ai.azurewebsites.net
   region: europe

wingman_core.py

@@ -3,8 +3,8 @@
 import os
 import re
 import threading
-import pygame
 from typing import Optional
+import pygame
 from fastapi import APIRouter, File, UploadFile
 import requests
 import sounddevice as sd
@@ -31,6 +31,7 @@
     WingmanInitializationError,
 )
 from providers.elevenlabs import ElevenLabs
+from providers.faster_whisper import FasterWhisper
 from providers.open_ai import OpenAi
 from providers.whispercpp import Whispercpp
 from providers.wingman_pro import WingmanPro
@@ -117,22 +118,24 @@ def __init__(
             tags=tags,
         )
         self.router.add_api_route(
-            methods=["POST"],
-            path="/whispercpp/start",
-            endpoint=self.start_whispercpp,
+            methods=["GET"],
+            path="/fasterwhisper/modelsizes",
+            response_model=list[str],
+            endpoint=self.get_fasterwhisper_modelsizes,
             tags=tags,
         )
         self.router.add_api_route(
-            methods=["POST"],
-            path="/whispercpp/stop",
-            endpoint=self.stop_whispercpp,
+            methods=["GET"],
+            path="/fasterwhisper/computetypes",
+            response_model=list[str],
+            endpoint=self.get_fasterwhisper_computetypes,
             tags=tags,
         )
         self.router.add_api_route(
             methods=["GET"],
-            path="/whispercpp/models",
+            path="/fasterwhisper/devices",
             response_model=list[str],
-            endpoint=self.get_whispercpp_models,
+            endpoint=self.get_fasterwhisper_devices,
             tags=tags,
         )
         self.router.add_api_route(
@@ -300,12 +303,15 @@ def __init__(
 
         self.whispercpp = Whispercpp(
             settings=self.settings_service.settings.voice_activation.whispercpp,
-            app_root_path=app_root_path,
-            app_is_bundled=app_is_bundled,
+        )
+        self.fasterwhisper = FasterWhisper(
+            settings=self.settings_service.settings.voice_activation.fasterwhisper,
         )
         self.xvasynth = XVASynth(settings=self.settings_service.settings.xvasynth)
         self.settings_service.initialize(
-            whispercpp=self.whispercpp, xvasynth=self.xvasynth
+            whispercpp=self.whispercpp,
+            fasterwhisper=self.fasterwhisper,
+            xvasynth=self.xvasynth,
         )
 
         self.voice_service = VoiceService(
@@ -331,20 +337,35 @@ async def startup(self):
             await self.set_voice_activation(is_enabled=True)
 
     def is_mouse_configured(self, config: Config) -> bool:
-        return any(config.wingmen[wingman].record_mouse_button for wingman in config.wingmen)
-    
+        return any(
+            config.wingmen[wingman].record_mouse_button for wingman in config.wingmen
+        )
+
     def is_joystick_configured(self, config: Config) -> bool:
-        return any(config.wingmen[wingman].record_joystick_button for wingman in config.wingmen)
-    
+        return any(
+            config.wingmen[wingman].record_joystick_button for wingman in config.wingmen
+        )
+
     async def start_joysticks(self, config: Config):
         pygame.init()
 
         # Get all joystick configs
-        joystick_configs = [config.wingmen[wingman].record_joystick_button for wingman in config.wingmen if config.wingmen[wingman].record_joystick_button]
-        
-        joysticks = [pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())]
+        joystick_configs = [
+            config.wingmen[wingman].record_joystick_button
+            for wingman in config.wingmen
+            if config.wingmen[wingman].record_joystick_button
+        ]
+
+        joysticks = [
+            pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())
+        ]
         for joystick in joysticks:
-            if any([joystick.get_guid() == joystick_config.guid for joystick_config in joystick_configs]):
+            if any(
+                [
+                    joystick.get_guid() == joystick_config.guid
+                    for joystick_config in joystick_configs
+                ]
+            ):
                 joystick.init()
 
         running = True
@@ -356,12 +377,20 @@ async def start_joysticks(self, config: Config):
                     joystick_origin = pygame.joystick.Joystick(event.joy)
                     for joystick_config in joystick_configs:
                         if joystick_origin.get_guid() == joystick_config.guid:
-                            self.on_press(joystick_config=CommandJoystickConfig(guid=joystick_config.guid, button=event.button))
+                            self.on_press(
+                                joystick_config=CommandJoystickConfig(
+                                    guid=joystick_config.guid, button=event.button
+                                )
+                            )
                 elif event.type == pygame.JOYBUTTONUP:
                     joystick_origin = pygame.joystick.Joystick(event.joy)
                     for joystick_config in joystick_configs:
                         if joystick_origin.get_guid() == joystick_config.guid:
-                            self.on_release(joystick_config=CommandJoystickConfig(guid=joystick_config.guid, button=event.button))
+                            self.on_release(
+                                joystick_config=CommandJoystickConfig(
+                                    guid=joystick_config.guid, button=event.button
+                                )
+                            )
 
             # Add a small sleep to prevent the loop from consuming too much CPU
             await asyncio.sleep(0.01)
@@ -400,6 +429,7 @@ async def initialize_tower(self, config_dir_info: ConfigWithDirInfo):
             audio_player=self.audio_player,
             audio_library=self.audio_library,
             whispercpp=self.whispercpp,
+            fasterwhisper=self.fasterwhisper,
             xvasynth=self.xvasynth,
         )
         self.tower_errors = await self.tower.instantiate_wingmen(
@@ -432,7 +462,9 @@ def is_hotkey_pressed(self, hotkey: list[int] | str) -> bool:
 
         return is_pressed
 
-    def on_press(self, key=None, mouse_button=None, joystick_config: CommandJoystickConfig=None):
+    def on_press(
+        self, key=None, mouse_button=None, joystick_config: CommandJoystickConfig = None
+    ):
         is_mute_hotkey_pressed = self.is_hotkey_pressed(
             self.settings_service.settings.voice_activation.mute_toggle_key_codes
             or self.settings_service.settings.voice_activation.mute_toggle_key
@@ -457,17 +489,23 @@ def on_press(self, key=None, mouse_button=None, joystick_config: CommandJoystick
                         wingman = potential_wingman
                         break
                 if joystick_config:
-                    if potential_wingman.get_record_joystick_button() == f"{joystick_config.guid}{joystick_config.button}":
+                    if (
+                        potential_wingman.get_record_joystick_button()
+                        == f"{joystick_config.guid}{joystick_config.button}"
+                    ):
                         wingman = potential_wingman
                         break
-                        
+
             if wingman:
                 if key:
                     self.active_recording = dict(key=key.name, wingman=wingman)
                 elif mouse_button:
                     self.active_recording = dict(key=mouse_button, wingman=wingman)
                 elif joystick_config:
-                    self.active_recording = dict(key=f"{joystick_config.guid}{joystick_config.button}", wingman=wingman)
+                    self.active_recording = dict(
+                        key=f"{joystick_config.guid}{joystick_config.button}",
+                        wingman=wingman,
+                    )
 
                 self.was_listening_before_ptt = self.is_listening
                 if (
@@ -478,12 +516,18 @@ def on_press(self, key=None, mouse_button=None, joystick_config: CommandJoystick
 
                 self.audio_recorder.start_recording(wingman_name=wingman.name)
 
-    def on_release(self, key=None, mouse_button=None, joystick_config: CommandJoystickConfig=None):
+    def on_release(
+        self, key=None, mouse_button=None, joystick_config: CommandJoystickConfig = None
+    ):
         if self.tower and (
             key is not None
             and self.active_recording["key"] == key.name
             or self.active_recording["key"] == mouse_button
-            or (joystick_config and self.active_recording["key"] == f"{joystick_config.guid}{joystick_config.button}")
+            or (
+                joystick_config
+                and self.active_recording["key"]
+                == f"{joystick_config.guid}{joystick_config.button}"
+            )
         ):
             wingman = self.active_recording["wingman"]
             recorded_audio_wav = self.audio_recorder.stop_recording(
@@ -849,34 +893,52 @@ def reset_conversation_history(self, wingman_name: Optional[str] = None):
             )
         return True
 
-    # POST /whispercpp/start
-    def start_whispercpp(self):
-        self.whispercpp.start_server()
-
-    # POST /whispercpp/stop
-    def stop_whispercpp(self):
-        try:
-            self.whispercpp.stop_server()
-        except Exception:
-            pass
-
-    # GET /whispercpp/models
-    def get_whispercpp_models(self):
-        model_files = []
-        try:
-            model_files = [
-                f
-                for f in os.listdir(self.whispercpp.models_dir)
-                if os.path.isfile(os.path.join(self.whispercpp.models_dir, f))
-                and f.endswith(".bin")
-            ]
-        except Exception:
-            # this can fail:
-            # - on MacOS (always)
-            # - in Dev mode if the dev hasn't copied the whispercpp-models dir to the repository
-            # in these cases, we return an empty list and the client will lock the controls and show a warning.
-            pass
-        return model_files
+    # GET /fasterwhisper/modelsizes
+    def get_fasterwhisper_modelsizes(self):
+        model_sizes = [
+            "tiny",
+            "tiny.en",
+            "base",
+            "base.en",
+            "small",
+            "small.en",
+            "distil-small.en",
+            "medium",
+            "medium.en",
+            "distil-medium.en",
+            "large-v1",
+            "large-v2",
+            "large-v3",
+            "large",
+            "distil-large-v2",
+            "distil-large-v3",
+            "large-v3-turbo",
+            "turbo",
+        ]
+        return model_sizes
+
+    # GET /fasterwhisper/computetypes
+    def get_fasterwhisper_computetypes(self):
+        compute_types = [
+            "default",
+            "auto",
+            "int8",
+            "int16",
+            "int8_float16",
+            "int8_float32",
+            "float16",
+            "float32",
+        ]
+        return compute_types
+
+    # GET /fasterwhisper/devices
+    def get_fasterwhisper_devices(self):
+        devices = [
+            "auto",
+            "cpu",
+            "cuda",
+        ]
+        return devices
 
     # POST /xvasynth/start
     def start_xvasynth(self):
@@ -1095,6 +1157,5 @@ async def get_elevenlabs_subscription_data(self):
             self.printr.toast_error(f"Elevenlabs: \n{str(e)}")
 
     async def shutdown(self):
-        await self.stop_whispercpp()
         await self.stop_xvasynth()
         await self.unload_tower()

wingmen/open_ai_wingman.py

@@ -3,7 +3,6 @@
 import asyncio
 import random
 import traceback
-from idlelib.pyparse import trans
 from typing import Mapping, Optional
 from openai.types.chat import ChatCompletion
 from api.interface import (
@@ -19,7 +18,8 @@
     SttProvider,
     ConversationProvider,
     WingmanProSttProvider,
-    WingmanProTtsProvider, WingmanInitializationErrorType,
+    WingmanProTtsProvider,
+    WingmanInitializationErrorType,
 )
 from providers.edge import Edge
 from providers.elevenlabs import ElevenLabs
@@ -84,6 +84,11 @@ async def validate(self):
         errors = await super().validate()
 
         try:
+            if self.uses_provider("whispercpp"):
+                self.whispercpp.validate(self.name, errors)
+            if self.uses_provider("fasterwhisper"):
+                self.fasterwhisper.validate(errors)
+
             if self.uses_provider("openai"):
                 await self.validate_and_set_openai(errors)
 
@@ -116,6 +121,7 @@ async def validate(self):
 
             if self.uses_provider("perplexity"):
                 await self.validate_and_set_perplexity(errors)
+
         except Exception as e:
             errors.append(
                 WingmanInitializationError(
@@ -124,7 +130,11 @@ async def validate(self):
                     error_type=WingmanInitializationErrorType.UNKNOWN,
                 )
             )
-            printr.print(f"Error during provider validation: {str(e)}", color=LogType.ERROR, server_only=True)
+            printr.print(
+                f"Error during provider validation: {str(e)}",
+                color=LogType.ERROR,
+                server_only=True,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
         return errors
@@ -199,6 +209,8 @@ def uses_provider(self, provider_type: str):
             return self.config.features.tts_provider == TtsProvider.XVASYNTH
         elif provider_type == "whispercpp":
             return self.config.features.stt_provider == SttProvider.WHISPERCPP
+        elif provider_type == "fasterwhisper":
+            return self.config.features.stt_provider == SttProvider.FASTER_WHISPER
         elif provider_type == "wingman_pro":
             return any(
                 [
@@ -227,7 +239,10 @@ async def prepare(self):
                 )
                 self.threaded_execution(self._generate_instant_responses)
         except Exception as e:
-            await printr.print_async(f"Error while preparing wingman '{self.name}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error while preparing wingman '{self.name}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
     async def unload_skills(self):
@@ -242,7 +257,10 @@ async def prepare_skill(self, skill: Skill):
                 self.tool_skills[tool_name] = skill
                 self.skill_tools.append(tool)
         except Exception as e:
-            await printr.print_async(f"Error while preparing skill '{skill.name}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error while preparing skill '{skill.name}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
         # init skill methods
@@ -335,7 +353,9 @@ async def validate_and_set_wingman_pro(self):
             wingman_name=self.name, settings=self.settings.wingman_pro
         )
 
-    async def validate_and_set_perplexity(self, errors: list[WingmanInitializationError]):
+    async def validate_and_set_perplexity(
+        self, errors: list[WingmanInitializationError]
+    ):
         api_key = await self.retrieve_secret("perplexity", errors)
         if api_key:
             self.perplexity = OpenAi(
@@ -361,7 +381,10 @@ async def update_settings(self, settings: SettingsConfig):
                     server_only=True,
                 )
         except Exception as e:
-            await printr.print_async(f"Error while updating settings for wingman '{self.name}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error while updating settings for wingman '{self.name}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
     async def _generate_instant_responses(self) -> None:
@@ -423,7 +446,10 @@ async def _generate_instant_responses(self) -> None:
                             completion = await self.actual_llm_call(messages)
                         retry_count += 1
         except Exception as e:
-            await printr.print_async(f"Error while generating instant responses: {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error while generating instant responses: {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
     async def _transcribe(self, audio_input_wav: str) -> str | None:
@@ -454,8 +480,17 @@ async def _transcribe(self, audio_input_wav: str) -> str | None:
                 transcript = self.whispercpp.transcribe(
                     filename=audio_input_wav, config=self.config.whispercpp
                 )
+            elif self.config.features.stt_provider == SttProvider.FASTER_WHISPER:
+                transcript = self.fasterwhisper.transcribe(
+                    filename=audio_input_wav,
+                    config=self.config.fasterwhisper,
+                    wingman_name=self.name,
+                )
             elif self.config.features.stt_provider == SttProvider.WINGMAN_PRO:
-                if self.config.wingman_pro.stt_provider == WingmanProSttProvider.WHISPER:
+                if (
+                    self.config.wingman_pro.stt_provider
+                    == WingmanProSttProvider.WHISPER
+                ):
                     transcript = self.wingman_pro.transcribe_whisper(
                         filename=audio_input_wav
                     )
@@ -469,7 +504,10 @@ async def _transcribe(self, audio_input_wav: str) -> str | None:
             elif self.config.features.stt_provider == SttProvider.OPENAI:
                 transcript = self.openai.transcribe(filename=audio_input_wav)
         except Exception as e:
-            await printr.print_async(f"Error during transcription using '{self.config.features.stt_provider}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error during transcription using '{self.config.features.stt_provider}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
         if not transcript:
@@ -896,8 +934,12 @@ async def generate_image(self, text: str) -> str:
             try:
                 return await self.wingman_pro.generate_image(text)
             except Exception as e:
-                await printr.print_async(f"Error during image generation: {str(e)}", color=LogType.ERROR)
-                printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
+                await printr.print_async(
+                    f"Error during image generation: {str(e)}", color=LogType.ERROR
+                )
+                printr.print(
+                    traceback.format_exc(), color=LogType.ERROR, server_only=True
+                )
 
         return ""
 
@@ -914,33 +956,45 @@ async def actual_llm_call(self, messages, tools: list[dict] = None):
                     config=self.config.azure.conversation,
                     tools=tools,
                 )
-            elif self.config.features.conversation_provider == ConversationProvider.OPENAI:
+            elif (
+                self.config.features.conversation_provider
+                == ConversationProvider.OPENAI
+            ):
                 completion = self.openai.ask(
                     messages=messages,
                     tools=tools,
                     model=self.config.openai.conversation_model,
                 )
-            elif self.config.features.conversation_provider == ConversationProvider.MISTRAL:
+            elif (
+                self.config.features.conversation_provider
+                == ConversationProvider.MISTRAL
+            ):
                 completion = self.mistral.ask(
                     messages=messages,
                     tools=tools,
                     model=self.config.mistral.conversation_model.value,
                 )
-            elif self.config.features.conversation_provider == ConversationProvider.GROQ:
+            elif (
+                self.config.features.conversation_provider == ConversationProvider.GROQ
+            ):
                 completion = self.groq.ask(
                     messages=messages,
                     tools=tools,
                     model=self.config.groq.conversation_model,
                 )
             elif (
-                self.config.features.conversation_provider == ConversationProvider.CEREBRAS
+                self.config.features.conversation_provider
+                == ConversationProvider.CEREBRAS
             ):
                 completion = self.cerebras.ask(
                     messages=messages,
                     tools=tools,
                     model=self.config.cerebras.conversation_model,
                 )
-            elif self.config.features.conversation_provider == ConversationProvider.GOOGLE:
+            elif (
+                self.config.features.conversation_provider
+                == ConversationProvider.GOOGLE
+            ):
                 completion = self.google.ask(
                     messages=messages,
                     tools=tools,
@@ -956,7 +1010,8 @@ async def actual_llm_call(self, messages, tools: list[dict] = None):
                     model=self.config.openrouter.conversation_model,
                 )
             elif (
-                self.config.features.conversation_provider == ConversationProvider.LOCAL_LLM
+                self.config.features.conversation_provider
+                == ConversationProvider.LOCAL_LLM
             ):
                 completion = self.local_llm.ask(
                     messages=messages,
@@ -973,15 +1028,18 @@ async def actual_llm_call(self, messages, tools: list[dict] = None):
                     tools=tools,
                 )
             elif (
-                self.config.features.conversation_provider == ConversationProvider.PERPLEXITY
+                self.config.features.conversation_provider
+                == ConversationProvider.PERPLEXITY
             ):
                 completion = self.perplexity.ask(
                     messages=messages,
                     tools=tools,
                     model=self.config.perplexity.conversation_model.value,
                 )
         except Exception as e:
-            await printr.print_async(f"Error during LLM call: {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error during LLM call: {str(e)}", color=LogType.ERROR
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
             return None
 
@@ -1087,8 +1145,12 @@ async def _handle_tool_calls(self, tool_calls):
                     self._add_tool_response(tool_call, function_response)
             except Exception as e:
                 self._add_tool_response(tool_call, "Error")
-                await printr.print_async(f"Error while processing tool call: {str(e)}", color=LogType.ERROR)
-                printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
+                await printr.print_async(
+                    f"Error while processing tool call: {str(e)}", color=LogType.ERROR
+                )
+                printr.print(
+                    traceback.format_exc(), color=LogType.ERROR, server_only=True
+                )
 
         return instant_response, skill
 
@@ -1136,9 +1198,16 @@ async def execute_command_by_function_call(
                 if instant_response:
                     await self.play_to_user(instant_response)
             except Exception as e:
-                await printr.print_async(f"Error while processing skill '{skill.name}': {str(e)}", color=LogType.ERROR)
-                printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
-                function_response = "ERROR DURING PROCESSING" # hints to AI that there was an Error
+                await printr.print_async(
+                    f"Error while processing skill '{skill.name}': {str(e)}",
+                    color=LogType.ERROR,
+                )
+                printr.print(
+                    traceback.format_exc(), color=LogType.ERROR, server_only=True
+                )
+                function_response = (
+                    "ERROR DURING PROCESSING"  # hints to AI that there was an Error
+                )
                 instant_response = None
 
         return function_response, instant_response, used_skill
@@ -1230,7 +1299,9 @@ async def play_to_user(
                         audio_player=self.audio_player,
                         wingman_name=self.name,
                     )
-                elif self.config.wingman_pro.tts_provider == WingmanProTtsProvider.AZURE:
+                elif (
+                    self.config.wingman_pro.tts_provider == WingmanProTtsProvider.AZURE
+                ):
                     await self.wingman_pro.generate_azure_speech(
                         text=text,
                         config=self.config.azure.tts,
@@ -1243,7 +1314,9 @@ async def play_to_user(
                     f"Unsupported TTS provider: {self.config.features.tts_provider}"
                 )
         except Exception as e:
-            await printr.print_async(f"Error during TTS playback: {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error during TTS playback: {str(e)}", color=LogType.ERROR
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
     async def _execute_command(self, command: dict) -> str:

wingmen/wingman.py

@@ -23,6 +23,7 @@
     LogType,
     WingmanInitializationErrorType,
 )
+from providers.faster_whisper import FasterWhisper
 from providers.whispercpp import Whispercpp
 from providers.xvasynth import XVASynth
 from services.audio_player import AudioPlayer
@@ -52,6 +53,7 @@ def __init__(
         audio_player: AudioPlayer,
         audio_library: AudioLibrary,
         whispercpp: Whispercpp,
+        fasterwhisper: FasterWhisper,
         xvasynth: XVASynth,
         tower: "Tower",
     ):
@@ -87,6 +89,9 @@ def __init__(
         self.whispercpp = whispercpp
         """A class that handles the communication with the Whispercpp server for transcription."""
 
+        self.fasterwhisper = fasterwhisper
+        """A class that handles local transcriptions using FasterWhisper."""
+
         self.xvasynth = xvasynth
         """A class that handles the communication with the XVASynth server for TTS."""
 
@@ -102,7 +107,7 @@ def get_record_key(self) -> str | int:
     def get_record_mouse_button(self) -> str:
         """Returns the activation or "push-to-talk" mouse button for this Wingman."""
         return self.config.record_mouse_button
-    
+
     def get_record_joystick_button(self) -> str:
         """Returns the activation or "push-to-talk" joystick button for this Wingman."""
         if not self.config.record_joystick_button:
@@ -160,7 +165,11 @@ async def retrieve_secret(self, secret_name, errors):
                     )
                 )
         except Exception as e:
-            printr.print(f"Error retrieving secret ''{secret_name}: {e}", color=LogType.ERROR, server_only=True)
+            printr.print(
+                f"Error retrieving secret ''{secret_name}: {e}",
+                color=LogType.ERROR,
+                server_only=True,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
             errors.append(
                 WingmanInitializationError(
@@ -190,8 +199,13 @@ async def unload_skills(self):
             try:
                 await skill.unload()
             except Exception as e:
-                await printr.print_async(f"Error unloading skill '{skill.name}': {str(e)}", color=LogType.ERROR)
-                printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
+                await printr.print_async(
+                    f"Error unloading skill '{skill.name}': {str(e)}",
+                    color=LogType.ERROR,
+                )
+                printr.print(
+                    traceback.format_exc(), color=LogType.ERROR, server_only=True
+                )
 
     async def init_skills(self) -> list[WingmanInitializationError]:
         """This method is called when the Wingman is instantiated by Tower or when a skill's config changes.
@@ -246,8 +260,13 @@ async def init_skills(self) -> list[WingmanInitializationError]:
                             color=LogType.ERROR,
                         )
             except Exception as e:
-                await printr.print_async(f"Error loading skill '{skill_config.name}': {str(e)}", color=LogType.ERROR)
-                printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
+                await printr.print_async(
+                    f"Error loading skill '{skill_config.name}': {str(e)}",
+                    color=LogType.ERROR,
+                )
+                printr.print(
+                    traceback.format_exc(), color=LogType.ERROR, server_only=True
+                )
 
         return errors
 
@@ -287,7 +306,9 @@ async def process(self, audio_input_wav: str = None, transcript: str = None):
             process_result = None
 
             if self.settings.debug_mode and not transcript:
-                await printr.print_async("Starting transcription...", color=LogType.INFO)
+                await printr.print_async(
+                    "Starting transcription...", color=LogType.INFO
+                )
 
             if not transcript:
                 # transcribe the audio.
@@ -332,7 +353,10 @@ async def process(self, audio_input_wav: str = None, transcript: str = None):
             if process_result:
                 await self.play_to_user(str(process_result), not interrupt)
         except Exception as e:
-            await printr.print_async(f"Error during processing of wingmann ''{self.name}: {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error during processing of wingmann ''{self.name}: {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
     # ───────────────── virtual methods / hooks ───────────────── #
@@ -432,13 +456,18 @@ async def _execute_instant_activation_command(
                 if command.instant_activation:
                     for phrase in command.instant_activation:
                         if phrase.lower() in commands_by_instant_activation:
-                            commands_by_instant_activation[phrase.lower()].append(command)
+                            commands_by_instant_activation[phrase.lower()].append(
+                                command
+                            )
                         else:
                             commands_by_instant_activation[phrase.lower()] = [command]
 
             # find best matching phrase
             phrase = difflib.get_close_matches(
-                transcript.lower(), commands_by_instant_activation.keys(), n=1, cutoff=0.8
+                transcript.lower(),
+                commands_by_instant_activation.keys(),
+                n=1,
+                cutoff=0.8,
             )
 
             # if no phrase found, return None
@@ -453,7 +482,10 @@ async def _execute_instant_activation_command(
             # return the executed command
             return commands
         except Exception as e:
-            await printr.print_async(f"Error during instant activation in wingmann '{self.name}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error during instant activation in wingmann '{self.name}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
             return None
 
@@ -482,7 +514,8 @@ async def _execute_command(self, command: CommandConfig) -> str:
 
             if len(command.actions or []) == 0:
                 await printr.print_async(
-                    f"No actions found for command: {command.name}", color=LogType.WARNING
+                    f"No actions found for command: {command.name}",
+                    color=LogType.WARNING,
                 )
 
             # handle the global special commands:
@@ -491,9 +524,12 @@ async def _execute_command(self, command: CommandConfig) -> str:
 
             return self._select_command_response(command) or "Ok"
         except Exception as e:
-            await printr.print_async(f"Error executing command '{command.name}' for wingman '{self.name}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error executing command '{command.name}' for wingman '{self.name}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
-            return "ERROR DURING PROCESSING" # hints to AI that there was an Error
+            return "ERROR DURING PROCESSING"  # hints to AI that there was an Error
 
     async def execute_action(self, command: CommandConfig):
         """Executes the actions defined in the command (in order).
@@ -580,12 +616,16 @@ async def execute_action(self, command: CommandConfig):
                         action.audio, self.config.sound.volume
                     )
         except Exception as e:
-            await printr.print_async(f"Error executing actions of command '{command.name}' for wingman '{self.name}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error executing actions of command '{command.name}' for wingman '{self.name}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
 
     def threaded_execution(self, function, *args) -> threading.Thread | None:
         """Execute a function in a separate thread."""
         try:
+
             def start_thread(function, *args):
                 if asyncio.iscoroutinefunction(function):
                     new_loop = asyncio.new_event_loop()
@@ -599,7 +639,9 @@ def start_thread(function, *args):
             thread.start()
             return thread
         except Exception as e:
-            printr.print(f"Error starting threaded execution: {str(e)}", color=LogType.ERROR)
+            printr.print(
+                f"Error starting threaded execution: {str(e)}", color=LogType.ERROR
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
             return None
 
@@ -620,13 +662,19 @@ async def update_config(
                 errors = await self.validate()
 
                 for error in errors:
-                    if error.error_type != WingmanInitializationErrorType.MISSING_SECRET:
+                    if (
+                        error.error_type
+                        != WingmanInitializationErrorType.MISSING_SECRET
+                    ):
                         self.config = old_config
                         return False
 
             return True
         except Exception as e:
-            await printr.print_async(f"Error updating config for wingman '{self.name}': {str(e)}", color=LogType.ERROR)
+            await printr.print_async(
+                f"Error updating config for wingman '{self.name}': {str(e)}",
+                color=LogType.ERROR,
+            )
             printr.print(traceback.format_exc(), color=LogType.ERROR, server_only=True)
             return False