Enum ThinkingLevel 

#[non_exhaustive]
pub enum ThinkingLevel {
    Minimal,
    Low,
    Medium,
    High,
    Unknown {
        level_type: String,
        data: Value,
    },
}

Thinking level for chain-of-thought reasoning.

Controls the depth of reasoning the model performs before generating a response. Higher levels produce more detailed reasoning but consume more tokens.

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

Evergreen Pattern

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

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.

Minimal

Minimal reasoning, fastest responses

Low

Light reasoning for simple problems

Medium

Balanced reasoning for moderate complexity

High

Extensive reasoning for complex problems

Unknown

Unknown variant for forward compatibility (Evergreen pattern)

Fields

level_type: String

The unrecognized level type from the API

data: Value

The full JSON data, preserved for debugging and roundtrip serialization

Implementations

impl ThinkingLevel

pub const fn is_unknown(&self) -> bool

Returns true if this is an unknown thinking level.

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

Returns the level type name if this is an unknown thinking level.

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

Returns the preserved data if this is an unknown thinking level.

Trait Implementations

impl Clone for ThinkingLevel

fn clone(&self) -> ThinkingLevel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ThinkingLevel

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ThinkingLevel

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ThinkingLevel

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ThinkingLevel

impl StructuralPartialEq for ThinkingLevel