Enum ClientError 

pub enum ClientError {
    Http(Error),
    Unauthorized {
        message: String,
    },
    RateLimited {
        retry_after: Option<Duration>,
    },
    RetryableServer {
        status: u16,
        message: String,
    },
    Api(String),
    Serde(Error),
}

A typed failure from an StClient call: transport errors, 401/429/5xx HTTP classes, deserialization failures, and other game/API errors. Use ClientError::is_retryable / ClientError::is_unauthorized to branch on transient vs. terminal outcomes.

use spacetraders_client::ClientError;

let err = ClientError::RateLimited { retry_after: None };
assert!(err.is_retryable());
assert!(!err.is_unauthorized());

Variants

Http(Error)

Transport/communication failure (connection reset, timeout, DNS, …). Transient: the engine should back off and retry rather than crash.

Unauthorized

401: the agent token is no longer valid, typically after a server reset. Run-control keeps this on a dedicated path (notify FleetCommander).

Fields

message: String

RateLimited

429: rate limited. retry_after carries the server’s Retry-After hint when present. Transient.

Fields

retry_after: Option<Duration>

RetryableServer

5xx: server-side / maintenance failure. Transient.

Fields

status: u16

message: String

Api(String)

A non-retryable game/API error: bad state, invalid action, insufficient funds, 404, and any other status we do not special-case.

Serde(Error)

Implementations

impl ClientError

pub fn is_unauthorized(&self) -> bool

pub fn is_retryable(&self) -> bool

Whether the failure is transient and worth retrying automatically: communication errors, 429 rate limits, and 5xx server errors. This is the idempotent-read view; mutations must go through Self::is_retryable_under.

pub fn is_retryable_under(&self, policy: RetryPolicy) -> bool

Whether this error is safe to retry automatically under policy.

For RetryPolicy::Idempotent this is exactly Self::is_retryable. For RetryPolicy::Mutating only a 429 qualifies: the rate limiter rejects it before the mutation runs, so no change was applied. A 5xx or communication error is ambiguous — the server may have applied the change — so a non-idempotent request must not be replayed.

pub fn is_ambiguous_mutation(&self) -> bool

Whether a failed mutation left the outcome ambiguous: the request may have reached the game and applied server-side even though the client saw an error. True for 5xx and communication failures (the response was lost or the server faulted mid-write); false for a 429 (rejected before the action ran) and for deterministic game errors (e.g. insufficient funds), where the prior state is known to still hold. Callers use this to decide whether to re-read authoritative state before acting again.

pub fn retry_after(&self) -> Option<Duration>

Server-suggested delay before retrying, when one was provided (the Retry-After header on a 429).

pub fn class(&self) -> &'static str

Trait Implementations

impl Debug for ClientError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ClientError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for ClientError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for ClientError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for ClientError

fn from(source: Error) -> Self

Converts to this type from the input type.