Struct ThinkingConfig 

pub struct ThinkingConfig {
    pub thinking_type: ThinkingType,
    pub budget_tokens: Option<u32>,
    pub effort: Option<ThinkingEffort>,
    pub exclude_from_response: bool,
}

Configuration for extended thinking / reasoning mode.

Extended thinking allows models to “think” more deeply about problems, producing better results for complex reasoning tasks. This config works across multiple providers:

• Anthropic: Maps to Claude’s extended thinking with budget_tokens
• OpenRouter: Maps to reasoning parameter with effort levels
• DeepSeek: Maps to enable_thinking parameter
• Qwen3: Controlled via provider-specific parameters

Example

// Enable thinking with budget
let request = CompletionRequest::new(model, messages)
    .with_thinking(ThinkingConfig::enabled(10000));

// Disable thinking for faster responses
let request = CompletionRequest::new(model, messages)
    .without_thinking();

// Control effort level (OpenRouter)
let request = CompletionRequest::new(model, messages)
    .with_thinking(ThinkingConfig::with_effort(ThinkingEffort::Low));

Fields

thinking_type: ThinkingType

Whether thinking is enabled

budget_tokens: Option<u32>

Maximum tokens for thinking (minimum 1024 for Anthropic)

effort: Option<ThinkingEffort>

Effort level for reasoning (supported by OpenRouter and similar providers)

exclude_from_response: bool

If true, reasoning is performed but excluded from the response. The model still “thinks” but the thinking tokens are hidden.

Implementations

impl ThinkingConfig

pub fn enabled(budget_tokens: u32) -> Self

Enable extended thinking with a token budget.

Arguments

• budget_tokens - Maximum tokens for thinking (minimum 1024)

pub fn disabled() -> Self

Disable extended thinking/reasoning.

This will disable reasoning for providers that support it:

• OpenRouter: Sets reasoning.effort to “none”
• DeepSeek: Sets enable_thinking to false
• Anthropic: Omits the thinking block

pub fn with_effort(effort: ThinkingEffort) -> Self

Create a thinking config with a specific effort level.

Useful for providers like OpenRouter that support effort-based reasoning control.

Arguments

• effort - The reasoning effort level (Low, Medium, High, Max)

pub fn with_effort_and_budget( effort: ThinkingEffort, budget_tokens: u32, ) -> Self

Create a thinking config with effort level and token budget.

Arguments

• effort - The reasoning effort level
• budget_tokens - Maximum tokens for reasoning

pub fn exclude_from_response(self, exclude: bool) -> Self

Set whether to exclude thinking from the response.

When true, the model still performs reasoning but the thinking tokens are not included in the response.

pub fn is_enabled(&self) -> bool

Check if thinking is enabled.

Trait Implementations

impl Clone for ThinkingConfig

fn clone(&self) -> ThinkingConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ThinkingConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ThinkingConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ThinkingConfig

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

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 ThinkingConfig

impl StructuralPartialEq for ThinkingConfig