Zackriya-Solutions/meetily · error

Failed to load Parakeet model

Error message

Failed to load Parakeet model {}: {}

What it means

Thrown by ParakeetEngine::load_model when ParakeetModel::new fails to construct the model from the model directory. ParakeetModel::new builds three ONNX Runtime sessions (encoder-model[.int8].onnx, decoder_joint-model[.int8].onnx, nemo128.onnx) and parses vocab.txt, so the wrapped error can be file I/O, a truncated/invalid ONNX file, an ort Session builder failure (GraphOptimizationLevel::Level3 / CPUExecutionProvider registration), or a malformed vocabulary (missing <blk> token). The first {} is the model name; the second {} is the underlying ParakeetError.

Solutions

1. Inspect models_dir/<model-name> and confirm all four required files exist with plausible sizes (v3 int8 encoder ~652 MB; v2 int8 ~652 MB; decoder ~9 MB)
2. If any file is missing or suspiciously small, call delete_model(model_name) then download_model(model_name, ...) and retry the load
3. Check disk space and read permissions on the models directory
4. Run with RUST_LOG=app_lib::parakeet_engine=debug to see which session (encoder/decoder_joint/nemo128) or the vocab failed, then verify vocab.txt integrity

Example fix

// before
engine.load_model("parakeet-tdt-0.6b-v3-int8").await?;

// after - recover by removing the bad copy and re-downloading
let name = "parakeet-tdt-0.6b-v3-int8";
if let Err(e) = engine.load_model(name).await {
    log::warn!("Parakeet load failed ({e}); re-downloading {name}");
    let _ = engine.delete_model(name).await;
    engine.download_model(name, None).await?;
    engine.load_model(name).await?;
}

// Before load: confirm status is Available and all required files exist
let infos = engine.discover_models().await?;
let info = infos.iter().find(|m| m.name == model_name)
    .ok_or_else(|| anyhow!("unknown model"))?;
if !matches!(info.status, ModelStatus::Available) {
    anyhow::bail!("model not loadable yet: {:?}", info.status);
}
for f in ["encoder-model.int8.onnx", "decoder_joint-model.int8.onnx", "nemo128.onnx", "vocab.txt"] {
    let p = &info.path.join(f);
    if !p.is_file() {
        anyhow::bail!("missing {} under {}", f, info.path.display());
    }
}

fn is_loadable(info: &ModelInfo) -> bool {
    matches!(info.status, ModelStatus::Available)
}

// On failure, recover by deleting the bad copy and re-downloading once
match engine.load_model(name).await {
    Ok(()) => {}
    Err(e) if e.to_string().contains("Failed to load Parakeet model") => {
        log::warn!("load failed ({e}); rebuilding {name}");
        let _ = engine.delete_model(name).await;
        engine.download_model(name, None).await?;
        engine.load_model(name).await?;
    }
    Err(e) => return Err(e),
}

When it happens

Trigger: Calling load_model("parakeet-tdt-0.6b-v3-int8") when the model directory exists and status is Available, but one of the required files (encoder-model.int8.onnx, decoder_joint-model.int8.onnx, nemo128.onnx, vocab.txt) is truncated from an interrupted download that escaped clean_incomplete_model_directory, was deleted externally, or is unreadable; also when vocab.txt is malformed (no <blk> line parses) or the ort session builder rejects the graph.

Common situations: Disk filled up mid-download leaving a short .onnx file; user or a cleanup tool deleted files inside ~/Library/Application Support/Meetily/models/<model> (macOS) or %APPDATA%\Meetily\models\<model> (Windows); models folder copied between machines partially; ONNX Runtime version change makes an old downloaded graph unloadable.

Related errors

• Failed to get app data dir
• Parakeet engine not initialized
• App state not available
• Download already in progress for model
• Download already in progress for model

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

Appendix: source

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

                let model = tokio::task::spawn_blocking(move || {
                    #[cfg(test)]
                    if let Some(hook) = model_lifecycle_test_hook {
                        hook.load_started.notify_one();
                        runtime_handle.block_on(hook.continue_load.notified());
                    }
                    ParakeetModel::new(&model_path, quantized)
                        .map_err(|error| error.to_string())
                })
                .await
                .map_err(|error| {
                    anyhow!(
                        "Parakeet model load task failed for {}: {}",
                        model_name,
                        error
                    )
                })?
                .map_err(|error| {
                    anyhow!("Failed to load Parakeet model {}: {}", model_name, error)
                })?;

                *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))
            }

View on GitHub (pinned to a2cb62e827)