Zackriya-Solutions/meetily · error · anyhow::Error

Parakeet model is corrupted and cannot be loaded

Error message

Parakeet model {} is corrupted and cannot be loaded

What it means

Returned by load_model when the model's status is ModelStatus::Corrupted, which carries file_size and expected_min_size. discover_models flags a model Corrupted when its files exist but are smaller than the expected minimum (a truncated download), so loading is refused before ONNX Runtime ever opens the graph.

Solutions

  1. Call delete_model(model_name) - deletion is explicitly allowed for Corrupted models - then download_model again
  2. Or invoke the parakeet_delete_corrupted_model Tauri command from the UI and re-download from the models screen
  3. Verify free disk space is at least the model size (~670 MB for v3 int8) before re-downloading

Example fix

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

// after - corrupted models must be deleted and re-downloaded
match engine.discover_models().await?.into_iter().find(|m| m.name == name) {
    Some(m) if matches!(m.status, ModelStatus::Corrupted { .. }) => {
        engine.delete_model(&name).await?;
        engine.download_model(&name, None).await?;
    }
    _ => {}
}
engine.load_model(&name).await?;
Defensive patterns

Strategy: fallback

Validate before calling

let infos = engine.discover_models().await?;
if let Some(m) = infos.iter().find(|m| m.name == name) {
    if let ModelStatus::Corrupted { file_size, expected_min_size } = &m.status {
        log::warn!("corrupt: {file_size} < {expected_min_size} bytes; rebuilding");
        engine.delete_model(name).await?;
        engine.download_model(name, None).await?;
    }
}

Type guard

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

// TS side: { Corrupted: { file_size, expected_min_size } }
function isCorrupted(status: unknown): boolean {
  return typeof status === 'object' && status !== null && 'Corrupted' in status;
}

Try / catch

match engine.load_model(name).await {
    Err(e) if e.to_string().contains("corrupted") => {
        engine.delete_model(name).await?; // allowed for Corrupted
        engine.download_model(name, None).await?;
        engine.load_model(name).await?;
    }
    other => other?,
}

Prevention

When it happens

Trigger: An interrupted or cancelled download (cancel_download keeps partial files for resume) left a short encoder/decoder ONNX file that then fails the size check; a partially copied models directory from another machine; disk-full during download producing undersized files.

Common situations: User cancelled a download and later tried to load the model; app crashed mid-download and the resume path never completed; manual copy of the models folder missed the tail of a large file.

Related errors

AI-assisted analysis of Zackriya-Solutions/meetily@a2cb62e827 (2026-08-16). Data as JSON: /api/errors/fba99020bb4b13b1. Report an issue: GitHub.

Appendix: source

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

                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 {
        let unloaded = self.current_model.write().await.take().is_some();
        if unloaded {
            log::info!("Parakeet model unloaded");

View on GitHub (pinned to a2cb62e827)