liter_llm 1.15.0 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 169a7dafd34a10e8f397f0a13c551203581c4839c7475bbcda809a407e1723fb
-  data.tar.gz: 8719bd61e9c8b81a7b2b10affc7f0a212159af272f0e51c56181e70e5d79da10
+  metadata.gz: 583c166965b777229367242f38ad821d1342f0fcd49327c33c436252bde4d3d3
+  data.tar.gz: bb2286dcf26095bd41dd72f2bf1622554af0c3306b389aab386999366291a76a
 SHA512:
-  metadata.gz: 513aa143123637b15cd80d329df6b5cb8964a3f644f78bf1cde2bdf9fcdb8e8a90820b0f50bf3afed07f43db8ba6f59404301336837044f2d4eabbe40f8fce54
-  data.tar.gz: 5874cf2e4d9c8d8f8dc6f9ea5786f9d68054ed9d91a87ca24930008dbd35bf15d03171bf380219b0309506f4230984fc0fb07a7c303d6889c72ed36404a1dc9f
+  metadata.gz: 6372e35d3c8bd6887310037de0e0ad3727af77696f2d5f547dd83f6323b2be6e9bd887cbaab6fb4f77d63849b7ad81a85a10a179e7e999985c765cf6372ff266
+  data.tar.gz: 5427806e8ae63d9104cab65932168403aaa0a27c344184b3d950a87271c03cefa3587a0b0080580557bed113f7515664777cc2666d1496be7b1f61b7be930099

data/ext/liter_llm_rb/native/Cargo.lock

@@ -1783,9 +1783,9 @@ checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
 
 [[package]]
 name = "liter-llm"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce85d28b7c57ec856b8a13197eaf7f0904fdd6434876143b64bd706182a31225"
+checksum = "9c5ed2a6c80abf59ecef2990a20369c171349160738a652a50c26b9c202a81d7"
 dependencies = [
  "ahash 0.8.12",
  "arc-swap",
@@ -1826,7 +1826,7 @@ dependencies = [
 
 [[package]]
 name = "liter-llm-rb"
-version = "1.15.0"
+version = "1.16.0"
 dependencies = [
  "futures",
  "liter-llm",

data/ext/liter_llm_rb/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "liter-llm-rb"
-version = "1.15.0"
+version = "1.16.0"
 edition = "2024"
 license = "MIT"
 description = "Universal LLM API client with Rust-powered polyglot bindings."
@@ -24,7 +24,7 @@ wasm-http = ["liter-llm/wasm-http"]
 
 [dependencies]
 futures = "0.3"
-liter-llm = { version = "1.15.0", features = ["native-http", "full"] }
+liter-llm = { version = "1.16.0", features = ["native-http", "full"] }
 magnus = "0.8"
 rb-sys = ">=0.9, <0.9.128"
 serde = { version = "1", features = ["derive"] }

data/ext/liter_llm_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:a1989c3dfb77377970d88272370ba76653a7c87963705fabadca288653ab7055
+// alef:hash:938b8ffd93c3e30d74875f875188c728addee9d4b80a97a7ac22716b3154c7c5
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -609,7 +609,7 @@ impl AssistantMessage {
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::ToolMessage")]
 pub struct ToolMessage {
-    content: String,
+    content: UserContent,
     tool_call_id: String,
     name: Option<String>,
 }
@@ -657,7 +657,7 @@ impl ToolMessage {
         Ok(Self {
             content: kwargs
                 .get(ruby.to_symbol("content"))
-                .and_then(|v| String::try_convert(v).ok())
+                .and_then(|v| UserContent::try_convert(v).ok())
                 .unwrap_or_default(),
             tool_call_id: kwargs
                 .get(ruby.to_symbol("tool_call_id"))
@@ -669,7 +669,7 @@ impl ToolMessage {
         })
     }
 
-    fn content(&self) -> String {
+    fn content(&self) -> UserContent {
         self.content.clone()
     }
 
@@ -680,11 +680,6 @@ impl ToolMessage {
     fn name(&self) -> Option<String> {
         self.name.clone()
     }
-
-    #[allow(clippy::should_implement_trait)]
-    fn to_s(&self) -> String {
-        self.content.clone()
-    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -6201,32 +6196,606 @@ impl ResponseObject {
         self.status.clone()
     }
 
-    fn output(&self) -> Vec<ResponseOutputItem> {
-        self.output.clone()
+    fn output(&self) -> Vec<ResponseOutputItem> {
+        self.output.clone()
+    }
+
+    fn usage(&self) -> Option<ResponseUsage> {
+        self.usage.clone()
+    }
+
+    fn error(&self) -> Option<String> {
+        self.error.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::ResponseOutputItem")]
+pub struct ResponseOutputItem {
+    item_type: String,
+    content: String,
+}
+
+unsafe impl IntoValueFromNative for ResponseOutputItem {}
+
+impl magnus::TryConvert for ResponseOutputItem {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ResponseOutputItem 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 ResponseOutputItem: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ResponseOutputItem>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ResponseOutputItem: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ResponseOutputItem {}
+
+impl Default for ResponseOutputItem {
+    fn default() -> Self {
+        liter_llm::types::ResponseOutputItem::default().into()
+    }
+}
+
+impl ResponseOutputItem {
+    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 {
+            item_type: kwargs
+                .get(ruby.to_symbol("item_type"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            content: kwargs
+                .get(ruby.to_symbol("content"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn item_type(&self) -> String {
+        self.item_type.clone()
+    }
+
+    fn content(&self) -> String {
+        self.content.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::ResponseUsage")]
+pub struct ResponseUsage {
+    input_tokens: u64,
+    output_tokens: u64,
+    total_tokens: u64,
+}
+
+unsafe impl IntoValueFromNative for ResponseUsage {}
+
+impl magnus::TryConvert for ResponseUsage {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ResponseUsage 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 ResponseUsage: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ResponseUsage>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ResponseUsage: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ResponseUsage {}
+
+impl Default for ResponseUsage {
+    fn default() -> Self {
+        liter_llm::types::ResponseUsage::default().into()
+    }
+}
+
+impl ResponseUsage {
+    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_tokens: kwargs
+                .get(ruby.to_symbol("input_tokens"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or_default(),
+            output_tokens: kwargs
+                .get(ruby.to_symbol("output_tokens"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or_default(),
+            total_tokens: kwargs
+                .get(ruby.to_symbol("total_tokens"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn input_tokens(&self) -> u64 {
+        self.input_tokens
+    }
+
+    fn output_tokens(&self) -> u64 {
+        self.output_tokens
+    }
+
+    fn total_tokens(&self) -> u64 {
+        self.total_tokens
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::LlmConfig")]
+pub struct LlmConfig {
+    model: String,
+    api_key: Option<String>,
+    base_url: Option<String>,
+    timeout_secs: Option<u64>,
+    max_retries: Option<u32>,
+    temperature: Option<f64>,
+    max_tokens: Option<u64>,
+    load_env: Option<bool>,
+    headers: Option<HashMap<String, String>>,
+    providers: Option<Vec<LlmProviderConfig>>,
+    cache: Option<LlmCacheConfig>,
+    budget: Option<LlmBudgetConfig>,
+    rate_limit: Option<LlmRateLimitConfig>,
+    cost_tracking: Option<bool>,
+    tracing: Option<bool>,
+    cooldown_secs: Option<u64>,
+    health_check_secs: Option<u64>,
+    bedrock: Option<BedrockConfig>,
+}
+
+unsafe impl IntoValueFromNative for LlmConfig {}
+
+impl magnus::TryConvert for LlmConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&LlmConfig 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 LlmConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<LlmConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize LlmConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for LlmConfig {}
+
+impl Default for LlmConfig {
+    fn default() -> Self {
+        liter_llm::client::LlmConfig::default().into()
+    }
+}
+
+impl LlmConfig {
+    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 {
+            model: kwargs
+                .get(ruby.to_symbol("model"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            api_key: kwargs
+                .get(ruby.to_symbol("api_key"))
+                .and_then(|v| String::try_convert(v).ok()),
+            base_url: kwargs
+                .get(ruby.to_symbol("base_url"))
+                .and_then(|v| String::try_convert(v).ok()),
+            timeout_secs: kwargs
+                .get(ruby.to_symbol("timeout_secs"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            max_retries: kwargs
+                .get(ruby.to_symbol("max_retries"))
+                .and_then(|v| u32::try_convert(v).ok()),
+            temperature: kwargs
+                .get(ruby.to_symbol("temperature"))
+                .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()),
+            load_env: kwargs
+                .get(ruby.to_symbol("load_env"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            headers: kwargs
+                .get(ruby.to_symbol("headers"))
+                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok()),
+            providers: kwargs
+                .get(ruby.to_symbol("providers"))
+                .and_then(|v| <Vec<LlmProviderConfig>>::try_convert(v).ok()),
+            cache: kwargs
+                .get(ruby.to_symbol("cache"))
+                .and_then(|v| LlmCacheConfig::try_convert(v).ok()),
+            budget: kwargs
+                .get(ruby.to_symbol("budget"))
+                .and_then(|v| LlmBudgetConfig::try_convert(v).ok()),
+            rate_limit: kwargs
+                .get(ruby.to_symbol("rate_limit"))
+                .and_then(|v| LlmRateLimitConfig::try_convert(v).ok()),
+            cost_tracking: kwargs
+                .get(ruby.to_symbol("cost_tracking"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            tracing: kwargs
+                .get(ruby.to_symbol("tracing"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            cooldown_secs: kwargs
+                .get(ruby.to_symbol("cooldown_secs"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            health_check_secs: kwargs
+                .get(ruby.to_symbol("health_check_secs"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            bedrock: kwargs
+                .get(ruby.to_symbol("bedrock"))
+                .and_then(|v| BedrockConfig::try_convert(v).ok()),
+        })
+    }
+
+    fn model(&self) -> String {
+        self.model.clone()
+    }
+
+    fn api_key(&self) -> Option<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 temperature(&self) -> Option<f64> {
+        self.temperature
+    }
+
+    fn max_tokens(&self) -> Option<u64> {
+        self.max_tokens
+    }
+
+    fn load_env(&self) -> Option<bool> {
+        self.load_env
+    }
+
+    fn headers(&self) -> Option<HashMap<String, String>> {
+        self.headers.clone()
+    }
+
+    fn providers(&self) -> Option<Vec<LlmProviderConfig>> {
+        self.providers.clone()
+    }
+
+    fn cache(&self) -> Option<LlmCacheConfig> {
+        self.cache.clone()
+    }
+
+    fn budget(&self) -> Option<LlmBudgetConfig> {
+        self.budget.clone()
+    }
+
+    fn rate_limit(&self) -> Option<LlmRateLimitConfig> {
+        self.rate_limit.clone()
+    }
+
+    fn cost_tracking(&self) -> Option<bool> {
+        self.cost_tracking
+    }
+
+    fn tracing(&self) -> Option<bool> {
+        self.tracing
+    }
+
+    fn cooldown_secs(&self) -> Option<u64> {
+        self.cooldown_secs
+    }
+
+    fn health_check_secs(&self) -> Option<u64> {
+        self.health_check_secs
+    }
+
+    fn bedrock(&self) -> Option<BedrockConfig> {
+        self.bedrock.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::LlmCacheConfig")]
+pub struct LlmCacheConfig {
+    max_entries: Option<usize>,
+    ttl_seconds: Option<u64>,
+    backend: Option<String>,
+    backend_config: Option<HashMap<String, String>>,
+}
+
+unsafe impl IntoValueFromNative for LlmCacheConfig {}
+
+impl magnus::TryConvert for LlmCacheConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&LlmCacheConfig 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 LlmCacheConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<LlmCacheConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize LlmCacheConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for LlmCacheConfig {}
+
+impl Default for LlmCacheConfig {
+    fn default() -> Self {
+        liter_llm::client::LlmCacheConfig::default().into()
+    }
+}
+
+impl LlmCacheConfig {
+    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()),
+            ttl_seconds: kwargs
+                .get(ruby.to_symbol("ttl_seconds"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            backend: kwargs
+                .get(ruby.to_symbol("backend"))
+                .and_then(|v| String::try_convert(v).ok()),
+            backend_config: kwargs
+                .get(ruby.to_symbol("backend_config"))
+                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok()),
+        })
+    }
+
+    fn max_entries(&self) -> Option<usize> {
+        self.max_entries
+    }
+
+    fn ttl_seconds(&self) -> Option<u64> {
+        self.ttl_seconds
+    }
+
+    fn backend(&self) -> Option<String> {
+        self.backend.clone()
+    }
+
+    fn backend_config(&self) -> Option<HashMap<String, String>> {
+        self.backend_config.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::LlmBudgetConfig")]
+pub struct LlmBudgetConfig {
+    global_limit: Option<f64>,
+    model_limits: Option<HashMap<String, f64>>,
+    enforcement: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for LlmBudgetConfig {}
+
+impl magnus::TryConvert for LlmBudgetConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&LlmBudgetConfig 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 LlmBudgetConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<LlmBudgetConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize LlmBudgetConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for LlmBudgetConfig {}
+
+impl Default for LlmBudgetConfig {
+    fn default() -> Self {
+        liter_llm::client::LlmBudgetConfig::default().into()
+    }
+}
+
+impl LlmBudgetConfig {
+    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 {
+            global_limit: kwargs
+                .get(ruby.to_symbol("global_limit"))
+                .and_then(|v| f64::try_convert(v).ok()),
+            model_limits: kwargs
+                .get(ruby.to_symbol("model_limits"))
+                .and_then(|v| <HashMap<String, f64>>::try_convert(v).ok()),
+            enforcement: kwargs
+                .get(ruby.to_symbol("enforcement"))
+                .and_then(|v| String::try_convert(v).ok()),
+        })
+    }
+
+    fn global_limit(&self) -> Option<f64> {
+        self.global_limit
+    }
+
+    fn model_limits(&self) -> Option<HashMap<String, f64>> {
+        self.model_limits.clone()
+    }
+
+    fn enforcement(&self) -> Option<String> {
+        self.enforcement.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::LlmRateLimitConfig")]
+pub struct LlmRateLimitConfig {
+    rpm: Option<u32>,
+    tpm: Option<u64>,
+    window_seconds: Option<u64>,
+}
+
+unsafe impl IntoValueFromNative for LlmRateLimitConfig {}
+
+impl magnus::TryConvert for LlmRateLimitConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&LlmRateLimitConfig 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 LlmRateLimitConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<LlmRateLimitConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize LlmRateLimitConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for LlmRateLimitConfig {}
+
+impl Default for LlmRateLimitConfig {
+    fn default() -> Self {
+        liter_llm::client::LlmRateLimitConfig::default().into()
+    }
+}
+
+impl LlmRateLimitConfig {
+    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 {
+            rpm: kwargs.get(ruby.to_symbol("rpm")).and_then(|v| u32::try_convert(v).ok()),
+            tpm: kwargs.get(ruby.to_symbol("tpm")).and_then(|v| u64::try_convert(v).ok()),
+            window_seconds: kwargs
+                .get(ruby.to_symbol("window_seconds"))
+                .and_then(|v| u64::try_convert(v).ok()),
+        })
+    }
+
+    fn rpm(&self) -> Option<u32> {
+        self.rpm
     }
 
-    fn usage(&self) -> Option<ResponseUsage> {
-        self.usage.clone()
+    fn tpm(&self) -> Option<u64> {
+        self.tpm
     }
 
-    fn error(&self) -> Option<String> {
-        self.error.clone()
+    fn window_seconds(&self) -> Option<u64> {
+        self.window_seconds
     }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
-#[magnus::wrap(class = "LiterLlm::ResponseOutputItem")]
-pub struct ResponseOutputItem {
-    item_type: String,
-    content: String,
+#[magnus::wrap(class = "LiterLlm::LlmProviderConfig")]
+pub struct LlmProviderConfig {
+    name: String,
+    base_url: String,
+    auth_header: Option<String>,
+    model_prefixes: Vec<String>,
 }
 
-unsafe impl IntoValueFromNative for ResponseOutputItem {}
+unsafe impl IntoValueFromNative for LlmProviderConfig {}
 
-impl magnus::TryConvert for ResponseOutputItem {
+impl magnus::TryConvert for LlmProviderConfig {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&ResponseOutputItem as magnus::TryConvert>::try_convert(val) {
+        if let Ok(r) = <&LlmProviderConfig 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) {
@@ -6235,68 +6804,85 @@ impl magnus::TryConvert for ResponseOutputItem {
             val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
                 magnus::Error::new(
                     unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                    format!("no implicit conversion into ResponseOutputItem: {}", e),
+                    format!("no implicit conversion into LlmProviderConfig: {}", e),
                 )
             })?
         };
-        serde_json::from_str::<ResponseOutputItem>(&json_str).map_err(|e| {
+        serde_json::from_str::<LlmProviderConfig>(&json_str).map_err(|e| {
             magnus::Error::new(
                 unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize ResponseOutputItem: {}", e),
+                format!("failed to deserialize LlmProviderConfig: {}", e),
             )
         })
     }
 }
 
-unsafe impl TryConvertOwned for ResponseOutputItem {}
+unsafe impl TryConvertOwned for LlmProviderConfig {}
 
-impl Default for ResponseOutputItem {
+impl Default for LlmProviderConfig {
     fn default() -> Self {
-        liter_llm::types::ResponseOutputItem::default().into()
+        liter_llm::client::LlmProviderConfig::default().into()
     }
 }
 
-impl ResponseOutputItem {
+impl LlmProviderConfig {
     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 {
-            item_type: kwargs
-                .get(ruby.to_symbol("item_type"))
+            name: kwargs
+                .get(ruby.to_symbol("name"))
                 .and_then(|v| String::try_convert(v).ok())
                 .unwrap_or_default(),
-            content: kwargs
-                .get(ruby.to_symbol("content"))
+            base_url: kwargs
+                .get(ruby.to_symbol("base_url"))
                 .and_then(|v| String::try_convert(v).ok())
                 .unwrap_or_default(),
+            auth_header: kwargs
+                .get(ruby.to_symbol("auth_header"))
+                .and_then(|v| String::try_convert(v).ok()),
+            model_prefixes: kwargs
+                .get(ruby.to_symbol("model_prefixes"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
         })
     }
 
-    fn item_type(&self) -> String {
-        self.item_type.clone()
+    fn name(&self) -> String {
+        self.name.clone()
     }
 
-    fn content(&self) -> String {
-        self.content.clone()
+    fn base_url(&self) -> String {
+        self.base_url.clone()
+    }
+
+    fn auth_header(&self) -> Option<String> {
+        self.auth_header.clone()
+    }
+
+    fn model_prefixes(&self) -> Vec<String> {
+        self.model_prefixes.clone()
     }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
-#[magnus::wrap(class = "LiterLlm::ResponseUsage")]
-pub struct ResponseUsage {
-    input_tokens: u64,
-    output_tokens: u64,
-    total_tokens: u64,
+#[magnus::wrap(class = "LiterLlm::BedrockConfig")]
+pub struct BedrockConfig {
+    region: Option<String>,
+    cross_region_prefix: Option<String>,
+    access_key_id: Option<String>,
+    secret_access_key: Option<String>,
+    session_token: Option<String>,
 }
 
-unsafe impl IntoValueFromNative for ResponseUsage {}
+unsafe impl IntoValueFromNative for BedrockConfig {}
 
-impl magnus::TryConvert for ResponseUsage {
+impl magnus::TryConvert for BedrockConfig {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        if let Ok(r) = <&ResponseUsage as magnus::TryConvert>::try_convert(val) {
+        if let Ok(r) = <&BedrockConfig 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) {
@@ -6305,59 +6891,70 @@ impl magnus::TryConvert for ResponseUsage {
             val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
                 magnus::Error::new(
                     unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                    format!("no implicit conversion into ResponseUsage: {}", e),
+                    format!("no implicit conversion into BedrockConfig: {}", e),
                 )
             })?
         };
-        serde_json::from_str::<ResponseUsage>(&json_str).map_err(|e| {
+        serde_json::from_str::<BedrockConfig>(&json_str).map_err(|e| {
             magnus::Error::new(
                 unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
-                format!("failed to deserialize ResponseUsage: {}", e),
+                format!("failed to deserialize BedrockConfig: {}", e),
             )
         })
     }
 }
 
-unsafe impl TryConvertOwned for ResponseUsage {}
+unsafe impl TryConvertOwned for BedrockConfig {}
 
-impl Default for ResponseUsage {
+impl Default for BedrockConfig {
     fn default() -> Self {
-        liter_llm::types::ResponseUsage::default().into()
+        liter_llm::client::BedrockConfig::default().into()
     }
 }
 
-impl ResponseUsage {
+impl BedrockConfig {
     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_tokens: kwargs
-                .get(ruby.to_symbol("input_tokens"))
-                .and_then(|v| u64::try_convert(v).ok())
-                .unwrap_or_default(),
-            output_tokens: kwargs
-                .get(ruby.to_symbol("output_tokens"))
-                .and_then(|v| u64::try_convert(v).ok())
-                .unwrap_or_default(),
-            total_tokens: kwargs
-                .get(ruby.to_symbol("total_tokens"))
-                .and_then(|v| u64::try_convert(v).ok())
-                .unwrap_or_default(),
+            region: kwargs
+                .get(ruby.to_symbol("region"))
+                .and_then(|v| String::try_convert(v).ok()),
+            cross_region_prefix: kwargs
+                .get(ruby.to_symbol("cross_region_prefix"))
+                .and_then(|v| String::try_convert(v).ok()),
+            access_key_id: kwargs
+                .get(ruby.to_symbol("access_key_id"))
+                .and_then(|v| String::try_convert(v).ok()),
+            secret_access_key: kwargs
+                .get(ruby.to_symbol("secret_access_key"))
+                .and_then(|v| String::try_convert(v).ok()),
+            session_token: kwargs
+                .get(ruby.to_symbol("session_token"))
+                .and_then(|v| String::try_convert(v).ok()),
         })
     }
 
-    fn input_tokens(&self) -> u64 {
-        self.input_tokens
+    fn region(&self) -> Option<String> {
+        self.region.clone()
     }
 
-    fn output_tokens(&self) -> u64 {
-        self.output_tokens
+    fn cross_region_prefix(&self) -> Option<String> {
+        self.cross_region_prefix.clone()
     }
 
-    fn total_tokens(&self) -> u64 {
-        self.total_tokens
+    fn access_key_id(&self) -> Option<String> {
+        self.access_key_id.clone()
+    }
+
+    fn secret_access_key(&self) -> Option<String> {
+        self.secret_access_key.clone()
+    }
+
+    fn session_token(&self) -> Option<String> {
+        self.session_token.clone()
     }
 }
 
@@ -10028,7 +10625,7 @@ impl From<liter_llm::types::AssistantMessage> for AssistantMessage {
 impl From<ToolMessage> for liter_llm::types::ToolMessage {
     fn from(val: ToolMessage) -> Self {
         Self {
-            content: val.content,
+            content: val.content.into(),
             tool_call_id: val.tool_call_id,
             name: val.name,
             ..Default::default()
@@ -10040,7 +10637,7 @@ impl From<ToolMessage> for liter_llm::types::ToolMessage {
 impl From<liter_llm::types::ToolMessage> for ToolMessage {
     fn from(val: liter_llm::types::ToolMessage) -> Self {
         Self {
-            content: val.content.to_string(),
+            content: val.content.into(),
             tool_call_id: val.tool_call_id.to_string(),
             name: val.name.map(|v| v.to_string()),
         }
@@ -11656,6 +12253,166 @@ impl From<liter_llm::types::ResponseUsage> for ResponseUsage {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::client::LlmConfig> for LlmConfig {
+    fn from(val: liter_llm::client::LlmConfig) -> Self {
+        Self {
+            model: val.model.to_string(),
+            api_key: val.api_key.map(|v| v.to_string()),
+            base_url: val.base_url.map(|v| v.to_string()),
+            timeout_secs: val.timeout_secs,
+            max_retries: val.max_retries,
+            temperature: val.temperature,
+            max_tokens: val.max_tokens,
+            load_env: val.load_env,
+            headers: val
+                .headers
+                .map(|m| m.into_iter().map(|(k, v)| (k.into(), v.into())).collect()),
+            providers: val.providers.map(|v| v.into_iter().map(Into::into).collect()),
+            cache: val.cache.map(Into::into),
+            budget: val.budget.map(Into::into),
+            rate_limit: val.rate_limit.map(Into::into),
+            cost_tracking: val.cost_tracking,
+            tracing: val.tracing,
+            cooldown_secs: val.cooldown_secs,
+            health_check_secs: val.health_check_secs,
+            bedrock: val.bedrock.map(Into::into),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<LlmCacheConfig> for liter_llm::client::LlmCacheConfig {
+    fn from(val: LlmCacheConfig) -> Self {
+        Self {
+            max_entries: val.max_entries,
+            ttl_seconds: val.ttl_seconds,
+            backend: val.backend,
+            backend_config: val
+                .backend_config
+                .map(|m| m.into_iter().map(|(k, v)| (k.into(), v.into())).collect()),
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::client::LlmCacheConfig> for LlmCacheConfig {
+    fn from(val: liter_llm::client::LlmCacheConfig) -> Self {
+        Self {
+            max_entries: val.max_entries,
+            ttl_seconds: val.ttl_seconds,
+            backend: val.backend.map(|v| v.to_string()),
+            backend_config: val
+                .backend_config
+                .map(|m| m.into_iter().map(|(k, v)| (k.into(), v.into())).collect()),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<LlmBudgetConfig> for liter_llm::client::LlmBudgetConfig {
+    fn from(val: LlmBudgetConfig) -> Self {
+        Self {
+            global_limit: val.global_limit,
+            model_limits: val.model_limits.map(|m| m.into_iter().collect()),
+            enforcement: val.enforcement,
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::client::LlmBudgetConfig> for LlmBudgetConfig {
+    fn from(val: liter_llm::client::LlmBudgetConfig) -> Self {
+        Self {
+            global_limit: val.global_limit,
+            model_limits: val.model_limits.map(|m| m.into_iter().collect()),
+            enforcement: val.enforcement.map(|v| v.to_string()),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<LlmRateLimitConfig> for liter_llm::client::LlmRateLimitConfig {
+    fn from(val: LlmRateLimitConfig) -> Self {
+        Self {
+            rpm: val.rpm,
+            tpm: val.tpm,
+            window_seconds: val.window_seconds,
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::client::LlmRateLimitConfig> for LlmRateLimitConfig {
+    fn from(val: liter_llm::client::LlmRateLimitConfig) -> Self {
+        Self {
+            rpm: val.rpm,
+            tpm: val.tpm,
+            window_seconds: val.window_seconds,
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<LlmProviderConfig> for liter_llm::client::LlmProviderConfig {
+    fn from(val: LlmProviderConfig) -> Self {
+        Self {
+            name: val.name,
+            base_url: val.base_url,
+            auth_header: val.auth_header,
+            model_prefixes: val.model_prefixes.into_iter().collect(),
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::client::LlmProviderConfig> for LlmProviderConfig {
+    fn from(val: liter_llm::client::LlmProviderConfig) -> Self {
+        Self {
+            name: val.name.to_string(),
+            base_url: val.base_url.to_string(),
+            auth_header: val.auth_header.map(|v| v.to_string()),
+            model_prefixes: val.model_prefixes.into_iter().collect(),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<BedrockConfig> for liter_llm::client::BedrockConfig {
+    fn from(val: BedrockConfig) -> Self {
+        Self {
+            region: val.region,
+            cross_region_prefix: val.cross_region_prefix,
+            access_key_id: val.access_key_id,
+            secret_access_key: val.secret_access_key,
+            session_token: val.session_token,
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::client::BedrockConfig> for BedrockConfig {
+    fn from(val: liter_llm::client::BedrockConfig) -> Self {
+        Self {
+            region: val.region.map(|v| v.to_string()),
+            cross_region_prefix: val.cross_region_prefix.map(|v| v.to_string()),
+            access_key_id: val.access_key_id.map(|v| v.to_string()),
+            secret_access_key: val.secret_access_key.map(|v| v.to_string()),
+            session_token: val.session_token.map(|v| v.to_string()),
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<WaitForBatchConfig> for liter_llm::client::WaitForBatchConfig {
@@ -12796,8 +13553,6 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("name", method!(ToolMessage::name, 0))?;
 
-    class.define_method("to_s", method!(ToolMessage::to_s, 0))?;
-
     let class = module.define_class("DeveloperMessage", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(DeveloperMessage::new, -1))?;
@@ -13651,6 +14406,104 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("total_tokens", method!(ResponseUsage::total_tokens, 0))?;
 
+    let class = module.define_class("LlmConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(LlmConfig::new, -1))?;
+
+    class.define_method("model", method!(LlmConfig::model, 0))?;
+
+    class.define_method("api_key", method!(LlmConfig::api_key, 0))?;
+
+    class.define_method("base_url", method!(LlmConfig::base_url, 0))?;
+
+    class.define_method("timeout_secs", method!(LlmConfig::timeout_secs, 0))?;
+
+    class.define_method("max_retries", method!(LlmConfig::max_retries, 0))?;
+
+    class.define_method("temperature", method!(LlmConfig::temperature, 0))?;
+
+    class.define_method("max_tokens", method!(LlmConfig::max_tokens, 0))?;
+
+    class.define_method("load_env", method!(LlmConfig::load_env, 0))?;
+
+    class.define_method("headers", method!(LlmConfig::headers, 0))?;
+
+    class.define_method("providers", method!(LlmConfig::providers, 0))?;
+
+    class.define_method("cache", method!(LlmConfig::cache, 0))?;
+
+    class.define_method("budget", method!(LlmConfig::budget, 0))?;
+
+    class.define_method("rate_limit", method!(LlmConfig::rate_limit, 0))?;
+
+    class.define_method("cost_tracking", method!(LlmConfig::cost_tracking, 0))?;
+
+    class.define_method("tracing", method!(LlmConfig::tracing, 0))?;
+
+    class.define_method("cooldown_secs", method!(LlmConfig::cooldown_secs, 0))?;
+
+    class.define_method("health_check_secs", method!(LlmConfig::health_check_secs, 0))?;
+
+    class.define_method("bedrock", method!(LlmConfig::bedrock, 0))?;
+
+    let class = module.define_class("LlmCacheConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(LlmCacheConfig::new, -1))?;
+
+    class.define_method("max_entries", method!(LlmCacheConfig::max_entries, 0))?;
+
+    class.define_method("ttl_seconds", method!(LlmCacheConfig::ttl_seconds, 0))?;
+
+    class.define_method("backend", method!(LlmCacheConfig::backend, 0))?;
+
+    class.define_method("backend_config", method!(LlmCacheConfig::backend_config, 0))?;
+
+    let class = module.define_class("LlmBudgetConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(LlmBudgetConfig::new, -1))?;
+
+    class.define_method("global_limit", method!(LlmBudgetConfig::global_limit, 0))?;
+
+    class.define_method("model_limits", method!(LlmBudgetConfig::model_limits, 0))?;
+
+    class.define_method("enforcement", method!(LlmBudgetConfig::enforcement, 0))?;
+
+    let class = module.define_class("LlmRateLimitConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(LlmRateLimitConfig::new, -1))?;
+
+    class.define_method("rpm", method!(LlmRateLimitConfig::rpm, 0))?;
+
+    class.define_method("tpm", method!(LlmRateLimitConfig::tpm, 0))?;
+
+    class.define_method("window_seconds", method!(LlmRateLimitConfig::window_seconds, 0))?;
+
+    let class = module.define_class("LlmProviderConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(LlmProviderConfig::new, -1))?;
+
+    class.define_method("name", method!(LlmProviderConfig::name, 0))?;
+
+    class.define_method("base_url", method!(LlmProviderConfig::base_url, 0))?;
+
+    class.define_method("auth_header", method!(LlmProviderConfig::auth_header, 0))?;
+
+    class.define_method("model_prefixes", method!(LlmProviderConfig::model_prefixes, 0))?;
+
+    let class = module.define_class("BedrockConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(BedrockConfig::new, -1))?;
+
+    class.define_method("region", method!(BedrockConfig::region, 0))?;
+
+    class.define_method("cross_region_prefix", method!(BedrockConfig::cross_region_prefix, 0))?;
+
+    class.define_method("access_key_id", method!(BedrockConfig::access_key_id, 0))?;
+
+    class.define_method("secret_access_key", method!(BedrockConfig::secret_access_key, 0))?;
+
+    class.define_method("session_token", method!(BedrockConfig::session_token, 0))?;
+
     let class = module.define_class("WaitForBatchConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(WaitForBatchConfig::new, -1))?;

data/lib/liter_llm/native.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:a1989c3dfb77377970d88272370ba76653a7c87963705fabadca288653ab7055
+# alef:hash:938b8ffd93c3e30d74875f875188c728addee9d4b80a97a7ac22716b3154c7c5
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # frozen_string_literal: true

data/lib/liter_llm/version.rb

@@ -1,10 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:fba5b8fce1478e035aaa2e1ba0d3f62b11d4c24e01b9f0f2bb56509b3a8b1e0c
+# alef:hash:938b8ffd93c3e30d74875f875188c728addee9d4b80a97a7ac22716b3154c7c5
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # frozen_string_literal: true
 
 module LiterLlm
   ## The version string for this package.
-  VERSION = "1.15.0"
+  VERSION = "1.16.0"
 end

data/lib/liter_llm.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:a1989c3dfb77377970d88272370ba76653a7c87963705fabadca288653ab7055
+# alef:hash:938b8ffd93c3e30d74875f875188c728addee9d4b80a97a7ac22716b3154c7c5
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 # frozen_string_literal: true

data/sig/types.rbs

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:a1989c3dfb77377970d88272370ba76653a7c87963705fabadca288653ab7055
+# alef:hash:938b8ffd93c3e30d74875f875188c728addee9d4b80a97a7ac22716b3154c7c5
 # To regenerate: alef generate
 # To verify freshness: alef verify --exit-code
 
@@ -61,11 +61,11 @@ module LiterLlm
   end
 
   class ToolMessage
-    attr_accessor content: String?
+    attr_accessor content: UserContent?
     attr_accessor tool_call_id: String?
     attr_accessor name: String?
 
-    def initialize: (?content: String, ?tool_call_id: String, ?name: String) -> void
+    def initialize: (?content: UserContent, ?tool_call_id: String, ?name: String) -> void
   end
 
   class DeveloperMessage
@@ -667,6 +667,73 @@ module LiterLlm
     def initialize: (?input_tokens: Integer, ?output_tokens: Integer, ?total_tokens: Integer) -> void
   end
 
+  class LlmConfig
+    attr_accessor model: String?
+    attr_accessor api_key: String?
+    attr_accessor base_url: String?
+    attr_accessor timeout_secs: Integer?
+    attr_accessor max_retries: Integer?
+    attr_accessor temperature: Float?
+    attr_accessor max_tokens: Integer?
+    attr_accessor load_env: bool?
+    attr_accessor headers: Hash[String, String]?
+    attr_accessor providers: Array[LlmProviderConfig]?
+    attr_accessor cache: LlmCacheConfig?
+    attr_accessor budget: LlmBudgetConfig?
+    attr_accessor rate_limit: LlmRateLimitConfig?
+    attr_accessor cost_tracking: bool?
+    attr_accessor tracing: bool?
+    attr_accessor cooldown_secs: Integer?
+    attr_accessor health_check_secs: Integer?
+    attr_accessor bedrock: BedrockConfig?
+
+    def initialize: (?model: String, ?api_key: String, ?base_url: String, ?timeout_secs: Integer, ?max_retries: Integer, ?temperature: Float, ?max_tokens: Integer, ?load_env: bool, ?headers: Hash[String, String], ?providers: Array[LlmProviderConfig], ?cache: LlmCacheConfig, ?budget: LlmBudgetConfig, ?rate_limit: LlmRateLimitConfig, ?cost_tracking: bool, ?tracing: bool, ?cooldown_secs: Integer, ?health_check_secs: Integer, ?bedrock: BedrockConfig) -> void
+  end
+
+  class LlmCacheConfig
+    attr_accessor max_entries: Integer?
+    attr_accessor ttl_seconds: Integer?
+    attr_accessor backend: String?
+    attr_accessor backend_config: Hash[String, String]?
+
+    def initialize: (?max_entries: Integer, ?ttl_seconds: Integer, ?backend: String, ?backend_config: Hash[String, String]) -> void
+  end
+
+  class LlmBudgetConfig
+    attr_accessor global_limit: Float?
+    attr_accessor model_limits: Hash[String, Float]?
+    attr_accessor enforcement: String?
+
+    def initialize: (?global_limit: Float, ?model_limits: Hash[String, Float], ?enforcement: String) -> void
+  end
+
+  class LlmRateLimitConfig
+    attr_accessor rpm: Integer?
+    attr_accessor tpm: Integer?
+    attr_accessor window_seconds: Integer?
+
+    def initialize: (?rpm: Integer, ?tpm: Integer, ?window_seconds: Integer) -> void
+  end
+
+  class LlmProviderConfig
+    attr_accessor name: String?
+    attr_accessor base_url: String?
+    attr_accessor auth_header: String?
+    attr_accessor model_prefixes: Array[String]?
+
+    def initialize: (?name: String, ?base_url: String, ?auth_header: String, ?model_prefixes: Array[String]) -> void
+  end
+
+  class BedrockConfig
+    attr_accessor region: String?
+    attr_accessor cross_region_prefix: String?
+    attr_accessor access_key_id: String?
+    attr_accessor secret_access_key: String?
+    attr_accessor session_token: String?
+
+    def initialize: (?region: String, ?cross_region_prefix: String, ?access_key_id: String, ?secret_access_key: String, ?session_token: String) -> void
+  end
+
   class WaitForBatchConfig
     attr_accessor initial_interval_secs: Float?
     attr_accessor max_interval_secs: Float?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: liter_llm
 version: !ruby/object:Gem::Version
-  version: 1.15.0
+  version: 1.16.0
 platform: ruby
 authors:
 - Na'aman Hirschfeld
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys