liter_llm 2.1.4 → 2.2.3

data/ext/liter_llm_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:0298ffd63d1edf1d3ee3e4b3928b7608944a5687feff10faee95958dce861a54
+// alef:hash:3861ed195f3c3e52018feb23f8f7da4fefbc958be2e63235f137618ed6fec98a
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -1404,6 +1404,141 @@ impl CacheConfig {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::CatalogInfo")]
+pub struct CatalogInfo {
+    source: String,
+    source_sha256: String,
+    fetched: String,
+    library_version: String,
+    schema_version: u64,
+    origin: String,
+}
+
+unsafe impl IntoValueFromNative for CatalogInfo {}
+
+impl magnus::TryConvert for CatalogInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&CatalogInfo 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 CatalogInfo: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<CatalogInfo>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize CatalogInfo: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for CatalogInfo {}
+
+impl Default for CatalogInfo {
+    fn default() -> Self {
+        liter_llm::CatalogInfo::default().into()
+    }
+}
+
+impl CatalogInfo {
+    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 {
+            source: match kwargs.get(ruby.to_symbol("source")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `source`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            source_sha256: match kwargs.get(ruby.to_symbol("source_sha256")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `source_sha256`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            fetched: match kwargs.get(ruby.to_symbol("fetched")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `fetched`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            library_version: match kwargs.get(ruby.to_symbol("library_version")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `library_version`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            schema_version: match kwargs.get(ruby.to_symbol("schema_version")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `schema_version`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            origin: match kwargs.get(ruby.to_symbol("origin")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `origin`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+        })
+    }
+
+    fn source(&self) -> String {
+        self.source.clone()
+    }
+
+    fn source_sha256(&self) -> String {
+        self.source_sha256.clone()
+    }
+
+    fn fetched(&self) -> String {
+        self.fetched.clone()
+    }
+
+    fn library_version(&self) -> String {
+        self.library_version.clone()
+    }
+
+    fn schema_version(&self) -> u64 {
+        self.schema_version
+    }
+
+    fn origin(&self) -> String {
+        self.origin.clone()
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::CatalogRefreshConfig")]
@@ -2538,6 +2673,220 @@ impl Choice {
     }
 }
 
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::ClientOptions")]
+pub struct ClientOptions {
+    api_key: String,
+    base_url: Option<String>,
+    timeout_secs: Option<u64>,
+    max_retries: Option<u32>,
+    max_response_bytes: Option<u64>,
+    model_hint: Option<String>,
+}
+
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+unsafe impl IntoValueFromNative for ClientOptions {}
+
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+impl magnus::TryConvert for ClientOptions {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ClientOptions 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 ClientOptions: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ClientOptions>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ClientOptions: {}", e),
+            )
+        })
+    }
+}
+
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+unsafe impl TryConvertOwned for ClientOptions {}
+
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+impl Default for ClientOptions {
+    fn default() -> Self {
+        liter_llm::ClientOptions::default().into()
+    }
+}
+
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+impl ClientOptions {
+    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 {
+            api_key: match kwargs.get(ruby.to_symbol("api_key")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `api_key`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            base_url: match kwargs.get(ruby.to_symbol("base_url")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `base_url`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            timeout_secs: match kwargs.get(ruby.to_symbol("timeout_secs")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `timeout_secs`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            max_retries: match kwargs.get(ruby.to_symbol("max_retries")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_retries`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            max_response_bytes: match kwargs.get(ruby.to_symbol("max_response_bytes")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_response_bytes`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            model_hint: match kwargs.get(ruby.to_symbol("model_hint")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `model_hint`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+        })
+    }
+
+    fn api_key(&self) -> String {
+        self.api_key.clone()
+    }
+
+    fn base_url(&self) -> Option<String> {
+        self.base_url.clone()
+    }
+
+    fn timeout_secs(&self) -> Option<u64> {
+        self.timeout_secs
+    }
+
+    fn max_retries(&self) -> Option<u32> {
+        self.max_retries
+    }
+
+    fn max_response_bytes(&self) -> Option<u64> {
+        self.max_response_bytes
+    }
+
+    fn model_hint(&self) -> Option<String> {
+        self.model_hint.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::CompletionTokensDetails")]
+pub struct CompletionTokensDetails {
+    reasoning_tokens: u64,
+}
+
+unsafe impl IntoValueFromNative for CompletionTokensDetails {}
+
+impl magnus::TryConvert for CompletionTokensDetails {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&CompletionTokensDetails 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 CompletionTokensDetails: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<CompletionTokensDetails>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize CompletionTokensDetails: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for CompletionTokensDetails {}
+impl<'de> serde::Deserialize<'de> for CompletionTokensDetails {
+    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <liter_llm::types::CompletionTokensDetails as serde::Deserialize>::deserialize(deserializer).map(Into::into)
+    }
+}
+
+impl Default for CompletionTokensDetails {
+    fn default() -> Self {
+        liter_llm::types::CompletionTokensDetails::default().into()
+    }
+}
+
+impl CompletionTokensDetails {
+    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 {
+            reasoning_tokens: match kwargs.get(ruby.to_symbol("reasoning_tokens")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `reasoning_tokens`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+        })
+    }
+
+    fn reasoning_tokens(&self) -> u64 {
+        self.reasoning_tokens
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize)]
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::CreateBatchRequest")]
@@ -6913,6 +7262,9 @@ impl LlmRateLimitConfig {
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::ModelInfo")]
 pub struct ModelInfo {
+    matched_key: String,
+    exact: bool,
+    price_known: bool,
     input_cost_per_token: f64,
     output_cost_per_token: f64,
     cache_read_input_token_cost: Option<f64>,
@@ -6975,6 +7327,33 @@ impl ModelInfo {
         let (kwargs_opt,) = args.optional;
         let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
         Ok(Self {
+            matched_key: match kwargs.get(ruby.to_symbol("matched_key")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `matched_key`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            exact: match kwargs.get(ruby.to_symbol("exact")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `exact`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            price_known: match kwargs.get(ruby.to_symbol("price_known")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `price_known`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
             input_cost_per_token: match kwargs.get(ruby.to_symbol("input_cost_per_token")) {
                 Some(v) => f64::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -7179,6 +7558,18 @@ impl ModelInfo {
         })
     }
 
+    fn matched_key(&self) -> String {
+        self.matched_key.clone()
+    }
+
+    fn exact(&self) -> bool {
+        self.exact
+    }
+
+    fn price_known(&self) -> bool {
+        self.price_known
+    }
+
     fn input_cost_per_token(&self) -> f64 {
         self.input_cost_per_token
     }
@@ -8862,6 +9253,7 @@ impl PageDimensions {
 #[magnus::wrap(class = "LiterLlm::PromptTokensDetails")]
 pub struct PromptTokensDetails {
     cached_tokens: u64,
+    cache_creation_tokens: u64,
     audio_tokens: u64,
 }
 
@@ -8923,6 +9315,15 @@ impl PromptTokensDetails {
                 })?,
                 None => Default::default(),
             },
+            cache_creation_tokens: match kwargs.get(ruby.to_symbol("cache_creation_tokens")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `cache_creation_tokens`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
             audio_tokens: match kwargs.get(ruby.to_symbol("audio_tokens")) {
                 Some(v) => u64::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -8939,6 +9340,10 @@ impl PromptTokensDetails {
         self.cached_tokens
     }
 
+    fn cache_creation_tokens(&self) -> u64 {
+        self.cache_creation_tokens
+    }
+
     fn audio_tokens(&self) -> u64 {
         self.audio_tokens
     }
@@ -11703,6 +12108,7 @@ pub struct Usage {
     completion_tokens: u64,
     total_tokens: u64,
     prompt_tokens_details: Option<PromptTokensDetails>,
+    completion_tokens_details: Option<CompletionTokensDetails>,
 }
 
 unsafe impl IntoValueFromNative for Usage {}
@@ -11793,6 +12199,18 @@ impl Usage {
                 })?),
                 None => None,
             },
+            completion_tokens_details: match kwargs
+                .get(ruby.to_symbol("completion_tokens_details"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(CompletionTokensDetails::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `completion_tokens_details`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -11811,6 +12229,10 @@ impl Usage {
     fn prompt_tokens_details(&self) -> Option<PromptTokensDetails> {
         self.prompt_tokens_details.clone()
     }
+
+    fn completion_tokens_details(&self) -> Option<CompletionTokensDetails> {
+        self.completion_tokens_details.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -13773,6 +14195,10 @@ fn capabilities(provider_name: String) -> ProviderCapabilities {
     liter_llm::provider::capabilities(&provider_name).into()
 }
 
+fn catalog_info() -> Option<CatalogInfo> {
+    liter_llm::catalog_info().map(Into::into)
+}
+
 fn check_bound(context: String, current_len: usize, incoming: usize, limit: usize) -> Result<(), Error> {
     let result = liter_llm::util::bounds::check_bound(&context, current_len, incoming, limit).map_err(|e| {
         magnus::Error::new(
@@ -13804,6 +14230,22 @@ fn completion_cost_with_cache(
     liter_llm::completion_cost_with_cache(&model, prompt_tokens, cached_tokens, completion_tokens)
 }
 
+fn completion_cost_with_cache_details(
+    model: String,
+    prompt_tokens: u64,
+    cached_tokens: u64,
+    cache_creation_tokens: u64,
+    completion_tokens: u64,
+) -> Option<f64> {
+    liter_llm::completion_cost_with_cache_details(
+        &model,
+        prompt_tokens,
+        cached_tokens,
+        cache_creation_tokens,
+        completion_tokens,
+    )
+}
+
 fn complex_provider_names() -> Result<Vec<String>, Error> {
     let result = liter_llm::provider::complex_provider_names().map_err(|e| {
         magnus::Error::new(
@@ -13907,6 +14349,31 @@ fn create_client_from_json(json: String) -> Result<DefaultClient, Error> {
     })
 }
 
+#[cfg(feature = "native-http")]
+fn create_client_with_options(args: &[magnus::Value]) -> Result<DefaultClient, Error> {
+    let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (options,) = args.optional;
+
+    let options: liter_llm::ClientOptions = match options {
+        Some(_v) if !_v.is_nil() => {
+            let binding_val: ClientOptions = ClientOptions::try_convert(_v).map_err(|e| {
+                magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string())
+            })?;
+            binding_val.into()
+        }
+        _ => Default::default(),
+    };
+    let result = liter_llm::create_client_with_options(options.into()).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(DefaultClient {
+        inner: Arc::new(result),
+    })
+}
+
 fn decode_data_url(url: String) -> Option<DecodedDataUrl> {
     liter_llm::image::decode_data_url(&url).map(Into::into)
 }
@@ -13936,6 +14403,10 @@ fn ensure_crypto_provider() -> () {
     liter_llm::ensure_crypto_provider()
 }
 
+fn exact_model_info(model: String) -> Option<ModelInfo> {
+    liter_llm::exact_model_info(&model).map(Into::into)
+}
+
 fn install_catalog_overlay_from_str(catalog_json: String) -> Result<(), Error> {
     let result = liter_llm::install_catalog_overlay_from_str(&catalog_json).map_err(|e| {
         magnus::Error::new(
@@ -14308,6 +14779,34 @@ impl From<liter_llm::CacheConfig> for CacheConfig {
     }
 }
 
+#[allow(clippy::needless_update)]
+impl From<CatalogInfo> for liter_llm::CatalogInfo {
+    fn from(val: CatalogInfo) -> Self {
+        Self {
+            source: val.source,
+            source_sha256: val.source_sha256,
+            fetched: val.fetched,
+            library_version: val.library_version,
+            schema_version: val.schema_version,
+            origin: val.origin,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<liter_llm::CatalogInfo> for CatalogInfo {
+    fn from(val: liter_llm::CatalogInfo) -> Self {
+        Self {
+            source: val.source.to_string(),
+            source_sha256: val.source_sha256.to_string(),
+            fetched: val.fetched.to_string(),
+            library_version: val.library_version.to_string(),
+            schema_version: val.schema_version,
+            origin: val.origin.to_string(),
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 impl From<CatalogRefreshConfig> for liter_llm::CatalogRefreshConfig {
     fn from(val: CatalogRefreshConfig) -> Self {
@@ -14532,6 +15031,55 @@ impl From<liter_llm::types::Choice> for Choice {
     }
 }
 
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+#[allow(clippy::needless_update)]
+impl From<ClientOptions> for liter_llm::ClientOptions {
+    fn from(val: ClientOptions) -> Self {
+        Self {
+            api_key: val.api_key,
+            base_url: val.base_url,
+            timeout_secs: val.timeout_secs,
+            max_retries: val.max_retries,
+            max_response_bytes: val.max_response_bytes,
+            model_hint: val.model_hint,
+            ..Default::default()
+        }
+    }
+}
+
+#[cfg(any(feature = "native-http", feature = "wasm-http"))]
+#[allow(clippy::redundant_closure)]
+impl From<liter_llm::ClientOptions> for ClientOptions {
+    fn from(val: liter_llm::ClientOptions) -> Self {
+        Self {
+            api_key: val.api_key.to_string(),
+            base_url: val.base_url.map(|v| v.to_string()),
+            timeout_secs: val.timeout_secs,
+            max_retries: val.max_retries,
+            max_response_bytes: val.max_response_bytes,
+            model_hint: val.model_hint.map(|v| v.to_string()),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+impl From<CompletionTokensDetails> for liter_llm::types::CompletionTokensDetails {
+    fn from(val: CompletionTokensDetails) -> Self {
+        Self {
+            reasoning_tokens: val.reasoning_tokens,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<liter_llm::types::CompletionTokensDetails> for CompletionTokensDetails {
+    fn from(val: liter_llm::types::CompletionTokensDetails) -> Self {
+        Self {
+            reasoning_tokens: val.reasoning_tokens,
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure)]
 impl From<CreateBatchRequest> for liter_llm::types::CreateBatchRequest {
@@ -15292,6 +15840,9 @@ impl From<liter_llm::client::LlmRateLimitConfig> for LlmRateLimitConfig {
 impl From<ModelInfo> for liter_llm::ModelInfo {
     fn from(val: ModelInfo) -> Self {
         Self {
+            matched_key: val.matched_key,
+            exact: val.exact,
+            price_known: val.price_known,
             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,
@@ -15320,6 +15871,9 @@ impl From<ModelInfo> for liter_llm::ModelInfo {
 impl From<liter_llm::ModelInfo> for ModelInfo {
     fn from(val: liter_llm::ModelInfo) -> Self {
         Self {
+            matched_key: val.matched_key.to_string(),
+            exact: val.exact,
+            price_known: val.price_known,
             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,
@@ -15677,6 +16231,7 @@ impl From<PromptTokensDetails> for liter_llm::types::PromptTokensDetails {
     fn from(val: PromptTokensDetails) -> Self {
         Self {
             cached_tokens: val.cached_tokens,
+            cache_creation_tokens: val.cache_creation_tokens,
             audio_tokens: val.audio_tokens,
             ..Default::default()
         }
@@ -15687,6 +16242,7 @@ impl From<liter_llm::types::PromptTokensDetails> for PromptTokensDetails {
     fn from(val: liter_llm::types::PromptTokensDetails) -> Self {
         Self {
             cached_tokens: val.cached_tokens,
+            cache_creation_tokens: val.cache_creation_tokens,
             audio_tokens: val.audio_tokens,
         }
     }
@@ -16319,6 +16875,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),
+            completion_tokens_details: val.completion_tokens_details.map(Into::into),
             ..Default::default()
         }
     }
@@ -16332,6 +16889,7 @@ impl From<liter_llm::types::Usage> for Usage {
             completion_tokens: val.completion_tokens,
             total_tokens: val.total_tokens,
             prompt_tokens_details: val.prompt_tokens_details.map(Into::into),
+            completion_tokens_details: val.completion_tokens_details.map(Into::into),
         }
     }
 }
@@ -17313,6 +17871,22 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     #[cfg(feature = "tower")]
     class.define_method("backend", method!(CacheConfig::backend, 0))?;
 
+    let class = module.define_class("CatalogInfo", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(CatalogInfo::new, -1))?;
+
+    class.define_method("source", method!(CatalogInfo::source, 0))?;
+
+    class.define_method("source_sha256", method!(CatalogInfo::source_sha256, 0))?;
+
+    class.define_method("fetched", method!(CatalogInfo::fetched, 0))?;
+
+    class.define_method("library_version", method!(CatalogInfo::library_version, 0))?;
+
+    class.define_method("schema_version", method!(CatalogInfo::schema_version, 0))?;
+
+    class.define_method("origin", method!(CatalogInfo::origin, 0))?;
+
     let class = module.define_class("CatalogRefreshConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(CatalogRefreshConfig::new, -1))?;
@@ -17467,6 +18041,38 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("logprobs", method!(Choice::logprobs, 0))?;
 
+    let class = module.define_class("ClientOptions", ruby.class_object())?;
+
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_singleton_method("new", function!(ClientOptions::new, -1))?;
+
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_method("api_key", method!(ClientOptions::api_key, 0))?;
+
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_method("base_url", method!(ClientOptions::base_url, 0))?;
+
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_method("timeout_secs", method!(ClientOptions::timeout_secs, 0))?;
+
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_method("max_retries", method!(ClientOptions::max_retries, 0))?;
+
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_method("max_response_bytes", method!(ClientOptions::max_response_bytes, 0))?;
+
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_method("model_hint", method!(ClientOptions::model_hint, 0))?;
+
+    let class = module.define_class("CompletionTokensDetails", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(CompletionTokensDetails::new, -1))?;
+
+    class.define_method(
+        "reasoning_tokens",
+        method!(CompletionTokensDetails::reasoning_tokens, 0),
+    )?;
+
     let class = module.define_class("CreateBatchRequest", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(CreateBatchRequest::new, -1))?;
@@ -17963,6 +18569,12 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_singleton_method("new", function!(ModelInfo::new, -1))?;
 
+    class.define_method("matched_key", method!(ModelInfo::matched_key, 0))?;
+
+    class.define_method("exact", method!(ModelInfo::exact, 0))?;
+
+    class.define_method("price_known", method!(ModelInfo::price_known, 0))?;
+
     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))?;
@@ -18237,6 +18849,11 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("cached_tokens", method!(PromptTokensDetails::cached_tokens, 0))?;
 
+    class.define_method(
+        "cache_creation_tokens",
+        method!(PromptTokensDetails::cache_creation_tokens, 0),
+    )?;
+
     class.define_method("audio_tokens", method!(PromptTokensDetails::audio_tokens, 0))?;
 
     let class = module.define_class("ProviderCapabilities", ruby.class_object())?;
@@ -18543,6 +19160,11 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("prompt_tokens_details", method!(Usage::prompt_tokens_details, 0))?;
 
+    class.define_method(
+        "completion_tokens_details",
+        method!(Usage::completion_tokens_details, 0),
+    )?;
+
     let class = module.define_class("UserMessage", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(UserMessage::new, -1))?;
@@ -18590,6 +19212,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("capabilities", function!(capabilities, 1))?;
 
+    module.define_module_function("catalog_info", function!(catalog_info, 0))?;
+
     module.define_module_function("check_bound", function!(check_bound, 4))?;
 
     module.define_module_function("clear", function!(clear, 0))?;
@@ -18600,6 +19224,11 @@ 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(
+        "completion_cost_with_cache_details",
+        function!(completion_cost_with_cache_details, 5),
+    )?;
+
     module.define_module_function("complex_provider_names", function!(complex_provider_names, 0))?;
 
     #[cfg(feature = "tokenizer")]
@@ -18614,6 +19243,9 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     #[cfg(any(feature = "native-http", feature = "wasm-http"))]
     module.define_module_function("create_client_from_json", function!(create_client_from_json, 1))?;
 
+    #[cfg(feature = "native-http")]
+    module.define_module_function("create_client_with_options", function!(create_client_with_options, -1))?;
+
     module.define_module_function("decode_data_url", function!(decode_data_url, 1))?;
 
     module.define_module_function("encode_data_url", function!(encode_data_url, -1))?;
@@ -18624,6 +19256,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     ))]
     module.define_module_function("ensure_crypto_provider", function!(ensure_crypto_provider, 0))?;
 
+    module.define_module_function("exact_model_info", function!(exact_model_info, 1))?;
+
     module.define_module_function(
         "install_catalog_overlay_from_str",
         function!(install_catalog_overlay_from_str, 1),