fix: GigaAM-only installs no longer prompt for a missing whisper model

A fresh install where the user downloads and activates only GigaAM kept
showing the 'no model installed' prompt on every launch, because the
check always looked for the whisper fallback file — and the sidecar
refused to start without it.

- sidecar: a missing whisper model is no longer fatal at startup; it is
  checked lazily on the first whisper request with a clear error. The
  warmup command accepts an engine field and preloads GigaAM when asked.
- app: the missing-model prompt now fires only when no usable engine
  exists (whisper file absent AND GigaAM not active+installed), and
  warmup targets the active engine.

windows: bump version to 0.7.1

Author: VasenevEA

sidecar-rust/src/main.rs

@@ -74,6 +74,12 @@ impl ModelHolder {
 
     fn ensure_loaded(&mut self) -> Result<&WhisperContext> {
         if self.ctx.is_none() {
+            if !self.model_path.exists() {
+                return Err(anyhow!(
+                    "whisper model file not found at {} (set FASTWORD_MODEL or download one)",
+                    self.model_path.display()
+                ));
+            }
             log(&format!("loading model {}", self.model_path.display()));
             let path_str = self
                 .model_path
@@ -238,8 +244,17 @@ fn handle(req: Request, engines: &Arc<Engines>) -> Response {
             )),
             "warmup" => {
                 let silence = vec![0.0f32; 16_000 / 2]; // 0.5s
-                let mut h = engines.whisper.lock().unwrap();
-                let _ = h.transcribe(&silence, None, 0.0, None)?;
+                match req.engine.as_deref() {
+                    // Preload the engine that will actually serve requests —
+                    // a GigaAM-only install has no whisper model at all.
+                    Some("gigaam") => {
+                        let _ = engines.run_gigaam(&silence)?;
+                    }
+                    _ => {
+                        let mut h = engines.whisper.lock().unwrap();
+                        let _ = h.transcribe(&silence, None, 0.0, None)?;
+                    }
+                }
                 Ok(String::new())
             }
             "transcribe" => {
@@ -302,9 +317,11 @@ fn main() -> Result<()> {
         std::env::var("FASTWORD_MODEL")
             .unwrap_or_else(|_| String::from("models/ggml-large-v3-turbo-q5_0.bin")),
     );
+    // Missing whisper model is not fatal: it is loaded lazily on the first
+    // whisper request, and a GigaAM-only setup never makes one.
     if !model_path.exists() {
-        return Err(anyhow!(
-            "model file not found at {} (set FASTWORD_MODEL)",
+        log(&format!(
+            "whisper model not found at {} — whisper requests will fail until it exists",
             model_path.display()
         ));
     }

windows/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fastword-win"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2021"
 description = "FastWord for Windows — local, private, push-to-talk dictation"
 license = "MIT"

windows/Cargo.toml

@@ -7,7 +7,7 @@
 ; (CI builds it automatically; Inno Setup 6 is preinstalled on GitHub
 ; windows runners.)
 
-#define AppVersion "0.7.0"
+#define AppVersion "0.7.1"
 
 [Setup]
 AppId={{1A8161D4-A910-4857-AD86-254EB4ED4690}

windows/installer/fastword.iss

@@ -169,10 +169,16 @@ fn run_app() -> Result<()> {
         }
     }
 
-    // A missing model is not fatal — a fresh install has none. Start
-    // without the sidecar and point the user at the Models tab instead.
+    // Engine routing (GigaAM is selected in the Models tab and is
+    // Russian-only, so its language hint is pinned like on macOS).
+    let gigaam_active = cfg.uses_gigaam() && models::gigaam_installed();
+
+    // A missing whisper model is not fatal — a fresh install has none, and
+    // a GigaAM-only install doesn't need one at all. Only when *no* usable
+    // engine exists do we start without the sidecar and point the user at
+    // the Models tab.
     let model_path = cfg.resolved_model_path();
-    let model_missing = !model_path.exists();
+    let model_missing = !model_path.exists() && !gigaam_active;
     if model_missing {
         logging::log(&format!("model not found at {} — starting without sidecar", model_path.display()));
     }
@@ -194,9 +200,7 @@ fn run_app() -> Result<()> {
     let client = if model_missing { None } else { Some(spawner.spawn()?) };
 
     let (mut language, mut initial_prompt) = languages::resolve(&cfg.language);
-    // GigaAM selected in the Models tab: route to the sherpa-onnx engine.
-    // It's Russian-only, so the language hint is pinned like on macOS.
-    let engine = if cfg.uses_gigaam() && models::gigaam_installed() {
+    let engine = if gigaam_active {
         language = "ru".to_string();
         initial_prompt = None;
         Some("gigaam".to_string())
@@ -628,9 +632,9 @@ fn controller_loop(
             Err(e) => logging::log(&format!("sidecar info failed: {e:#}")),
         }
 
-        // Load the model up front so the first dictation isn't slow.
+        // Load the active engine up front so the first dictation isn't slow.
         let t0 = std::time::Instant::now();
-        match client.warmup() {
+        match client.warmup(cfg.engine.as_deref()) {
             Ok(_) => logging::log(&format!("model warmed up in {:.1}s", t0.elapsed().as_secs_f32())),
             Err(e) => logging::log(&format!("warmup failed: {e:#}")),
         }

windows/src/main.rs

@@ -38,8 +38,10 @@ pub struct Response {
 }
 
 impl Request {
-    pub fn warmup(id: &str) -> Self {
-        Self::bare(id, "warmup")
+    pub fn warmup(id: &str, engine: Option<&str>) -> Self {
+        let mut req = Self::bare(id, "warmup");
+        req.engine = engine.map(str::to_string);
+        req
     }
 
     pub fn info(id: &str) -> Self {
@@ -215,9 +217,10 @@ impl SidecarClient {
         })
     }
 
-    pub fn warmup(&mut self) -> Result<String> {
+    /// Preload the engine that will serve requests (None = whisper).
+    pub fn warmup(&mut self, engine: Option<&str>) -> Result<String> {
         let id = self.take_id();
-        self.roundtrip(&Request::warmup(&id))
+        self.roundtrip(&Request::warmup(&id, engine))
     }
 
     /// Version/backend line, e.g. "fastword-sidecar 0.2.0 backend=cpu".
@@ -297,11 +300,16 @@ mod tests {
 
     #[test]
     fn warmup_request_wire_format() {
-        let req = Request::warmup("42");
+        let req = Request::warmup("42", None);
         assert_eq!(
             serde_json::to_string(&req).unwrap(),
             r#"{"id":"42","cmd":"warmup"}"#
         );
+        let req = Request::warmup("43", Some("gigaam"));
+        assert_eq!(
+            serde_json::to_string(&req).unwrap(),
+            r#"{"id":"43","cmd":"warmup","engine":"gigaam"}"#
+        );
     }
 
     #[test]