objectiveai 0.1.4

ObjectiveAI SDK, definitions, and utilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! Reasoning configuration for models that support extended thinking.

use serde::{Deserialize, Serialize};

/// Configuration for model reasoning/thinking capabilities.
///
/// Some models (like o1, o3, Claude with extended thinking) support
/// explicit reasoning modes where they can "think" before responding.
/// This struct configures those capabilities.
///
/// **Note:** The `max_tokens`, `effort`, and `summary_verbosity` fields are
/// only supported by some models. Unsupported fields are silently ignored.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Reasoning {
    /// Whether reasoning is enabled. Defaults to `true` if other fields are set.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    /// Maximum tokens for the reasoning/thinking output.
    ///
    /// Only supported by some models.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<u64>,
    /// The reasoning effort level.
    ///
    /// Only supported by some models.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub effort: Option<ReasoningEffort>,
    /// Verbosity of reasoning summaries in the response.
    ///
    /// Only supported by some models.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary_verbosity: Option<ReasoningSummaryVerbosity>,
}

impl Reasoning {
    /// Normalizes the reasoning configuration for deterministic hashing.
    pub fn prepare(mut self) -> Option<Self> {
        if let Some(0) = self.max_tokens {
            self.max_tokens = None;
        }
        if let Some(ReasoningSummaryVerbosity::Auto) = self.summary_verbosity {
            self.summary_verbosity = None;
        }
        if self.enabled.is_none()
            && (self.max_tokens.is_some()
                || self.effort.is_some()
                || self.summary_verbosity.is_some())
        {
            self.enabled = Some(true);
        }
        if self.enabled.is_some()
            || self.max_tokens.is_some()
            || self.effort.is_some()
            || self.summary_verbosity.is_some()
        {
            Some(self)
        } else {
            None
        }
    }

    /// Validates the reasoning configuration.
    pub fn validate(&self) -> Result<(), String> {
        if self
            .max_tokens
            .is_some_and(|max_tokens| max_tokens > i32::MAX as u64)
        {
            Err(format!(
                "`reasoning.max_tokens` must be at most {}",
                i32::MAX
            ))
        } else if let Some(false) = self.enabled {
            if self.max_tokens.is_some() {
                Err(
                    "`reasoning.enabled` cannot be false if `reasoning.max_tokens` is set"
                        .to_string(),
                )
            } else if self.effort.is_some() {
                Err("`reasoning.enabled` cannot be false if `reasoning.effort` is set".to_string())
            } else if self.summary_verbosity.is_some() {
                Err(
                    "`reasoning.enabled` cannot be false if `reasoning.summary_verbosity` is set"
                        .to_string(),
                )
            } else {
                Ok(())
            }
        } else {
            Ok(())
        }
    }
}

/// The level of effort the model should put into reasoning.
///
/// Only supported by some models.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ReasoningEffort {
    /// No reasoning.
    None,
    /// Minimal reasoning effort.
    Minimal,
    /// Low reasoning effort.
    Low,
    /// Medium reasoning effort.
    Medium,
    /// High reasoning effort.
    High,
    /// Maximum reasoning effort.
    Xhigh,
}

/// Verbosity of the reasoning summary included in responses.
///
/// Only supported by some models.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ReasoningSummaryVerbosity {
    /// Let the model decide (default, normalized away).
    Auto,
    /// Brief summary of reasoning.
    Concise,
    /// Thorough summary of reasoning.
    Detailed,
}