liter_llm 1.9.3 → 1.11.0

data/ext/liter_llm_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:b34f5dac0a6af082b71cab3b75e126050fd38402a73d6d3ff06130b6fe7d8875
+// alef:hash:c7947a41084f71e69944233535fbeda5cd13b37144078f1895b6b57a7802d3fe
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -415,6 +415,7 @@ pub struct AssistantMessage {
     tool_calls: Option<Vec<ToolCall>>,
     refusal: Option<String>,
     function_call: Option<FunctionCall>,
+    reasoning_content: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for AssistantMessage {}
@@ -473,6 +474,9 @@ impl AssistantMessage {
             function_call: kwargs
                 .get(ruby.to_symbol("function_call"))
                 .and_then(|v| FunctionCall::try_convert(v).ok()),
+            reasoning_content: kwargs
+                .get(ruby.to_symbol("reasoning_content"))
+                .and_then(|v| String::try_convert(v).ok()),
         })
     }
 
@@ -496,7 +500,12 @@ impl AssistantMessage {
         self.function_call.clone()
     }
 
+    fn reasoning_content(&self) -> Option<String> {
+        self.reasoning_content.clone()
+    }
+
     fn text(&self) -> Option<String> {
+        #[allow(clippy::needless_update)]
         let core_self = liter_llm::types::AssistantMessage {
             content: self.content.clone().map(Into::into),
 
@@ -507,11 +516,16 @@ impl AssistantMessage {
             refusal: self.refusal.clone(),
 
             function_call: self.function_call.clone().map(Into::into),
+
+            reasoning_content: self.reasoning_content.clone(),
+
+            ..Default::default()
         };
         core_self.text()
     }
 
     fn refusal_text(&self) -> Option<String> {
+        #[allow(clippy::needless_update)]
         let core_self = liter_llm::types::AssistantMessage {
             content: self.content.clone().map(Into::into),
 
@@ -522,11 +536,36 @@ impl AssistantMessage {
             refusal: self.refusal.clone(),
 
             function_call: self.function_call.clone().map(Into::into),
+
+            reasoning_content: self.reasoning_content.clone(),
+
+            ..Default::default()
         };
         core_self.refusal_text().map(|v| v.to_owned())
     }
 
+    fn reasoning_text(&self) -> Option<String> {
+        #[allow(clippy::needless_update)]
+        let core_self = liter_llm::types::AssistantMessage {
+            content: self.content.clone().map(Into::into),
+
+            name: self.name.clone(),
+
+            tool_calls: self.tool_calls.clone().map(|v| v.into_iter().map(Into::into).collect()),
+
+            refusal: self.refusal.clone(),
+
+            function_call: self.function_call.clone().map(Into::into),
+
+            reasoning_content: self.reasoning_content.clone(),
+
+            ..Default::default()
+        };
+        core_self.reasoning_text().map(|v| v.to_owned())
+    }
+
     fn output_images(&self) -> Vec<ImageUrl> {
+        #[allow(clippy::needless_update)]
         let core_self = liter_llm::types::AssistantMessage {
             content: self.content.clone().map(Into::into),
 
@@ -537,11 +576,16 @@ impl AssistantMessage {
             refusal: self.refusal.clone(),
 
             function_call: self.function_call.clone().map(Into::into),
+
+            reasoning_content: self.reasoning_content.clone(),
+
+            ..Default::default()
         };
         core_self.output_images().into_iter().map(Into::into).collect()
     }
 
     fn output_audio(&self) -> Vec<AudioContent> {
+        #[allow(clippy::needless_update)]
         let core_self = liter_llm::types::AssistantMessage {
             content: self.content.clone().map(Into::into),
 
@@ -552,6 +596,10 @@ impl AssistantMessage {
             refusal: self.refusal.clone(),
 
             function_call: self.function_call.clone().map(Into::into),
+
+            reasoning_content: self.reasoning_content.clone(),
+
+            ..Default::default()
         };
         core_self.output_audio().into_iter().map(Into::into).collect()
     }
@@ -2139,6 +2187,7 @@ pub struct StreamDelta {
     tool_calls: Option<Vec<StreamToolCall>>,
     function_call: Option<StreamFunctionCall>,
     refusal: Option<String>,
+    reasoning_content: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for StreamDelta {}
@@ -2197,6 +2246,9 @@ impl StreamDelta {
             refusal: kwargs
                 .get(ruby.to_symbol("refusal"))
                 .and_then(|v| String::try_convert(v).ok()),
+            reasoning_content: kwargs
+                .get(ruby.to_symbol("reasoning_content"))
+                .and_then(|v| String::try_convert(v).ok()),
         })
     }
 
@@ -2220,6 +2272,10 @@ impl StreamDelta {
         self.refusal.clone()
     }
 
+    fn reasoning_content(&self) -> Option<String> {
+        self.reasoning_content.clone()
+    }
+
     #[allow(clippy::should_implement_trait)]
     fn to_s(&self) -> String {
         self.content.clone().unwrap_or_default()
@@ -2564,7 +2620,7 @@ impl EmbeddingResponse {
 #[magnus::wrap(class = "LiterLlm::EmbeddingObject")]
 pub struct EmbeddingObject {
     object: String,
-    embedding: Vec<f64>,
+    embedding: Vec<f32>,
     index: u32,
 }
 
@@ -2609,7 +2665,7 @@ impl EmbeddingObject {
                 .unwrap_or_default(),
             embedding: kwargs
                 .get(ruby.to_symbol("embedding"))
-                .and_then(|v| <Vec<f64>>::try_convert(v).ok())
+                .and_then(|v| <Vec<f32>>::try_convert(v).ok())
                 .unwrap_or_default(),
             index: kwargs
                 .get(ruby.to_symbol("index"))
@@ -2622,7 +2678,7 @@ impl EmbeddingObject {
         self.object.clone()
     }
 
-    fn embedding(&self) -> Vec<f64> {
+    fn embedding(&self) -> Vec<f32> {
         self.embedding.clone()
     }
 
@@ -7249,6 +7305,330 @@ impl AuthConfig {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::ModelInfo")]
+pub struct ModelInfo {
+    input_cost_per_token: f64,
+    output_cost_per_token: f64,
+    cache_read_input_token_cost: Option<f64>,
+    cache_creation_input_token_cost: Option<f64>,
+    input_cost_per_audio_token: Option<f64>,
+    output_cost_per_audio_token: Option<f64>,
+    output_cost_per_reasoning_token: Option<f64>,
+    max_tokens: Option<u64>,
+    max_input_tokens: Option<u64>,
+    max_output_tokens: Option<u64>,
+    mode: Option<String>,
+    supports_vision: Option<bool>,
+    supports_function_calling: Option<bool>,
+    supports_reasoning: Option<bool>,
+    supports_structured_output: Option<bool>,
+    supports_audio_input: Option<bool>,
+    supports_audio_output: Option<bool>,
+    supports_prompt_caching: Option<bool>,
+    tiers: Vec<ModelTier>,
+}
+
+unsafe impl IntoValueFromNative for ModelInfo {}
+
+impl magnus::TryConvert for ModelInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ModelInfo as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into ModelInfo: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ModelInfo>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ModelInfo: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ModelInfo {}
+
+impl Default for ModelInfo {
+    fn default() -> Self {
+        liter_llm::ModelInfo::default().into()
+    }
+}
+
+impl ModelInfo {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            input_cost_per_token: kwargs
+                .get(ruby.to_symbol("input_cost_per_token"))
+                .and_then(|v| f64::try_convert(v).ok())
+                .unwrap_or_default(),
+            output_cost_per_token: kwargs
+                .get(ruby.to_symbol("output_cost_per_token"))
+                .and_then(|v| f64::try_convert(v).ok())
+                .unwrap_or_default(),
+            cache_read_input_token_cost: kwargs
+                .get(ruby.to_symbol("cache_read_input_token_cost"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            cache_creation_input_token_cost: kwargs
+                .get(ruby.to_symbol("cache_creation_input_token_cost"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            input_cost_per_audio_token: kwargs
+                .get(ruby.to_symbol("input_cost_per_audio_token"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            output_cost_per_audio_token: kwargs
+                .get(ruby.to_symbol("output_cost_per_audio_token"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            output_cost_per_reasoning_token: kwargs
+                .get(ruby.to_symbol("output_cost_per_reasoning_token"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            max_tokens: kwargs
+                .get(ruby.to_symbol("max_tokens"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            max_input_tokens: kwargs
+                .get(ruby.to_symbol("max_input_tokens"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            max_output_tokens: kwargs
+                .get(ruby.to_symbol("max_output_tokens"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            mode: kwargs
+                .get(ruby.to_symbol("mode"))
+                .and_then(|v| String::try_convert(v).ok()),
+            supports_vision: kwargs
+                .get(ruby.to_symbol("supports_vision"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            supports_function_calling: kwargs
+                .get(ruby.to_symbol("supports_function_calling"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            supports_reasoning: kwargs
+                .get(ruby.to_symbol("supports_reasoning"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            supports_structured_output: kwargs
+                .get(ruby.to_symbol("supports_structured_output"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            supports_audio_input: kwargs
+                .get(ruby.to_symbol("supports_audio_input"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            supports_audio_output: kwargs
+                .get(ruby.to_symbol("supports_audio_output"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            supports_prompt_caching: kwargs
+                .get(ruby.to_symbol("supports_prompt_caching"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            tiers: kwargs
+                .get(ruby.to_symbol("tiers"))
+                .and_then(|v| <Vec<ModelTier>>::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn input_cost_per_token(&self) -> f64 {
+        self.input_cost_per_token
+    }
+
+    fn output_cost_per_token(&self) -> f64 {
+        self.output_cost_per_token
+    }
+
+    fn cache_read_input_token_cost(&self) -> Option<f64> {
+        self.cache_read_input_token_cost
+    }
+
+    fn cache_creation_input_token_cost(&self) -> Option<f64> {
+        self.cache_creation_input_token_cost
+    }
+
+    fn input_cost_per_audio_token(&self) -> Option<f64> {
+        self.input_cost_per_audio_token
+    }
+
+    fn output_cost_per_audio_token(&self) -> Option<f64> {
+        self.output_cost_per_audio_token
+    }
+
+    fn output_cost_per_reasoning_token(&self) -> Option<f64> {
+        self.output_cost_per_reasoning_token
+    }
+
+    fn max_tokens(&self) -> Option<u64> {
+        self.max_tokens
+    }
+
+    fn max_input_tokens(&self) -> Option<u64> {
+        self.max_input_tokens
+    }
+
+    fn max_output_tokens(&self) -> Option<u64> {
+        self.max_output_tokens
+    }
+
+    fn mode(&self) -> Option<String> {
+        self.mode.clone()
+    }
+
+    fn supports_vision(&self) -> Option<bool> {
+        self.supports_vision
+    }
+
+    fn supports_function_calling(&self) -> Option<bool> {
+        self.supports_function_calling
+    }
+
+    fn supports_reasoning(&self) -> Option<bool> {
+        self.supports_reasoning
+    }
+
+    fn supports_structured_output(&self) -> Option<bool> {
+        self.supports_structured_output
+    }
+
+    fn supports_audio_input(&self) -> Option<bool> {
+        self.supports_audio_input
+    }
+
+    fn supports_audio_output(&self) -> Option<bool> {
+        self.supports_audio_output
+    }
+
+    fn supports_prompt_caching(&self) -> Option<bool> {
+        self.supports_prompt_caching
+    }
+
+    fn tiers(&self) -> Vec<ModelTier> {
+        self.tiers.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::ModelTier")]
+pub struct ModelTier {
+    min_context_tokens: u64,
+    input_cost_per_token: f64,
+    output_cost_per_token: f64,
+    cache_read_input_token_cost: Option<f64>,
+    cache_creation_input_token_cost: Option<f64>,
+    input_cost_per_audio_token: Option<f64>,
+    output_cost_per_audio_token: Option<f64>,
+    output_cost_per_reasoning_token: Option<f64>,
+}
+
+unsafe impl IntoValueFromNative for ModelTier {}
+
+impl magnus::TryConvert for ModelTier {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ModelTier as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into ModelTier: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ModelTier>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ModelTier: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ModelTier {}
+
+impl Default for ModelTier {
+    fn default() -> Self {
+        liter_llm::ModelTier::default().into()
+    }
+}
+
+impl ModelTier {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            min_context_tokens: kwargs
+                .get(ruby.to_symbol("min_context_tokens"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or_default(),
+            input_cost_per_token: kwargs
+                .get(ruby.to_symbol("input_cost_per_token"))
+                .and_then(|v| f64::try_convert(v).ok())
+                .unwrap_or_default(),
+            output_cost_per_token: kwargs
+                .get(ruby.to_symbol("output_cost_per_token"))
+                .and_then(|v| f64::try_convert(v).ok())
+                .unwrap_or_default(),
+            cache_read_input_token_cost: kwargs
+                .get(ruby.to_symbol("cache_read_input_token_cost"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            cache_creation_input_token_cost: kwargs
+                .get(ruby.to_symbol("cache_creation_input_token_cost"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            input_cost_per_audio_token: kwargs
+                .get(ruby.to_symbol("input_cost_per_audio_token"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            output_cost_per_audio_token: kwargs
+                .get(ruby.to_symbol("output_cost_per_audio_token"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            output_cost_per_reasoning_token: kwargs
+                .get(ruby.to_symbol("output_cost_per_reasoning_token"))
+                .and_then(|v| f64::try_convert(v).ok()),
+        })
+    }
+
+    fn min_context_tokens(&self) -> u64 {
+        self.min_context_tokens
+    }
+
+    fn input_cost_per_token(&self) -> f64 {
+        self.input_cost_per_token
+    }
+
+    fn output_cost_per_token(&self) -> f64 {
+        self.output_cost_per_token
+    }
+
+    fn cache_read_input_token_cost(&self) -> Option<f64> {
+        self.cache_read_input_token_cost
+    }
+
+    fn cache_creation_input_token_cost(&self) -> Option<f64> {
+        self.cache_creation_input_token_cost
+    }
+
+    fn input_cost_per_audio_token(&self) -> Option<f64> {
+        self.input_cost_per_audio_token
+    }
+
+    fn output_cost_per_audio_token(&self) -> Option<f64> {
+        self.output_cost_per_audio_token
+    }
+
+    fn output_cost_per_reasoning_token(&self) -> Option<f64> {
+        self.output_cost_per_reasoning_token
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::BudgetConfig")]
@@ -7326,6 +7706,84 @@ impl BudgetConfig {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::CacheConfig")]
+pub struct CacheConfig {
+    max_entries: usize,
+    ttl: u64,
+    backend: CacheBackend,
+}
+
+unsafe impl IntoValueFromNative for CacheConfig {}
+
+impl magnus::TryConvert for CacheConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&CacheConfig as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into CacheConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<CacheConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize CacheConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for CacheConfig {}
+
+impl Default for CacheConfig {
+    fn default() -> Self {
+        liter_llm::CacheConfig::default().into()
+    }
+}
+
+impl CacheConfig {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            max_entries: kwargs
+                .get(ruby.to_symbol("max_entries"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or(256),
+            ttl: kwargs
+                .get(ruby.to_symbol("ttl"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or(300000),
+            backend: kwargs
+                .get(ruby.to_symbol("backend"))
+                .and_then(|v| CacheBackend::try_convert(v).ok())
+                .unwrap_or(CacheBackend::Memory),
+        })
+    }
+
+    fn max_entries(&self) -> usize {
+        self.max_entries
+    }
+
+    fn ttl(&self) -> u64 {
+        self.ttl.clone()
+    }
+
+    fn backend(&self) -> CacheBackend {
+        self.backend.clone()
+    }
+}
+
 #[derive(Clone)]
 #[magnus::wrap(class = "LiterLlm::SingleflightResult")]
 pub struct SingleflightResult {
@@ -7489,10 +7947,96 @@ impl IntentPrototype {
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-#[serde(tag = "role")]
-pub enum Message {
-    #[serde(rename = "system")]
-    System { _0: SystemMessage },
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::CatalogRefreshConfig")]
+pub struct CatalogRefreshConfig {
+    enabled: bool,
+    source_url: String,
+    ttl_seconds: u64,
+    cache_path: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for CatalogRefreshConfig {}
+
+impl magnus::TryConvert for CatalogRefreshConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&CatalogRefreshConfig as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into CatalogRefreshConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<CatalogRefreshConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize CatalogRefreshConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for CatalogRefreshConfig {}
+
+impl Default for CatalogRefreshConfig {
+    fn default() -> Self {
+        liter_llm::cost::refresh::CatalogRefreshConfig::default().into()
+    }
+}
+
+impl CatalogRefreshConfig {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            enabled: kwargs
+                .get(ruby.to_symbol("enabled"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            source_url: kwargs
+                .get(ruby.to_symbol("source_url"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            ttl_seconds: kwargs
+                .get(ruby.to_symbol("ttl_seconds"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or(86400),
+            cache_path: kwargs
+                .get(ruby.to_symbol("cache_path"))
+                .and_then(|v| String::try_convert(v).ok()),
+        })
+    }
+
+    fn enabled(&self) -> bool {
+        self.enabled
+    }
+
+    fn source_url(&self) -> String {
+        self.source_url.clone()
+    }
+
+    fn ttl_seconds(&self) -> u64 {
+        self.ttl_seconds
+    }
+
+    fn cache_path(&self) -> Option<String> {
+        self.cache_path.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "role")]
+pub enum Message {
+    #[serde(rename = "system")]
+    System { _0: SystemMessage },
     #[serde(rename = "user")]
     User { _0: UserMessage },
     #[serde(rename = "assistant")]
@@ -8855,6 +9399,65 @@ impl magnus::TryConvert for Enforcement {
 unsafe impl IntoValueFromNative for Enforcement {}
 unsafe impl TryConvertOwned for Enforcement {}
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "type")]
+#[serde(rename_all = "snake_case")]
+pub enum CacheBackend {
+    Memory,
+    OpenDal { scheme: String, config: String },
+}
+
+impl Default for CacheBackend {
+    fn default() -> Self {
+        Self::Memory
+    }
+}
+
+impl magnus::IntoValue for CacheBackend {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        match serde_json::to_value(&self) {
+            Ok(v) => json_to_ruby(handle, v),
+            Err(_) => handle.qnil().into_value_with(handle),
+        }
+    }
+}
+
+impl magnus::TryConvert for CacheBackend {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // For unit enums or when passed as a string, fall back to string-based conversion.
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into CacheBackend: {}", e),
+                )
+            })?
+        };
+        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
+        // For internally-tagged enums, a bare variant string is wrapped as {"<tag>": value}.
+        // If that fails, try treating it as a plain string value and wrap in quotes
+        // If both fail, try as Custom variant (for untagged enum support)
+        serde_json::from_str(&json_str)
+            .or_else(|_| serde_json::from_value(serde_json::json!({ "type": json_str })))
+            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
+            .or_else(|_| {
+                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
+                match serde_json::to_value(&json_str) {
+                    Ok(val) => serde_json::from_value(val),
+                    Err(e) => Err(e),
+                }
+            })
+            .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
+    }
+}
+
+unsafe impl IntoValueFromNative for CacheBackend {}
+unsafe impl TryConvertOwned for CacheBackend {}
+impl CacheBackend {}
+
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
 pub enum CircuitState {
     Closed,
@@ -8940,6 +9543,50 @@ impl magnus::TryConvert for HealthStatus {
 unsafe impl IntoValueFromNative for HealthStatus {}
 unsafe impl TryConvertOwned for HealthStatus {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum RefreshOutcome {
+    Disabled,
+    FromCache,
+    Fetched,
+}
+
+impl Default for RefreshOutcome {
+    fn default() -> Self {
+        Self::Disabled
+    }
+}
+
+impl magnus::IntoValue for RefreshOutcome {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            RefreshOutcome::Disabled => "disabled",
+            RefreshOutcome::FromCache => "from_cache",
+            RefreshOutcome::Fetched => "fetched",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for RefreshOutcome {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        // Accept the serde wire name (snake_case), the PascalCase Rust variant name,
+        // and a lowercase fallback so fixtures written in any of those styles work.
+        match s.as_str() {
+            "disabled" | "Disabled" => Ok(RefreshOutcome::Disabled),
+            "from_cache" | "FromCache" => Ok(RefreshOutcome::FromCache),
+            "fetched" | "Fetched" => Ok(RefreshOutcome::Fetched),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid RefreshOutcome value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for RefreshOutcome {}
+unsafe impl TryConvertOwned for RefreshOutcome {}
+
 fn create_client(args: &[magnus::Value]) -> Result<DefaultClient, Error> {
     let args = magnus::scan_args::scan_args::<
         (String,),
@@ -9075,6 +9722,10 @@ fn completion_cost_with_cache(
     liter_llm::completion_cost_with_cache(&model, prompt_tokens, cached_tokens, completion_tokens)
 }
 
+fn model_info(model: String) -> Option<ModelInfo> {
+    liter_llm::model_info(&model).map(Into::into)
+}
+
 fn clear() -> () {
     liter_llm::guardrail::registry::clear()
 }
@@ -9134,16 +9785,98 @@ fn ensure_crypto_provider() -> () {
     liter_llm::ensure_crypto_provider()
 }
 
+fn install_catalog_overlay_from_str(catalog_json: String) -> Result<(), Error> {
+    let result = liter_llm::cost::refresh::install_catalog_overlay_from_str(&catalog_json).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
+fn clear_catalog_overlay() -> () {
+    liter_llm::cost::refresh::clear_catalog_overlay()
+}
+
+fn refresh_catalog(args: &[magnus::Value]) -> Result<RefreshOutcome, Error> {
+    let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (config,) = args.optional;
+
+    let config_core: liter_llm::CatalogRefreshConfig = match config {
+        Some(_v) if !_v.is_nil() => {
+            let binding_val: CatalogRefreshConfig = CatalogRefreshConfig::try_convert(_v).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+            binding_val.into()
+        }
+        _ => Default::default(),
+    };
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { liter_llm::cost::refresh::refresh_catalog(&config_core).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
+fn refresh_catalog_async(args: &[magnus::Value]) -> Result<RefreshOutcome, Error> {
+    let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (config,) = args.optional;
+
+    let config_core: liter_llm::CatalogRefreshConfig = match config {
+        Some(_v) if !_v.is_nil() => {
+            let binding_val: CatalogRefreshConfig = CatalogRefreshConfig::try_convert(_v).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+            binding_val.into()
+        }
+        _ => Default::default(),
+    };
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { liter_llm::cost::refresh::refresh_catalog(&config_core).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
 fn chat_stream(engine: DefaultClient, req: ChatCompletionRequest) -> Result<magnus::Value, Error> {
     engine.chat_stream(req)
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<SystemMessage> for liter_llm::types::SystemMessage {
     fn from(val: SystemMessage) -> Self {
         Self {
             content: val.content.into(),
             name: val.name,
+            ..Default::default()
         }
     }
 }
@@ -9158,12 +9891,14 @@ impl From<liter_llm::types::SystemMessage> for SystemMessage {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<UserMessage> for liter_llm::types::UserMessage {
     fn from(val: UserMessage) -> Self {
         Self {
             content: val.content.into(),
             name: val.name,
+            ..Default::default()
         }
     }
 }
@@ -9178,12 +9913,14 @@ impl From<liter_llm::types::UserMessage> for UserMessage {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ImageUrl> for liter_llm::types::ImageUrl {
     fn from(val: ImageUrl) -> Self {
         Self {
             url: val.url,
             detail: val.detail.map(Into::into),
+            ..Default::default()
         }
     }
 }
@@ -9198,12 +9935,14 @@ impl From<liter_llm::types::ImageUrl> for ImageUrl {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DocumentContent> for liter_llm::types::DocumentContent {
     fn from(val: DocumentContent) -> Self {
         Self {
             data: val.data,
             media_type: val.media_type,
+            ..Default::default()
         }
     }
 }
@@ -9218,12 +9957,14 @@ impl From<liter_llm::types::DocumentContent> for DocumentContent {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<AudioContent> for liter_llm::types::AudioContent {
     fn from(val: AudioContent) -> Self {
         Self {
             data: val.data,
             format: val.format,
+            ..Default::default()
         }
     }
 }
@@ -9238,6 +9979,7 @@ impl From<liter_llm::types::AudioContent> for AudioContent {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<AssistantMessage> for liter_llm::types::AssistantMessage {
     fn from(val: AssistantMessage) -> Self {
@@ -9247,6 +9989,8 @@ impl From<AssistantMessage> for liter_llm::types::AssistantMessage {
             tool_calls: val.tool_calls.map(|v| v.into_iter().map(Into::into).collect()),
             refusal: val.refusal,
             function_call: val.function_call.map(Into::into),
+            reasoning_content: val.reasoning_content,
+            ..Default::default()
         }
     }
 }
@@ -9260,10 +10004,12 @@ impl From<liter_llm::types::AssistantMessage> for AssistantMessage {
             tool_calls: val.tool_calls.map(|v| v.into_iter().map(Into::into).collect()),
             refusal: val.refusal.map(|v| v.to_string()),
             function_call: val.function_call.map(Into::into),
+            reasoning_content: val.reasoning_content.map(|v| v.to_string()),
         }
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ToolMessage> for liter_llm::types::ToolMessage {
     fn from(val: ToolMessage) -> Self {
@@ -9271,6 +10017,7 @@ impl From<ToolMessage> for liter_llm::types::ToolMessage {
             content: val.content,
             tool_call_id: val.tool_call_id,
             name: val.name,
+            ..Default::default()
         }
     }
 }
@@ -9286,12 +10033,14 @@ impl From<liter_llm::types::ToolMessage> for ToolMessage {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DeveloperMessage> for liter_llm::types::DeveloperMessage {
     fn from(val: DeveloperMessage) -> Self {
         Self {
             content: val.content,
             name: val.name,
+            ..Default::default()
         }
     }
 }
@@ -9306,12 +10055,14 @@ impl From<liter_llm::types::DeveloperMessage> for DeveloperMessage {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<FunctionMessage> for liter_llm::types::FunctionMessage {
     fn from(val: FunctionMessage) -> Self {
         Self {
             content: val.content,
             name: val.name,
+            ..Default::default()
         }
     }
 }
@@ -9412,12 +10163,14 @@ impl From<liter_llm::types::FunctionCall> for FunctionCall {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<SpecificToolChoice> for liter_llm::types::SpecificToolChoice {
     fn from(val: SpecificToolChoice) -> Self {
         Self {
             choice_type: val.choice_type.into(),
             function: val.function.into(),
+            ..Default::default()
         }
     }
 }
@@ -9432,10 +10185,14 @@ impl From<liter_llm::types::SpecificToolChoice> for SpecificToolChoice {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<SpecificFunction> for liter_llm::types::SpecificFunction {
     fn from(val: SpecificFunction) -> Self {
-        Self { name: val.name }
+        Self {
+            name: val.name,
+            ..Default::default()
+        }
     }
 }
 
@@ -9448,6 +10205,7 @@ impl From<liter_llm::types::SpecificFunction> for SpecificFunction {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<JsonSchemaFormat> for liter_llm::types::JsonSchemaFormat {
     fn from(val: JsonSchemaFormat) -> Self {
@@ -9456,6 +10214,7 @@ impl From<JsonSchemaFormat> for liter_llm::types::JsonSchemaFormat {
             description: val.description,
             schema: serde_json::from_str(&val.schema).unwrap_or_default(),
             strict: val.strict,
+            ..Default::default()
         }
     }
 }
@@ -9472,6 +10231,7 @@ impl From<liter_llm::types::JsonSchemaFormat> for JsonSchemaFormat {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<Usage> for liter_llm::types::Usage {
     fn from(val: Usage) -> Self {
@@ -9480,6 +10240,7 @@ impl From<Usage> for liter_llm::types::Usage {
             completion_tokens: val.completion_tokens,
             total_tokens: val.total_tokens,
             prompt_tokens_details: val.prompt_tokens_details.map(Into::into),
+            ..Default::default()
         }
     }
 }
@@ -9496,12 +10257,14 @@ impl From<liter_llm::types::Usage> for Usage {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<PromptTokensDetails> for liter_llm::types::PromptTokensDetails {
     fn from(val: PromptTokensDetails) -> Self {
         Self {
             cached_tokens: val.cached_tokens,
             audio_tokens: val.audio_tokens,
+            ..Default::default()
         }
     }
 }
@@ -9516,6 +10279,7 @@ impl From<liter_llm::types::PromptTokensDetails> for PromptTokensDetails {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ChatCompletionRequest> for liter_llm::types::ChatCompletionRequest {
     fn from(val: ChatCompletionRequest) -> Self {
@@ -9541,6 +10305,7 @@ impl From<ChatCompletionRequest> for liter_llm::types::ChatCompletionRequest {
             reasoning_effort: val.reasoning_effort.map(Into::into),
             modalities: val.modalities.map(|v| v.into_iter().map(Into::into).collect()),
             extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            ..Default::default()
         }
     }
 }
@@ -9574,11 +10339,13 @@ impl From<liter_llm::types::ChatCompletionRequest> for ChatCompletionRequest {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<StreamOptions> for liter_llm::types::StreamOptions {
     fn from(val: StreamOptions) -> Self {
         Self {
             include_usage: val.include_usage,
+            ..Default::default()
         }
     }
 }
@@ -9592,6 +10359,7 @@ impl From<liter_llm::types::StreamOptions> for StreamOptions {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ChatCompletionResponse> for liter_llm::types::ChatCompletionResponse {
     fn from(val: ChatCompletionResponse) -> Self {
@@ -9604,6 +10372,7 @@ impl From<ChatCompletionResponse> for liter_llm::types::ChatCompletionResponse {
             usage: val.usage.map(Into::into),
             system_fingerprint: val.system_fingerprint,
             service_tier: val.service_tier,
+            ..Default::default()
         }
     }
 }
@@ -9624,6 +10393,7 @@ impl From<liter_llm::types::ChatCompletionResponse> for ChatCompletionResponse {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<Choice> for liter_llm::types::Choice {
     fn from(val: Choice) -> Self {
@@ -9631,6 +10401,7 @@ impl From<Choice> for liter_llm::types::Choice {
             index: val.index,
             message: val.message.into(),
             finish_reason: val.finish_reason.map(Into::into),
+            ..Default::default()
         }
     }
 }
@@ -9682,6 +10453,7 @@ impl From<liter_llm::types::StreamDelta> for StreamDelta {
             tool_calls: val.tool_calls.map(|v| v.into_iter().map(Into::into).collect()),
             function_call: val.function_call.map(Into::into),
             refusal: val.refusal.map(|v| v.to_string()),
+            reasoning_content: val.reasoning_content.map(|v| v.to_string()),
         }
     }
 }
@@ -9708,6 +10480,7 @@ impl From<liter_llm::types::StreamFunctionCall> for StreamFunctionCall {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<EmbeddingRequest> for liter_llm::types::EmbeddingRequest {
     fn from(val: EmbeddingRequest) -> Self {
@@ -9717,6 +10490,7 @@ impl From<EmbeddingRequest> for liter_llm::types::EmbeddingRequest {
             encoding_format: val.encoding_format.map(Into::into),
             dimensions: val.dimensions,
             user: val.user,
+            ..Default::default()
         }
     }
 }
@@ -9780,6 +10554,7 @@ impl From<liter_llm::types::EmbeddingObject> for EmbeddingObject {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<CreateImageRequest> for liter_llm::types::CreateImageRequest {
     fn from(val: CreateImageRequest) -> Self {
@@ -9792,6 +10567,7 @@ impl From<CreateImageRequest> for liter_llm::types::CreateImageRequest {
             style: val.style,
             response_format: val.response_format,
             user: val.user,
+            ..Default::default()
         }
     }
 }
@@ -9812,12 +10588,14 @@ impl From<liter_llm::types::CreateImageRequest> for CreateImageRequest {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ImagesResponse> for liter_llm::types::ImagesResponse {
     fn from(val: ImagesResponse) -> Self {
         Self {
             created: val.created,
             data: val.data.into_iter().map(Into::into).collect(),
+            ..Default::default()
         }
     }
 }
@@ -9832,6 +10610,7 @@ impl From<liter_llm::types::ImagesResponse> for ImagesResponse {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<Image> for liter_llm::types::Image {
     fn from(val: Image) -> Self {
@@ -9839,6 +10618,7 @@ impl From<Image> for liter_llm::types::Image {
             url: val.url,
             b64_json: val.b64_json,
             revised_prompt: val.revised_prompt,
+            ..Default::default()
         }
     }
 }
@@ -9854,12 +10634,14 @@ impl From<liter_llm::types::Image> for Image {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DecodedDataUrl> for liter_llm::image::DecodedDataUrl {
     fn from(val: DecodedDataUrl) -> Self {
         Self {
             mime: val.mime,
             data: val.data.to_vec().into(),
+            ..Default::default()
         }
     }
 }
@@ -9874,6 +10656,7 @@ impl From<liter_llm::image::DecodedDataUrl> for DecodedDataUrl {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<CreateSpeechRequest> for liter_llm::types::CreateSpeechRequest {
     fn from(val: CreateSpeechRequest) -> Self {
@@ -9883,6 +10666,7 @@ impl From<CreateSpeechRequest> for liter_llm::types::CreateSpeechRequest {
             voice: val.voice,
             response_format: val.response_format,
             speed: val.speed,
+            ..Default::default()
         }
     }
 }
@@ -9900,6 +10684,7 @@ impl From<liter_llm::types::CreateSpeechRequest> for CreateSpeechRequest {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<CreateTranscriptionRequest> for liter_llm::types::CreateTranscriptionRequest {
     fn from(val: CreateTranscriptionRequest) -> Self {
@@ -9910,6 +10695,7 @@ impl From<CreateTranscriptionRequest> for liter_llm::types::CreateTranscriptionR
             prompt: val.prompt,
             response_format: val.response_format,
             temperature: val.temperature,
+            ..Default::default()
         }
     }
 }
@@ -9928,6 +10714,7 @@ impl From<liter_llm::types::CreateTranscriptionRequest> for CreateTranscriptionR
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<TranscriptionResponse> for liter_llm::types::TranscriptionResponse {
     fn from(val: TranscriptionResponse) -> Self {
@@ -9936,6 +10723,7 @@ impl From<TranscriptionResponse> for liter_llm::types::TranscriptionResponse {
             language: val.language,
             duration: val.duration,
             segments: val.segments.map(|v| v.into_iter().map(Into::into).collect()),
+            ..Default::default()
         }
     }
 }
@@ -9952,6 +10740,7 @@ impl From<liter_llm::types::TranscriptionResponse> for TranscriptionResponse {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<TranscriptionSegment> for liter_llm::types::TranscriptionSegment {
     fn from(val: TranscriptionSegment) -> Self {
@@ -9960,6 +10749,7 @@ impl From<TranscriptionSegment> for liter_llm::types::TranscriptionSegment {
             start: val.start,
             end: val.end,
             text: val.text,
+            ..Default::default()
         }
     }
 }
@@ -9976,12 +10766,14 @@ impl From<liter_llm::types::TranscriptionSegment> for TranscriptionSegment {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ModerationRequest> for liter_llm::types::ModerationRequest {
     fn from(val: ModerationRequest) -> Self {
         Self {
             input: val.input.into(),
             model: val.model,
+            ..Default::default()
         }
     }
 }
@@ -10040,6 +10832,7 @@ impl From<liter_llm::types::ModerationResult> for ModerationResult {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ModerationCategories> for liter_llm::types::ModerationCategories {
     fn from(val: ModerationCategories) -> Self {
@@ -10055,6 +10848,7 @@ impl From<ModerationCategories> for liter_llm::types::ModerationCategories {
             self_harm_instructions: val.self_harm_instructions,
             harassment_threatening: val.harassment_threatening,
             violence: val.violence,
+            ..Default::default()
         }
     }
 }
@@ -10078,6 +10872,7 @@ impl From<liter_llm::types::ModerationCategories> for ModerationCategories {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ModerationCategoryScores> for liter_llm::types::ModerationCategoryScores {
     fn from(val: ModerationCategoryScores) -> Self {
@@ -10093,6 +10888,7 @@ impl From<ModerationCategoryScores> for liter_llm::types::ModerationCategoryScor
             self_harm_instructions: val.self_harm_instructions,
             harassment_threatening: val.harassment_threatening,
             violence: val.violence,
+            ..Default::default()
         }
     }
 }
@@ -10116,6 +10912,7 @@ impl From<liter_llm::types::ModerationCategoryScores> for ModerationCategoryScor
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<RerankRequest> for liter_llm::types::RerankRequest {
     fn from(val: RerankRequest) -> Self {
@@ -10125,6 +10922,7 @@ impl From<RerankRequest> for liter_llm::types::RerankRequest {
             documents: val.documents.into_iter().map(Into::into).collect(),
             top_n: val.top_n,
             return_documents: val.return_documents,
+            ..Default::default()
         }
     }
 }
@@ -10202,6 +11000,7 @@ impl From<liter_llm::types::RerankResultDocument> for RerankResultDocument {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<SearchRequest> for liter_llm::types::SearchRequest {
     fn from(val: SearchRequest) -> Self {
@@ -10211,6 +11010,7 @@ impl From<SearchRequest> for liter_llm::types::SearchRequest {
             max_results: val.max_results,
             search_domain_filter: val.search_domain_filter.map(|v| v.into_iter().collect()),
             country: val.country,
+            ..Default::default()
         }
     }
 }
@@ -10272,6 +11072,7 @@ impl From<liter_llm::types::SearchResult> for SearchResult {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<OcrRequest> for liter_llm::types::OcrRequest {
     fn from(val: OcrRequest) -> Self {
@@ -10280,6 +11081,7 @@ impl From<OcrRequest> for liter_llm::types::OcrRequest {
             document: val.document.into(),
             pages: val.pages.map(|v| v.into_iter().collect()),
             include_image_base64: val.include_image_base64,
+            ..Default::default()
         }
     }
 }
@@ -10382,12 +11184,14 @@ impl From<liter_llm::types::PageDimensions> for PageDimensions {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ModelsListResponse> for liter_llm::types::ModelsListResponse {
     fn from(val: ModelsListResponse) -> Self {
         Self {
             object: val.object,
             data: val.data.into_iter().map(Into::into).collect(),
+            ..Default::default()
         }
     }
 }
@@ -10402,6 +11206,7 @@ impl From<liter_llm::types::ModelsListResponse> for ModelsListResponse {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ModelObject> for liter_llm::types::ModelObject {
     fn from(val: ModelObject) -> Self {
@@ -10410,6 +11215,7 @@ impl From<ModelObject> for liter_llm::types::ModelObject {
             object: val.object,
             created: val.created,
             owned_by: val.owned_by,
+            ..Default::default()
         }
     }
 }
@@ -10426,6 +11232,7 @@ impl From<liter_llm::types::ModelObject> for ModelObject {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<CreateFileRequest> for liter_llm::types::CreateFileRequest {
     fn from(val: CreateFileRequest) -> Self {
@@ -10433,6 +11240,7 @@ impl From<CreateFileRequest> for liter_llm::types::CreateFileRequest {
             file: val.file,
             purpose: val.purpose.into(),
             filename: val.filename,
+            ..Default::default()
         }
     }
 }
@@ -10448,6 +11256,7 @@ impl From<liter_llm::types::CreateFileRequest> for CreateFileRequest {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<FileObject> for liter_llm::types::FileObject {
     fn from(val: FileObject) -> Self {
@@ -10459,6 +11268,7 @@ impl From<FileObject> for liter_llm::types::FileObject {
             filename: val.filename,
             purpose: val.purpose,
             status: val.status,
+            ..Default::default()
         }
     }
 }
@@ -10478,6 +11288,7 @@ impl From<liter_llm::types::FileObject> for FileObject {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<FileListResponse> for liter_llm::types::FileListResponse {
     fn from(val: FileListResponse) -> Self {
@@ -10485,6 +11296,7 @@ impl From<FileListResponse> for liter_llm::types::FileListResponse {
             object: val.object,
             data: val.data.into_iter().map(Into::into).collect(),
             has_more: val.has_more,
+            ..Default::default()
         }
     }
 }
@@ -10500,6 +11312,7 @@ impl From<liter_llm::types::FileListResponse> for FileListResponse {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<FileListQuery> for liter_llm::types::FileListQuery {
     fn from(val: FileListQuery) -> Self {
@@ -10507,6 +11320,7 @@ impl From<FileListQuery> for liter_llm::types::FileListQuery {
             purpose: val.purpose,
             limit: val.limit,
             after: val.after,
+            ..Default::default()
         }
     }
 }
@@ -10522,6 +11336,7 @@ impl From<liter_llm::types::FileListQuery> for FileListQuery {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<DeleteResponse> for liter_llm::types::DeleteResponse {
     fn from(val: DeleteResponse) -> Self {
@@ -10529,6 +11344,7 @@ impl From<DeleteResponse> for liter_llm::types::DeleteResponse {
             id: val.id,
             object: val.object,
             deleted: val.deleted,
+            ..Default::default()
         }
     }
 }
@@ -10544,6 +11360,7 @@ impl From<liter_llm::types::DeleteResponse> for DeleteResponse {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<CreateBatchRequest> for liter_llm::types::CreateBatchRequest {
     fn from(val: CreateBatchRequest) -> Self {
@@ -10552,6 +11369,7 @@ impl From<CreateBatchRequest> for liter_llm::types::CreateBatchRequest {
             endpoint: val.endpoint,
             completion_window: val.completion_window,
             metadata: val.metadata.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            ..Default::default()
         }
     }
 }
@@ -10568,6 +11386,7 @@ impl From<liter_llm::types::CreateBatchRequest> for CreateBatchRequest {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<BatchObject> for liter_llm::types::BatchObject {
     fn from(val: BatchObject) -> Self {
@@ -10586,6 +11405,7 @@ impl From<BatchObject> for liter_llm::types::BatchObject {
             expired_at: val.expired_at,
             request_counts: val.request_counts.map(Into::into),
             metadata: val.metadata.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            ..Default::default()
         }
     }
 }
@@ -10612,6 +11432,7 @@ impl From<liter_llm::types::BatchObject> for BatchObject {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<BatchRequestCounts> for liter_llm::types::BatchRequestCounts {
     fn from(val: BatchRequestCounts) -> Self {
@@ -10619,6 +11440,7 @@ impl From<BatchRequestCounts> for liter_llm::types::BatchRequestCounts {
             total: val.total,
             completed: val.completed,
             failed: val.failed,
+            ..Default::default()
         }
     }
 }
@@ -10634,6 +11456,7 @@ impl From<liter_llm::types::BatchRequestCounts> for BatchRequestCounts {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<BatchListResponse> for liter_llm::types::BatchListResponse {
     fn from(val: BatchListResponse) -> Self {
@@ -10643,6 +11466,7 @@ impl From<BatchListResponse> for liter_llm::types::BatchListResponse {
             has_more: val.has_more,
             first_id: val.first_id,
             last_id: val.last_id,
+            ..Default::default()
         }
     }
 }
@@ -10660,12 +11484,14 @@ impl From<liter_llm::types::BatchListResponse> for BatchListResponse {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<BatchListQuery> for liter_llm::types::BatchListQuery {
     fn from(val: BatchListQuery) -> Self {
         Self {
             limit: val.limit,
             after: val.after,
+            ..Default::default()
         }
     }
 }
@@ -10680,6 +11506,7 @@ impl From<liter_llm::types::BatchListQuery> for BatchListQuery {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<CreateResponseRequest> for liter_llm::types::CreateResponseRequest {
     fn from(val: CreateResponseRequest) -> Self {
@@ -10691,6 +11518,7 @@ impl From<CreateResponseRequest> for liter_llm::types::CreateResponseRequest {
             temperature: val.temperature,
             max_output_tokens: val.max_output_tokens,
             metadata: val.metadata.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            ..Default::default()
         }
     }
 }
@@ -10710,12 +11538,14 @@ impl From<liter_llm::types::CreateResponseRequest> for CreateResponseRequest {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ResponseTool> for liter_llm::types::ResponseTool {
     fn from(val: ResponseTool) -> Self {
         Self {
             tool_type: val.tool_type,
             config: serde_json::from_str(&val.config).unwrap_or_default(),
+            ..Default::default()
         }
     }
 }
@@ -10730,6 +11560,7 @@ impl From<liter_llm::types::ResponseTool> for ResponseTool {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ResponseObject> for liter_llm::types::ResponseObject {
     fn from(val: ResponseObject) -> Self {
@@ -10742,6 +11573,7 @@ impl From<ResponseObject> for liter_llm::types::ResponseObject {
             output: val.output.into_iter().map(Into::into).collect(),
             usage: val.usage.map(Into::into),
             error: val.error.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            ..Default::default()
         }
     }
 }
@@ -10762,12 +11594,14 @@ impl From<liter_llm::types::ResponseObject> for ResponseObject {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ResponseOutputItem> for liter_llm::types::ResponseOutputItem {
     fn from(val: ResponseOutputItem) -> Self {
         Self {
             item_type: val.item_type,
             content: serde_json::from_str(&val.content).unwrap_or_default(),
+            ..Default::default()
         }
     }
 }
@@ -10782,6 +11616,7 @@ impl From<liter_llm::types::ResponseOutputItem> for ResponseOutputItem {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ResponseUsage> for liter_llm::types::ResponseUsage {
     fn from(val: ResponseUsage) -> Self {
@@ -10789,6 +11624,7 @@ impl From<ResponseUsage> for liter_llm::types::ResponseUsage {
             input_tokens: val.input_tokens,
             output_tokens: val.output_tokens,
             total_tokens: val.total_tokens,
+            ..Default::default()
         }
     }
 }
@@ -10804,6 +11640,7 @@ impl From<liter_llm::types::ResponseUsage> for ResponseUsage {
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<WaitForBatchConfig> for liter_llm::client::WaitForBatchConfig {
     fn from(val: WaitForBatchConfig) -> Self {
@@ -10812,6 +11649,7 @@ impl From<WaitForBatchConfig> for liter_llm::client::WaitForBatchConfig {
             max_interval_secs: val.max_interval_secs,
             backoff_multiplier: val.backoff_multiplier,
             timeout_secs: val.timeout_secs,
+            ..Default::default()
         }
     }
 }
@@ -10852,6 +11690,7 @@ impl From<liter_llm::provider::custom::CustomProviderConfig> for CustomProviderC
     }
 }
 
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ProviderCapabilities> for liter_llm::provider::ProviderCapabilities {
     fn from(val: ProviderCapabilities) -> Self {
@@ -10863,6 +11702,7 @@ impl From<ProviderCapabilities> for liter_llm::provider::ProviderCapabilities {
             audio_in: val.audio_in,
             audio_out: val.audio_out,
             video_in: val.video_in,
+            ..Default::default()
         }
     }
 }
@@ -10936,6 +11776,97 @@ impl From<liter_llm::provider::AuthConfig> for AuthConfig {
     }
 }
 
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<ModelInfo> for liter_llm::ModelInfo {
+    fn from(val: ModelInfo) -> Self {
+        Self {
+            input_cost_per_token: val.input_cost_per_token,
+            output_cost_per_token: val.output_cost_per_token,
+            cache_read_input_token_cost: val.cache_read_input_token_cost,
+            cache_creation_input_token_cost: val.cache_creation_input_token_cost,
+            input_cost_per_audio_token: val.input_cost_per_audio_token,
+            output_cost_per_audio_token: val.output_cost_per_audio_token,
+            output_cost_per_reasoning_token: val.output_cost_per_reasoning_token,
+            max_tokens: val.max_tokens,
+            max_input_tokens: val.max_input_tokens,
+            max_output_tokens: val.max_output_tokens,
+            mode: val.mode,
+            supports_vision: val.supports_vision,
+            supports_function_calling: val.supports_function_calling,
+            supports_reasoning: val.supports_reasoning,
+            supports_structured_output: val.supports_structured_output,
+            supports_audio_input: val.supports_audio_input,
+            supports_audio_output: val.supports_audio_output,
+            supports_prompt_caching: val.supports_prompt_caching,
+            tiers: val.tiers.into_iter().map(Into::into).collect(),
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::ModelInfo> for ModelInfo {
+    fn from(val: liter_llm::ModelInfo) -> Self {
+        Self {
+            input_cost_per_token: val.input_cost_per_token,
+            output_cost_per_token: val.output_cost_per_token,
+            cache_read_input_token_cost: val.cache_read_input_token_cost,
+            cache_creation_input_token_cost: val.cache_creation_input_token_cost,
+            input_cost_per_audio_token: val.input_cost_per_audio_token,
+            output_cost_per_audio_token: val.output_cost_per_audio_token,
+            output_cost_per_reasoning_token: val.output_cost_per_reasoning_token,
+            max_tokens: val.max_tokens,
+            max_input_tokens: val.max_input_tokens,
+            max_output_tokens: val.max_output_tokens,
+            mode: val.mode.map(|v| v.to_string()),
+            supports_vision: val.supports_vision,
+            supports_function_calling: val.supports_function_calling,
+            supports_reasoning: val.supports_reasoning,
+            supports_structured_output: val.supports_structured_output,
+            supports_audio_input: val.supports_audio_input,
+            supports_audio_output: val.supports_audio_output,
+            supports_prompt_caching: val.supports_prompt_caching,
+            tiers: val.tiers.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<ModelTier> for liter_llm::ModelTier {
+    fn from(val: ModelTier) -> Self {
+        Self {
+            min_context_tokens: val.min_context_tokens,
+            input_cost_per_token: val.input_cost_per_token,
+            output_cost_per_token: val.output_cost_per_token,
+            cache_read_input_token_cost: val.cache_read_input_token_cost,
+            cache_creation_input_token_cost: val.cache_creation_input_token_cost,
+            input_cost_per_audio_token: val.input_cost_per_audio_token,
+            output_cost_per_audio_token: val.output_cost_per_audio_token,
+            output_cost_per_reasoning_token: val.output_cost_per_reasoning_token,
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::ModelTier> for ModelTier {
+    fn from(val: liter_llm::ModelTier) -> Self {
+        Self {
+            min_context_tokens: val.min_context_tokens,
+            input_cost_per_token: val.input_cost_per_token,
+            output_cost_per_token: val.output_cost_per_token,
+            cache_read_input_token_cost: val.cache_read_input_token_cost,
+            cache_creation_input_token_cost: val.cache_creation_input_token_cost,
+            input_cost_per_audio_token: val.input_cost_per_audio_token,
+            output_cost_per_audio_token: val.output_cost_per_audio_token,
+            output_cost_per_reasoning_token: val.output_cost_per_reasoning_token,
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<BudgetConfig> for liter_llm::BudgetConfig {
     fn from(val: BudgetConfig) -> Self {
@@ -10943,6 +11874,7 @@ impl From<BudgetConfig> for liter_llm::BudgetConfig {
             global_limit: val.global_limit,
             model_limits: val.model_limits.into_iter().collect(),
             enforcement: val.enforcement.into(),
+            ..Default::default()
         }
     }
 }
@@ -10958,6 +11890,31 @@ impl From<liter_llm::BudgetConfig> for BudgetConfig {
     }
 }
 
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<CacheConfig> for liter_llm::CacheConfig {
+    fn from(val: CacheConfig) -> Self {
+        Self {
+            max_entries: val.max_entries,
+            ttl: std::time::Duration::from_millis(val.ttl),
+            backend: val.backend.into(),
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::CacheConfig> for CacheConfig {
+    fn from(val: liter_llm::CacheConfig) -> Self {
+        Self {
+            max_entries: val.max_entries,
+            ttl: val.ttl.as_millis() as u64,
+            backend: val.backend.into(),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<RateLimitConfig> for liter_llm::RateLimitConfig {
     fn from(val: RateLimitConfig) -> Self {
@@ -10965,6 +11922,7 @@ impl From<RateLimitConfig> for liter_llm::RateLimitConfig {
             rpm: val.rpm,
             tpm: val.tpm,
             window: std::time::Duration::from_millis(val.window),
+            ..Default::default()
         }
     }
 }
@@ -10991,6 +11949,32 @@ impl From<liter_llm::tower::IntentPrototype> for IntentPrototype {
     }
 }
 
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<CatalogRefreshConfig> for liter_llm::cost::refresh::CatalogRefreshConfig {
+    fn from(val: CatalogRefreshConfig) -> Self {
+        Self {
+            enabled: val.enabled,
+            source_url: val.source_url,
+            ttl_seconds: val.ttl_seconds,
+            cache_path: val.cache_path,
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::cost::refresh::CatalogRefreshConfig> for CatalogRefreshConfig {
+    fn from(val: liter_llm::cost::refresh::CatalogRefreshConfig) -> Self {
+        Self {
+            enabled: val.enabled,
+            source_url: val.source_url.to_string(),
+            ttl_seconds: val.ttl_seconds,
+            cache_path: val.cache_path.map(|v| v.to_string()),
+        }
+    }
+}
+
 impl From<Message> for liter_llm::types::Message {
     fn from(val: Message) -> Self {
         match val {
@@ -11514,6 +12498,30 @@ impl From<liter_llm::Enforcement> for Enforcement {
     }
 }
 
+impl From<CacheBackend> for liter_llm::CacheBackend {
+    fn from(val: CacheBackend) -> Self {
+        match val {
+            CacheBackend::Memory => Self::Memory,
+            CacheBackend::OpenDal { scheme, config } => Self::OpenDal {
+                scheme: scheme,
+                config: serde_json::from_str(&config).unwrap_or_default(),
+            },
+        }
+    }
+}
+
+impl From<liter_llm::CacheBackend> for CacheBackend {
+    fn from(val: liter_llm::CacheBackend) -> Self {
+        match val {
+            liter_llm::CacheBackend::Memory => Self::Memory,
+            liter_llm::CacheBackend::OpenDal { scheme, config } => Self::OpenDal {
+                scheme: scheme.to_string(),
+                config: serde_json::to_string(&config).unwrap_or_default(),
+            },
+        }
+    }
+}
+
 impl From<liter_llm::tower::CircuitState> for CircuitState {
     fn from(val: liter_llm::tower::CircuitState) -> Self {
         match val {
@@ -11533,6 +12541,26 @@ impl From<liter_llm::tower::HealthStatus> for HealthStatus {
     }
 }
 
+impl From<RefreshOutcome> for liter_llm::cost::refresh::RefreshOutcome {
+    fn from(val: RefreshOutcome) -> Self {
+        match val {
+            RefreshOutcome::Disabled => Self::Disabled,
+            RefreshOutcome::FromCache => Self::FromCache,
+            RefreshOutcome::Fetched => Self::Fetched,
+        }
+    }
+}
+
+impl From<liter_llm::cost::refresh::RefreshOutcome> for RefreshOutcome {
+    fn from(val: liter_llm::cost::refresh::RefreshOutcome) -> Self {
+        match val {
+            liter_llm::cost::refresh::RefreshOutcome::Disabled => Self::Disabled,
+            liter_llm::cost::refresh::RefreshOutcome::FromCache => Self::FromCache,
+            liter_llm::cost::refresh::RefreshOutcome::Fetched => Self::Fetched,
+        }
+    }
+}
+
 /// Convert a `liter_llm::error::LiterLlmError` error to a Magnus runtime error.
 #[allow(dead_code)]
 fn liter_llm_error_to_magnus_err(e: liter_llm::error::LiterLlmError) -> magnus::Error {
@@ -11573,6 +12601,13 @@ impl LiterLlmErrorInfo {
     }
 }
 
+/// Convert a `liter_llm::cost::refresh::CatalogRefreshError` error to a Magnus runtime error.
+#[allow(dead_code)]
+fn catalog_refresh_error_to_magnus_err(e: liter_llm::cost::refresh::CatalogRefreshError) -> magnus::Error {
+    let msg = e.to_string();
+    magnus::Error::new(unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(), msg)
+}
+
 #[derive(Clone)]
 #[magnus::wrap(class = "LiterLlm::ChatStreamIterator")]
 pub struct ChatStreamIterator {
@@ -11719,10 +12754,14 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("function_call", method!(AssistantMessage::function_call, 0))?;
 
+    class.define_method("reasoning_content", method!(AssistantMessage::reasoning_content, 0))?;
+
     class.define_method("text", method!(AssistantMessage::text, 0))?;
 
     class.define_method("refusal_text", method!(AssistantMessage::refusal_text, 0))?;
 
+    class.define_method("reasoning_text", method!(AssistantMessage::reasoning_text, 0))?;
+
     class.define_method("output_images", method!(AssistantMessage::output_images, 0))?;
 
     class.define_method("output_audio", method!(AssistantMessage::output_audio, 0))?;
@@ -11981,6 +13020,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("refusal", method!(StreamDelta::refusal, 0))?;
 
+    class.define_method("reasoning_content", method!(StreamDelta::reasoning_content, 0))?;
+
     class.define_method("to_s", method!(StreamDelta::to_s, 0))?;
 
     let class = module.define_class("StreamToolCall", ruby.class_object())?;
@@ -12723,6 +13764,107 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("env_var", method!(AuthConfig::env_var, 0))?;
 
+    let class = module.define_class("ModelInfo", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(ModelInfo::new, -1))?;
+
+    class.define_method("input_cost_per_token", method!(ModelInfo::input_cost_per_token, 0))?;
+
+    class.define_method("output_cost_per_token", method!(ModelInfo::output_cost_per_token, 0))?;
+
+    class.define_method(
+        "cache_read_input_token_cost",
+        method!(ModelInfo::cache_read_input_token_cost, 0),
+    )?;
+
+    class.define_method(
+        "cache_creation_input_token_cost",
+        method!(ModelInfo::cache_creation_input_token_cost, 0),
+    )?;
+
+    class.define_method(
+        "input_cost_per_audio_token",
+        method!(ModelInfo::input_cost_per_audio_token, 0),
+    )?;
+
+    class.define_method(
+        "output_cost_per_audio_token",
+        method!(ModelInfo::output_cost_per_audio_token, 0),
+    )?;
+
+    class.define_method(
+        "output_cost_per_reasoning_token",
+        method!(ModelInfo::output_cost_per_reasoning_token, 0),
+    )?;
+
+    class.define_method("max_tokens", method!(ModelInfo::max_tokens, 0))?;
+
+    class.define_method("max_input_tokens", method!(ModelInfo::max_input_tokens, 0))?;
+
+    class.define_method("max_output_tokens", method!(ModelInfo::max_output_tokens, 0))?;
+
+    class.define_method("mode", method!(ModelInfo::mode, 0))?;
+
+    class.define_method("supports_vision", method!(ModelInfo::supports_vision, 0))?;
+
+    class.define_method(
+        "supports_function_calling",
+        method!(ModelInfo::supports_function_calling, 0),
+    )?;
+
+    class.define_method("supports_reasoning", method!(ModelInfo::supports_reasoning, 0))?;
+
+    class.define_method(
+        "supports_structured_output",
+        method!(ModelInfo::supports_structured_output, 0),
+    )?;
+
+    class.define_method("supports_audio_input", method!(ModelInfo::supports_audio_input, 0))?;
+
+    class.define_method("supports_audio_output", method!(ModelInfo::supports_audio_output, 0))?;
+
+    class.define_method(
+        "supports_prompt_caching",
+        method!(ModelInfo::supports_prompt_caching, 0),
+    )?;
+
+    class.define_method("tiers", method!(ModelInfo::tiers, 0))?;
+
+    let class = module.define_class("ModelTier", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(ModelTier::new, -1))?;
+
+    class.define_method("min_context_tokens", method!(ModelTier::min_context_tokens, 0))?;
+
+    class.define_method("input_cost_per_token", method!(ModelTier::input_cost_per_token, 0))?;
+
+    class.define_method("output_cost_per_token", method!(ModelTier::output_cost_per_token, 0))?;
+
+    class.define_method(
+        "cache_read_input_token_cost",
+        method!(ModelTier::cache_read_input_token_cost, 0),
+    )?;
+
+    class.define_method(
+        "cache_creation_input_token_cost",
+        method!(ModelTier::cache_creation_input_token_cost, 0),
+    )?;
+
+    class.define_method(
+        "input_cost_per_audio_token",
+        method!(ModelTier::input_cost_per_audio_token, 0),
+    )?;
+
+    class.define_method(
+        "output_cost_per_audio_token",
+        method!(ModelTier::output_cost_per_audio_token, 0),
+    )?;
+
+    class.define_method(
+        "output_cost_per_reasoning_token",
+        method!(ModelTier::output_cost_per_reasoning_token, 0),
+    )?;
+
     let class = module.define_class("BudgetConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(BudgetConfig::new, -1))?;
@@ -12733,6 +13875,16 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("enforcement", method!(BudgetConfig::enforcement, 0))?;
 
+    let class = module.define_class("CacheConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(CacheConfig::new, -1))?;
+
+    class.define_method("max_entries", method!(CacheConfig::max_entries, 0))?;
+
+    class.define_method("ttl", method!(CacheConfig::ttl, 0))?;
+
+    class.define_method("backend", method!(CacheConfig::backend, 0))?;
+
     let class = module.define_class("SingleflightResult", ruby.class_object())?;
 
     let class = module.define_class("RateLimitConfig", ruby.class_object())?;
@@ -12755,6 +13907,18 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("model", method!(IntentPrototype::model, 0))?;
 
+    let class = module.define_class("CatalogRefreshConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(CatalogRefreshConfig::new, -1))?;
+
+    class.define_method("enabled", method!(CatalogRefreshConfig::enabled, 0))?;
+
+    class.define_method("source_url", method!(CatalogRefreshConfig::source_url, 0))?;
+
+    class.define_method("ttl_seconds", method!(CatalogRefreshConfig::ttl_seconds, 0))?;
+
+    class.define_method("cache_path", method!(CatalogRefreshConfig::cache_path, 0))?;
+
     let class = module.define_class("RerankDocument", ruby.class_object())?;
 
     class.define_singleton_method("object", function!(RerankDocument::_factory_object, 1))?;
@@ -12786,6 +13950,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("completion_cost_with_cache", function!(completion_cost_with_cache, 4))?;
 
+    module.define_module_function("model_info", function!(model_info, 1))?;
+
     module.define_module_function("clear", function!(clear, 0))?;
 
     module.define_module_function("count_tokens", function!(count_tokens, 2))?;
@@ -12796,6 +13962,15 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("ensure_crypto_provider", function!(ensure_crypto_provider, 0))?;
 
+    module.define_module_function(
+        "install_catalog_overlay_from_str",
+        function!(install_catalog_overlay_from_str, 1),
+    )?;
+
+    module.define_module_function("clear_catalog_overlay", function!(clear_catalog_overlay, 0))?;
+
+    module.define_module_function("refresh_catalog", function!(refresh_catalog_async, -1))?;
+
     module.define_module_function("chat_stream", function!(chat_stream, 2))?;
 
     let liter_llm_error_info_class = module.define_class("LiterLlmErrorInfo", ruby.class_object())?;