Enum Role 

#[non_exhaustive]
pub enum Role {
    User,
    Model,
    Unknown {
        role_type: String,
        data: Value,
    },
}

Role in a conversation turn.

Indicates whether the content came from the user or the model.

This enum is marked #[non_exhaustive] for forward compatibility. New roles may be added in future API versions.

Evergreen Pattern

Unknown values from the API deserialize into the Unknown variant, preserving the original data for debugging and roundtrip serialization.

Example

use genai_rs::Role;

let role = Role::User;
assert!(matches!(role, Role::User));

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.

User

Content from the user

Model

Content from the model

Unknown

Unknown variant for forward compatibility (Evergreen pattern)

Fields

role_type: String

The unrecognized role type from the API

data: Value

The raw JSON value, preserved for debugging and roundtrip

Implementations

impl Role

pub const fn is_unknown(&self) -> bool

Returns true if this is an unknown role.

pub fn unknown_role_type(&self) -> Option<&str>

Returns the role type name if this is an unknown role.

pub fn unknown_data(&self) -> Option<&Value>

Returns the preserved data if this is an unknown role.

Trait Implementations

impl Clone for Role

fn clone(&self) -> Role

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Role

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Role

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Role

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

Formats the value using the given formatter.

impl PartialEq for Role

fn eq(&self, other: &Role) -> 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 Role

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 Role