What causes "Parakeet model {} has error: {}" in Zackriya-Solutions/meetily?

Re-run parakeet_retry_download / download_model for the model - a fresh successful pass overwrites the Error status

Parakeet model has error

Error message

Parakeet model {} has error: {}

What it means

Returned by load_model when the model's status is ModelStatus::Error(ref err); the embedded string is the message recorded when the model previously entered an error state. This is a sticky status carried in available_models, so the load is rejected until the state is cleared by a successful download, a delete, or a fresh discovery pass.

Solutions

Re-run parakeet_retry_download / download_model for the model - a fresh successful pass overwrites the Error status
If retry keeps failing, call parakeet_delete_corrupted_model / delete_model (only works for Corrupted/Available, so first reset via a retry or app restart) or delete the model folder manually and download again
Restart the app to force discover_models to recompute status from disk if the folder actually looks complete

Example fix

// before
engine.load_model(name).await?;

// after - clear an Error status by re-downloading before loading
let info = engine.discover_models().await?.into_iter().find(|m| m.name == name);
if matches!(info.map(|m| m.status), Some(ModelStatus::Error(_))) {
    engine.download_model(&name, None).await?;
}
engine.load_model(&name).await?;

Defensive patterns

Strategy: retry

Validate before calling

let infos = engine.discover_models().await?;
if let Some(m) = infos.iter().find(|m| m.name == name) {
    if let ModelStatus::Error(ref msg) = m.status {
        log::warn!("model {name} in Error state: {msg}; re-downloading");
        engine.download_model(&name, None).await?;
    }
}

Type guard

fn is_error_status(info: &ModelInfo) -> bool {
    matches!(info.status, ModelStatus::Error(_))
}

Try / catch

match engine.load_model(name).await {
    Err(e) if e.to_string().contains("has error") => {
        // clear the state with a fresh download, then retry once
        engine.download_model(name, None).await?;
        engine.load_model(name).await?;
    }
    other => other?,
}

Prevention

After any download failure, show a retry affordance instead of leaving the model in Error with no path forward
On startup, re-run discover_models so stale Error states reconcile with the filesystem
Log the embedded error string - it names the original failure that set the state

When it happens

Trigger: A prior download attempt for this model failed in a path that set ModelStatus::Error (for example the post-download verification or a hard failure during fetch), and load_model is called afterwards; the app was not restarted since, so the in-memory status map still holds Error.

Common situations: Flaky network killed a download mid-session; the download succeeded partially and a later validation marked the model errored; the user retried 'Load' instead of 'Download' after seeing a download error in the UI.

Related errors

AI-assisted analysis of Zackriya-Solutions/meetily@a2cb62e827 (2026-09-12). Data as JSON: /api/errors/8dcaba01cb500edc. Report an issue: GitHub.

Appendix: source

Thrown at frontend/src-tauri/src/parakeet_engine/parakeet_engine.rs:505

                *self.current_model.write().await = Some(model);
                *self.current_model_name.write().await = Some(model_name.to_string());

                log::info!(
                    "Successfully loaded Parakeet model: {} ({})",
                    model_name,
                    if quantized { "Int8 quantized" } else { "FP32" }
                );
                Ok(())
            }
            ModelStatus::Missing => {
                Err(anyhow!("Parakeet model {} is not downloaded", model_name))
            }
            ModelStatus::Downloading { .. } => {
                Err(anyhow!("Parakeet model {} is currently downloading", model_name))
            }
            ModelStatus::Error(err) => {
                Err(anyhow!("Parakeet model {} has error: {}", model_name, err))
            }
            ModelStatus::Corrupted { .. } => {
                Err(anyhow!("Parakeet model {} is corrupted and cannot be loaded", model_name))
            }
        }
    }

    /// Unload the current model
    pub async fn unload_model(&self) -> bool {
        #[cfg(test)]
        if let Some(hook) = self.load_test_hook().await {
            hook.unload_attempted.notify_one();
        }
        let _lifecycle_guard = self.model_lifecycle_lock.lock().await;
        self.unload_model_locked().await
    }

    async fn unload_model_locked(&self) -> bool {

View on GitHub (pinned to a2cb62e827)