use serde::{Deserialize, Serialize};
use crate::errors::{Result, TokenizerError};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ReasoningEffort {
None,
High,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ModelSettings {
pub reasoning_effort: Option<ReasoningEffort>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ValidatorType {
#[default]
Enum,
}
fn required_option<'de, D>(
deserializer: D,
) -> std::result::Result<Option<ReasoningEffort>, D::Error>
where
D: serde::Deserializer<'de>,
{
serde::Deserialize::deserialize(deserializer)
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReasoningEffortBuilder {
#[serde(rename = "type", default)]
pub validator_type: ValidatorType,
pub accepts_none: bool,
#[serde(deserialize_with = "required_option")]
pub default: Option<ReasoningEffort>,
pub values: Vec<ReasoningEffort>,
}
impl ReasoningEffortBuilder {
pub fn validate(&self) -> Result<()> {
if !self.accepts_none && self.default.is_some() {
return Err(TokenizerError::InvalidConfig(format!(
"Default values can only be defined for accepts_none fields (accepts_none={}, default={:?})",
self.accepts_none, self.default
)));
}
let mut seen = std::collections::HashSet::new();
for value in &self.values {
if !seen.insert(value) {
return Err(TokenizerError::InvalidConfig(format!(
"Duplicate values in {:?}",
self.values
)));
}
}
if self.values.is_empty() && !self.accepts_none {
return Err(TokenizerError::InvalidConfig(
"Empty list of values while not accepts_none".to_string(),
));
}
if let Some(default) = self.default
&& !self.values.contains(&default)
{
return Err(TokenizerError::InvalidConfig(format!(
"Default value {:?} is not in {:?}",
default, self.values
)));
}
Ok(())
}
pub fn build_value(&self, value: Option<ReasoningEffort>) -> Result<Option<ReasoningEffort>> {
if value.is_none() && !self.accepts_none {
return Err(TokenizerError::InvalidRequest(
"reasoning_effort should be set for this model".to_string(),
));
}
let value = value.or(self.default);
if let Some(value) = value {
if self.values.is_empty() {
return Err(TokenizerError::InvalidRequest(
"reasoning_effort not supported for this model".to_string(),
));
}
if !self.values.contains(&value) {
return Err(TokenizerError::InvalidRequest(format!(
"reasoning_effort should be one of {:?}, got {:?}",
self.values, value
)));
}
}
Ok(value)
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ModelSettingsBuilder {
#[serde(default)]
pub reasoning_effort: Option<ReasoningEffortBuilder>,
}
impl ModelSettingsBuilder {
#[must_use]
pub fn none() -> Self {
Self::default()
}
pub fn validate(&self) -> Result<()> {
if let Some(builder) = &self.reasoning_effort {
builder.validate()?;
}
Ok(())
}
pub fn build_settings(
&self,
reasoning_effort: Option<ReasoningEffort>,
) -> Result<ModelSettings> {
let reasoning_effort = match &self.reasoning_effort {
Some(builder) => builder.build_value(reasoning_effort)?,
None => None,
};
Ok(ModelSettings { reasoning_effort })
}
pub fn validate_settings(&self, settings: &ModelSettings) -> Result<()> {
match &self.reasoning_effort {
None => {
if settings.reasoning_effort.is_some() {
return Err(TokenizerError::InvalidRequest(
"reasoning_effort not supported for this model".to_string(),
));
}
}
Some(builder) => match settings.reasoning_effort {
None => {
if !(builder.accepts_none && builder.default.is_none()) {
return Err(TokenizerError::InvalidRequest(
"reasoning_effort should be set for this model".to_string(),
));
}
}
Some(value) => {
builder.build_value(Some(value))?;
}
},
}
Ok(())
}
}