Enum MailError 

pub enum MailError {
    UnknownParticipant {
        participant: ParticipantId,
    },
    UnknownRoom {
        room: RoomId,
    },
    UnknownSession {
        session: SessionId,
    },
    SessionAccountMismatch {
        session: SessionId,
        expected: ParticipantId,
        presented: ParticipantId,
    },
    UnknownMessage {
        message_id: MessageId,
    },
    NotAddressedToYou {
        message_id: MessageId,
    },
    PermissionDenied {
        need: String,
    },
    Malformed {
        field: String,
        reason: String,
    },
    TooLarge {
        field: String,
        limit: usize,
        actual: usize,
    },
    StoreUnavailable {
        operation: String,
    },
}

A named refusal. Every variant names its inputs so a caller learns what was refused and why from the refusal alone – never a bare Internal (the crate contract’s own discipline; see mail4agent/CLAUDE.md).

UnknownParticipant/UnknownRoom carry the offending id even though the task’s own sketch of this enum omitted their fields: an “unknown X” refusal that does not say which X is exactly the unnamed-refusal failure mode the crate contract calls out by name.

Variants

UnknownParticipant

No participant is registered under this id.

Fields

participant: ParticipantId

UnknownRoom

No room is registered under this id.

Fields

room: RoomId

UnknownSession

No session is registered under this id – it has never been named in an Address::Session that reached Address::Session’s registering call, MailboxEngine::ensure_session.

Fields

session: SessionId

SessionAccountMismatch

session is registered, but under a different account than the one presented alongside it in an Address::Session. Refused rather than silently resolved either way, because either party being wrong about which account owns a session is exactly the confusion the account/session split exists to prevent.

Fields

session: SessionId

expected: ParticipantId

presented: ParticipantId

UnknownMessage

No message is stored under this id.

Fields

message_id: MessageId

NotAddressedToYou

The message exists, but was not sent to the caller (not their direct address, and not a room they belong to).

Fields

message_id: MessageId

PermissionDenied

The caller’s credential does not carry the capability the operation needs. need names the missing capability, e.g. "mail:send".

Fields

need: String

Malformed

A field failed structural validation. reason says how.

Fields

field: String

reason: String

TooLarge

A field exceeded its bound. Carries both the bound and what was sent so the caller can act without a second round trip.

Fields

field: String

limit: usize

actual: usize

StoreUnavailable

The storage layer could not complete operation (a filesystem error, a lock, a corrupt row – never a domain refusal). Names only the operation, never the underlying cause: that cause is logged server-side for the operator, so a caller learns what failed without a path or a driver’s error text leaving the process.

Fields

operation: String

Trait Implementations

impl Clone for MailError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MailError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MailError

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MailError

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

Formats the value using the given formatter.

impl Eq for MailError

impl Error for MailError

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 PartialEq for MailError

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for MailError

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 MailError