astrid-runtime/astrid · error

FSKit callback probe failed

Error message

FSKit callback probe failed [{code}]: {message}

What it means

After verifying correlation, probe_callback inspects the FSKit responder's outcome. If the extension reported a Failure (StorageFilesystemFailureV1), the provider surfaces its code and message wrapped in this error. This is the propagation path for a callback probe that the FSKit side explicitly rejected.

Solutions

1. Read the embedded [code] and message in the error text to identify the extension-side failure and fix the root cause there
2. Confirm the extension supports the probe operation and protocol V2 payloads
3. Upgrade the FSKit extension/provider so both sides agree on the callback contract
4. Re-run the probe after fixing; if persistent, capture extension logs alongside the code

Example fix

// on the extension side
// before
return .failure(code: .unsupported, message: "")
// after
return .success(StorageFilesystemSuccessV1(...))

if let Err(e) = probe_callback(&req).await { if let Some((code, msg)) = parse_probe_failure(&e) { log::error!("extension failure {code}: {msg}"); handle_extension_failure(code); } }

When it happens

Trigger: probe_callback (called from run) receives StorageFilesystemOutcomeV2::Failure{code,message} for a probe whose request_id matched — the FSKit extension's callback handler returned a failure code for the probed operation.

Common situations: The extension doesn't support the probed callback method; the extension hit an internal error (e.g. missing mount metadata); a version skew where the extension expects different probe payloads.

Related errors

• daemon closed the response stream before the final marker
• daemon rejected status request
• daemon returned an unexpected status response
• detached FUSE service exceeded the startup response size
• FSKit callback probe correlation mismatch

AI-assisted analysis of astrid-runtime/astrid@affd8760f4 (2026-09-09). Data as JSON: /api/errors/983d544f8c295b7e. Report an issue: GitHub.

Appendix: source

Thrown at crates/astrid-storage-provider-fskit/src/service.rs:237

        request_id: format!("fskit-service-{}", launch.lease.mount_id),
        lease_token: launch.lease.lease_token.clone(),
        operation: StorageFilesystemOperationV2::Stat {
            path: String::new(),
        },
    };
    let bytes = serde_json::to_vec(&request).context("encode FSKit callback probe")?;
    let length = u32::try_from(bytes.len()).context("FSKit callback probe is too large")?;
    stream.write_all(&length.to_be_bytes()).await?;
    stream.write_all(&bytes).await?;
    stream.flush().await?;
    let response = read_callback_response(&mut stream).await?;
    if response.request_id != request.request_id {
        bail!("FSKit callback probe correlation mismatch");
    }
    match response.outcome {
        StorageFilesystemOutcomeV2::Success(_) => Ok(()),
        StorageFilesystemOutcomeV2::Failure(StorageFilesystemFailureV1 { code, message }) => {
            bail!("FSKit callback probe failed [{code}]: {message}")
        },
    }
}

async fn read_callback_response(stream: &mut LocalStream) -> Result<StorageFilesystemResponseV2> {
    let mut length = [0_u8; 4];
    stream.read_exact(&mut length).await?;
    let length = u32::from_be_bytes(length) as usize;
    if length == 0 || length > MAX_CALLBACK_BYTES {
        bail!("FSKit callback response exceeds the bounded frame size");
    }
    let mut bytes = vec![0_u8; length];
    stream.read_exact(&mut bytes).await?;
    let response: StorageFilesystemResponseV2 =
        serde_json::from_slice(&bytes).context("decode FSKit callback probe")?;
    if response.protocol_version != STORAGE_FILESYSTEM_PROTOCOL_V2 {
        bail!("FSKit callback probe protocol mismatch");
    }

View on GitHub (pinned to affd8760f4)