vllm-project/vllm · error · Error

utility call `{method}` closed unexpectedly (call_id={call_i

Error message

utility call `{method}` closed unexpectedly (call_id={call_id})

What it means

EngineCoreError::UtilityCallClosed means the utility call's response channel closed before any result arrived — the engine-core (or its dispatcher) dropped the responder for that call_id. The call was accepted but never answered.

Source

Thrown at rust/src/engine-core-client/src/error.rs:96

    #[error("engine-core output dispatcher closed: {message}")]
    DispatcherClosed { message: String },
    #[error("engine-core client is closed: {message}")]
    ClientClosed { message: String },
    #[error("request output stream for `{request_id}` closed unexpectedly")]
    RequestStreamClosed { request_id: String },
    #[error("utility call `{method}` failed (call_id={call_id}): {message}")]
    UtilityCallFailed {
        method: String,
        call_id: UtilityCallId,
        message: String,
    },
    #[error("utility call `{method}` returned an invalid result (call_id={call_id}): {message}")]
    UtilityResultDecode {
        method: String,
        call_id: UtilityCallId,
        message: String,
    },
    #[error("utility call `{method}` closed unexpectedly (call_id={call_id})")]
    UtilityCallClosed { method: String, call_id: u64 },
    #[error("utility call `{method}` returned inconsistent results across engines: {values}")]
    InconsistentUtilityResults { method: String, values: String },

    /// A special variant to allow cloning the same error.
    #[error(transparent)]
    Shared(Arc<Self>),
}

View on GitHub (pinned to c794754062)

Solutions

Ensure utility calls are not issued after/between shutdown initiation — gate them on engine liveness
Retry the utility call once after confirming the engine-core is still running (call_id can be reused safely for a new attempt)
Check engine-core logs for the crash or shutdown that closed the responder

Defensive patterns

Strategy: retry

Validate before calling

// Skip utility calls during shutdown
if shutting_down.load(Ordering::Relaxed) { return Ok(None); }
client.utility_call(method, payload).await.map(Some)

Type guard

pub fn is_utility_closed(e: &vllm_engine_core_client::Error) -> bool {
    matches!(e, vllm_engine_core_client::Error::UtilityCallClosed { .. })
}

Try / catch

for attempt in 0..2 {
    match client.utility_call(method, payload).await {
        Err(vllm_engine_core_client::Error::UtilityCallClosed { .. }) if attempt == 0 && engine_alive() => continue,
        other => break other,
    }
}

Prevention

Block new utility calls once shutdown begins (shutdown flag / watch channel)
Confirm engine liveness before retrying a closed utility call
Correlate call_id in logs to distinguish races from engine crashes

When it happens

Trigger: Issuing a utility call concurrently with engine-core shutdown; the dispatcher task being torn down while the utility call is pending; engine-core crashing between accepting the call and responding.

Common situations: Shutdown races where a monitoring task fires a utility call as the engine closes; engine crash mid-call; testing harnesses that drop the client immediately after issuing a utility call.

Related errors

AI-assisted analysis of vllm-project/vllm@c794754062 (2026-08-14). Data as JSON: /api/errors/a987ce49ec09288b. Report an issue: GitHub.