Enum ErrorCode 

pub enum ErrorCode {
    UnsupportedProtocolVersion,
    MalformedFrame,
    UnknownCommand,
    FrameTooLarge,
    PayloadTooLarge,
    StaleRequest,
    DuplicateRequest,
    TooManyPending,
    NotAuthorized,
    DeviceOffline,
    UnknownService,
    ServiceActionFailed,
    UnknownRun,
    UnknownApproval,
    ApprovalExpired,
    Timeout,
    RateLimited,
    CapabilityUnavailable,
    InternalError,
}

Why a frame was refused, or why the operation behind it did not happen.

Non-exhaustive is deliberate on the reading side only: a peer that meets a code it does not know treats it as ErrorCode::InternalError rather than failing to parse, so adding a code in a later minor revision cannot break an older client. The serde representation below is what makes that work.

Variants

UnsupportedProtocolVersion

The frame named a major version this peer cannot speak at all.

MalformedFrame

The bytes were not a valid envelope: bad JSON, missing field, unknown field, wrong type.

UnknownCommand

The envelope parsed, but type is not a name this peer accepts in this direction. A response type arriving at the daemon is this, not ErrorCode::MalformedFrame.

FrameTooLarge

The frame was larger than super::limits::MAX_FRAME_BYTES. Answered only when the frame was small enough to identify; past that the socket simply closes.

PayloadTooLarge

A field inside a well-formed frame exceeded its own limit — a prompt over 16 KiB, say.

StaleRequest

sentAt is outside the window in super::limits. The sender has almost certainly stopped waiting.

DuplicateRequest

This request id was already seen inside the dedup window and the operation is not one that may run twice.

TooManyPending

The device already has super::limits::MAX_PENDING_COMMANDS requests in flight.

NotAuthorized

The credential is revoked, belongs to another device, or the caller does not own this device.

DeviceOffline

No daemon socket is currently attached to this device. Never queued — presence fails closed.

UnknownService

No service by that exact name is registered. The remote surface never takes a pattern, so this is always an exact-name miss.

ServiceActionFailed

The daemon tried the action and it failed. The only code here that carries a message written by the local runtime rather than the protocol.

UnknownRun

No agent run by that id, or one that has already finished.

UnknownApproval

No pending approval by that id on that run.

ApprovalExpired

The approval was answered by its own expiry before the human answered it. Always a deny, never a silent drop.

Timeout

The operation was still running when its deadline passed. Not retryable: the daemon may yet finish it.

RateLimited

A per-IP, per-user or per-device rate limit refused the frame.

CapabilityUnavailable

The peer speaks this protocol version but not this capability — an older daemon meeting a feature that shipped after it. Rendered to a user as “your machine needs updating”, never as a failure.

InternalError

Anything else, and anything a peer does not recognise.

Implementations

impl ErrorCode

pub const ALL: &'static [Self]

Every code, in wire order. The exhaustiveness tests and the generated documentation both read this, so a new variant that is not listed here fails the build’s own tests rather than shipping undocumented.

pub const fn retryable(self) -> bool

Whether the same request id may be sent again by an automatic retry.

True only where the operation provably did not start. Everything ambiguous — a timeout above all — is false, and is a decision for a human looking at the machine’s real state.

pub const fn fatal_to_session(self) -> bool

Whether meeting this code should close the device socket.

A daemon that cannot be trusted to frame correctly is not a daemon whose next frame should be believed.

pub const fn as_str(self) -> &'static str

The wire spelling. Kept as a method as well as a serde attribute so the fixture tests can assert the exact string without a round trip.

Trait Implementations

impl Clone for ErrorCode

fn clone(&self) -> ErrorCode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ErrorCode

impl Debug for ErrorCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErrorCode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ErrorCode

impl Hash for ErrorCode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ErrorCode

fn cmp(&self, other: &ErrorCode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for ErrorCode

fn eq(&self, other: &ErrorCode) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for ErrorCode

fn partial_cmp(&self, other: &ErrorCode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ErrorCode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ErrorCode