Enum ErrorComponent 

#[non_exhaustive]
pub enum ErrorComponent {
    Agent,
    Model,
    Tool,
    Session,
    Artifact,
    Memory,
    Graph,
    Realtime,
    Code,
    Server,
    Auth,
    Guardrail,
    Eval,
    Deploy,
}

The subsystem that produced the error — the origin, not the boundary it surfaces through.

Choose the variant matching where the failure actually happened, not which trait boundary returned it. For example:

• A code-execution timeout inside python_code_tool.rs → Code
• An auth denial inside middleware → Auth
• A missing API key detected in model config → Model with InvalidInput
• A database write failure in session persistence → Session

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Agent

Error originated in agent logic.

Model

Error originated in model/LLM interaction.

Tool

Error originated in tool execution.

Session

Error originated in session management.

Artifact

Error originated in artifact storage.

Memory

Error originated in memory/RAG operations.

Graph

Error originated in graph workflow execution.

Realtime

Error originated in realtime audio/video streaming.

Code

Error originated in code execution.

Server

Error originated in the HTTP server.

Auth

Error originated in authentication/authorization.

Guardrail

Error originated in guardrail validation.

Eval

Error originated in evaluation framework.

Deploy

Error originated in deployment operations.

Trait Implementations

impl Clone for ErrorComponent

fn clone(&self) -> ErrorComponent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorComponent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErrorComponent

fn deserialize<__D>( __deserializer: __D, ) -> Result<ErrorComponent, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ErrorComponent

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

Formats the value using the given formatter.

impl Hash for ErrorComponent

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

where __H: Hasher,

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

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ErrorComponent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ErrorComponent

impl Eq for ErrorComponent

impl StructuralPartialEq for ErrorComponent