xai-org/grok-build · error

blocking write task panicked: {e}

Error message

blocking write task panicked: {e}

What it means

This error wraps a panic from the spawn_blocking task that writes a downloaded chunk to its byte range in the destination file. tokio converts a JoinError (panic or cancellation) from the blocking task into this anyhow error via map_err, so the actual write logic itself failed to run — it crashed. It means the file write worker died abnormally, not that the write returned an I/O error (those propagate via the ? before it).

Source

Thrown at crates/codegen/xai-grok-update/src/auto_update.rs:1213

    let mut buf = Vec::with_capacity((end - start + 1) as usize);
    let mut stream = resp.bytes_stream();
    while let Some(chunk) = stream.next().await {
        let chunk = chunk?;
        if let Some(pb) = progress {
            pb.inc(chunk.len() as u64);
        }
        buf.extend_from_slice(&chunk);
    }
    let dest = dest.to_owned();
    tokio::task::spawn_blocking(move || -> std::io::Result<()> {
        use std::io::{Seek, SeekFrom, Write};
        let mut f = std::fs::OpenOptions::new().write(true).open(&dest)?;
        f.seek(SeekFrom::Start(start))?;
        f.write_all(&buf)?;
        Ok(())
    })
    .await
    .map_err(|e| anyhow::anyhow!("blocking write task panicked: {e}"))??;
    Ok(())
}

/// Download a file from `url` to `dest` with a terminal progress bar.
///
/// If the server provides a `Content-Length` header, a determinate bar is shown
/// with bytes downloaded, total size, and ETA. Otherwise a spinner with a byte
/// counter is used as a fallback.
#[doc(hidden)]
pub async fn download_with_progress(url: &str, dest: &std::path::Path) -> Result<()> {
    // Try parallel byte-range first. Falls through to single-connection on any
    // failure (HEAD missing Content-Length, ranges rejected, partial-fetch error).
    match try_parallel_download(url, dest, true).await {
        Ok(()) => return Ok(()),
        Err(e) => {
            tracing::debug!("parallel download failed, falling back to single connection: {e}")
        }
    }

View on GitHub (pinned to bc7f02eddd)

Solutions

1. Check the panic message embedded in {e} to find the real cause inside the blocking write closure
2. Verify the destination path is a writable, valid file and not removed concurrently
3. Re-run the download; parallel-range writes can race with file removal — ensure no other process deletes dest mid-download
4. Ensure the task is not being cancelled (process shutdown) mid-download

Example fix

// before
let mut f = std::fs::OpenOptions::new().write(true).open(&dest)?;
f.seek(SeekFrom::Start(start))?;
f.write_all(&buf)?;
// after (avoid panicking inside the blocking task; return errors instead)
let mut f = std::fs::OpenOptions::new().write(true).open(&dest)
    .map_err(|e| anyhow::anyhow!("open {} failed: {e}", dest.display()))?;
f.seek(SeekFrom::Start(start)).map_err(|e| anyhow::anyhow!("seek failed: {e}"))?;
f.write_all(&buf).map_err(|e| anyhow::anyhow!("write failed: {e}"))?;

let meta = tokio::fs::metadata(&dest).await?;
if !meta.is_file() { anyhow::bail!("dest is not a file: {}", dest.display()); }

match download_range(&url, &dest, start, end).await {
    Err(e) if e.to_string().contains("blocking write task panicked") => {
        // inspect {e} for the inner panic, ensure dest is writable, retry once
        eprintln!("download write panicked: {e}");
    }
    Err(e) => return Err(e),
    Ok(()) => {}
}

When it happens

Trigger: Calling download_range (indirectly through try_parallel_download) when the spawned blocking closure panics — e.g. seek/write_all panics, or an explicit panic/unwrap inside the blocking task. Also triggered if the blocking task was cancelled.

Common situations: Disk-full or permission errors surfacing as panics from unwraps in the write path; the destination file being closed/invalid while the task runs; thread cancellation during shutdown of a parallel download of a large artifact.

Related errors

• decode task panicked: {e}
• Connection cancelled
• Task panicked: {}
• agent runtime worker join: {e}
• Authentication cancelled

AI-assisted analysis of xai-org/grok-build@bc7f02eddd (2026-08-31). Data as JSON: /api/errors/0e8ecf7d704911b0. Report an issue: GitHub.