liter_llm 1.17.3 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19482743f60ba9ade5386c54b0b066f735278e39374770764a8abb312fb7c544
-  data.tar.gz: 80c1dabeaba2542c2d013b7dcebee1e6f0e22fbf71fa870b1fd1b2cb45859504
+  metadata.gz: c5bd204a264adbd698932331bb39e051c81aee3e41ec25694acabb29b0ca3fbb
+  data.tar.gz: 2435c21142430e5f33c6543e2c734000ba05520168f4cb0ebebad3f8da39bf5a
 SHA512:
-  metadata.gz: '049bf1770b1dd29ae209bbd2bc8207fae5d572db4bccd6d7d3a12d62ea147ca2c0e9e731b807078f784efab6fec5d9a09f514239265c62b28d14e73f5ff0ea40'
-  data.tar.gz: 8ee96a2a68f466c36b73a18b62e84131afd5715f67bb5b0ee9a0fc739d62db4209bd85ad4c15add462ee33691113102b2ba22f15f519ef687ebfa79fc847c196
+  metadata.gz: 5766c2a1de94770d1753f5c2e766ab2640687cb7a027ebf60164c295b9bcff408537e3ae4842dc421e66d3fd454e70b62bdc0901c4c7f9dd7c624e8168861d44
+  data.tar.gz: dbb82f17c226cb866f70e57f8346b30a127e469b07271d325be21a58ccd1b1b35fcb05e003e0dbaba146cf0bedd4b1432a9099eab4d9b2a69ab2b754327f73ce

data/README.md

@@ -1,3 +1,8 @@
+<!-- This file is auto-generated by alef — DO NOT EDIT. -->
+<!-- alef:hash:cd144fa3684b490bac9fd3b39ee03cefb1f07fcfecec6d7599e0314be7d775e3 -->
+<!-- To regenerate: alef readme -->
+<!-- To verify freshness: alef verify -->
+
 <p align="center">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://cdn.jsdelivr.net/gh/xberg-io/assets@v1/banner/readme-banner-dark.svg">

data/ext/liter_llm_rb/native/Cargo.lock

@@ -1794,9 +1794,9 @@ checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
 
 [[package]]
 name = "liter-llm"
-version = "1.17.3"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11c241016acd3f9a7893561db6cedb20ea2a90bbcc751928145e09c0e6ac1dd5"
+checksum = "de5d980b9ebe69c204ce3dfcd1fb5f01cf374d6ecd99f04f791b98faec0a1b27"
 dependencies = [
  "ahash 0.8.12",
  "arc-swap",
@@ -1838,7 +1838,7 @@ dependencies = [
 
 [[package]]
 name = "liter-llm-rb"
-version = "1.17.3"
+version = "1.18.0"
 dependencies = [
  "futures",
  "liter-llm",
@@ -2571,9 +2571,9 @@ dependencies = [
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
 dependencies = [
  "bindgen",
  "lazy_static",

data/ext/liter_llm_rb/native/Cargo.toml

@@ -1,6 +1,11 @@
+# This file is auto-generated by alef — DO NOT EDIT.
+# alef:hash:e221e01ba9179e68583cafd7161d7c43de4eacc42c13af77e2e5f1e4d63bc728
+# To regenerate: alef generate
+# To verify freshness: alef verify
+
 [package]
 name = "liter-llm-rb"
-version = "1.17.3"
+version = "1.18.0"
 edition = "2024"
 license = "MIT"
 description = "Universal LLM API client with Rust-powered polyglot bindings."
@@ -17,18 +22,29 @@ path = "../src/lib.rs"
 crate-type = ["cdylib"]
 
 [features]
-default = ["native-http", "opendal-cache", "wasm-http", "tokenizer", "tower"]
+default = ["native-http", "opendal-cache", "tokenizer", "tower", "wasm-http"]
 native-http = ["liter-llm/native-http"]
 opendal-cache = ["liter-llm/opendal-cache"]
-wasm-http = ["liter-llm/wasm-http"]
 tokenizer = ["liter-llm/tokenizer"]
 tower = ["liter-llm/tower"]
+wasm-http = ["liter-llm/wasm-http"]
 
 [dependencies]
 futures = "0.3"
-liter-llm = { version = "1.17.3", features = ["native-http", "full"] }
+liter-llm = { version = "1.18.0", features = ["native-http", "full"] }
 magnus = "0.8"
 rb-sys = ">=0.9, <0.9.128"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1", features = ["rt-multi-thread"] }
+
+# This crate deliberately does not use `[lints]` / `workspace = true`: its C-ABI /
+# PyO3 / napi / ext-php-rs / NIF boundary requires `unsafe` code, and the workspace's
+# `[workspace.lints.rust]` sets `unsafe_code = "deny"` -- an all-or-nothing table that
+# would turn every such boundary into a compile error. The `[lints.clippy]` block below
+# instead carries the subset of the workspace's deny-by-default lint policy this crate
+# can actually satisfy. ~keep
+[lints.clippy]
+dbg_macro = "deny"
+print_stderr = "deny"
+print_stdout = "deny"

data/ext/liter_llm_rb/native/extconf.rb

@@ -1,3 +1,8 @@
+# This file is auto-generated by alef — DO NOT EDIT.
+# alef:hash:7b1808d5f8bd88acdf4abf88f680c0db55f06da73e768c8e465d13b44f0c70bf
+# To regenerate: alef generate
+# To verify freshness: alef verify
+
 # frozen_string_literal: true
 
 require "mkmf"

data/ext/liter_llm_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:6cd4ed693a8d18aa4e3959a858f10dc6c9ddd62b2ddf72ca30c91065514f407b
+// alef:hash:0e3211f6b85dad033da915446b280abf238ccc5297156d5b9c3942bc8c8bd78a
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -6461,6 +6461,7 @@ pub struct LlmConfig {
     cache: Option<LlmCacheConfig>,
     budget: Option<LlmBudgetConfig>,
     rate_limit: Option<LlmRateLimitConfig>,
+    in_flight_limit: Option<LlmInFlightLimitConfig>,
     cost_tracking: Option<bool>,
     tracing: Option<bool>,
     cooldown_secs: Option<u64>,
@@ -6549,6 +6550,9 @@ impl LlmConfig {
             rate_limit: kwargs
                 .get(ruby.to_symbol("rate_limit"))
                 .and_then(|v| LlmRateLimitConfig::try_convert(v).ok()),
+            in_flight_limit: kwargs
+                .get(ruby.to_symbol("in_flight_limit"))
+                .and_then(|v| LlmInFlightLimitConfig::try_convert(v).ok()),
             cost_tracking: kwargs
                 .get(ruby.to_symbol("cost_tracking"))
                 .and_then(|v| bool::try_convert(v).ok()),
@@ -6619,6 +6623,10 @@ impl LlmConfig {
         self.rate_limit.clone()
     }
 
+    fn in_flight_limit(&self) -> Option<LlmInFlightLimitConfig> {
+        self.in_flight_limit.clone()
+    }
+
     fn cost_tracking(&self) -> Option<bool> {
         self.cost_tracking
     }
@@ -6869,6 +6877,65 @@ impl LlmRateLimitConfig {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::LlmInFlightLimitConfig")]
+pub struct LlmInFlightLimitConfig {
+    max_in_flight: Option<usize>,
+}
+
+unsafe impl IntoValueFromNative for LlmInFlightLimitConfig {}
+
+impl magnus::TryConvert for LlmInFlightLimitConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&LlmInFlightLimitConfig 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 LlmInFlightLimitConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<LlmInFlightLimitConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize LlmInFlightLimitConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for LlmInFlightLimitConfig {}
+
+impl Default for LlmInFlightLimitConfig {
+    fn default() -> Self {
+        liter_llm::client::LlmInFlightLimitConfig::default().into()
+    }
+}
+
+impl LlmInFlightLimitConfig {
+    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_in_flight: kwargs
+                .get(ruby.to_symbol("max_in_flight"))
+                .and_then(|v| usize::try_convert(v).ok()),
+        })
+    }
+
+    fn max_in_flight(&self) -> Option<usize> {
+        self.max_in_flight
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::LlmProviderConfig")]
@@ -8520,6 +8587,65 @@ unsafe impl TryConvertOwned for SingleflightResult {}
 
 impl SingleflightResult {}
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::InFlightLimitConfig")]
+pub struct InFlightLimitConfig {
+    max_in_flight: Option<usize>,
+}
+
+unsafe impl IntoValueFromNative for InFlightLimitConfig {}
+
+impl magnus::TryConvert for InFlightLimitConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&InFlightLimitConfig 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 InFlightLimitConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<InFlightLimitConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize InFlightLimitConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for InFlightLimitConfig {}
+
+impl Default for InFlightLimitConfig {
+    fn default() -> Self {
+        liter_llm::InFlightLimitConfig::default().into()
+    }
+}
+
+impl InFlightLimitConfig {
+    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_in_flight: kwargs
+                .get(ruby.to_symbol("max_in_flight"))
+                .and_then(|v| usize::try_convert(v).ok()),
+        })
+    }
+
+    fn max_in_flight(&self) -> Option<usize> {
+        self.max_in_flight
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::RateLimitConfig")]
@@ -9006,8 +9132,9 @@ impl magnus::IntoValue for ImageDetail {
 impl magnus::TryConvert for ImageDetail {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "low" | "Low" => Ok(ImageDetail::Low),
             "high" | "High" => Ok(ImageDetail::High),
@@ -9166,8 +9293,9 @@ impl magnus::IntoValue for ToolType {
 impl magnus::TryConvert for ToolType {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "function" | "Function" => Ok(ToolType::Function),
             other => Err(magnus::Error::new(
@@ -9265,8 +9393,9 @@ impl magnus::IntoValue for ToolChoiceMode {
 impl magnus::TryConvert for ToolChoiceMode {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "auto" | "Auto" => Ok(ToolChoiceMode::Auto),
             "required" | "Required" => Ok(ToolChoiceMode::Required),
@@ -9428,8 +9557,9 @@ impl magnus::IntoValue for Modality {
 impl magnus::TryConvert for Modality {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "text" | "Text" => Ok(Modality::Text),
             "audio" | "Audio" => Ok(Modality::Audio),
@@ -9480,8 +9610,9 @@ impl magnus::IntoValue for FinishReason {
 impl magnus::TryConvert for FinishReason {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "stop" | "Stop" => Ok(FinishReason::Stop),
             "length" | "Length" => Ok(FinishReason::Length),
@@ -9532,8 +9663,9 @@ impl magnus::IntoValue for ReasoningEffort {
 impl magnus::TryConvert for ReasoningEffort {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "low" | "Low" => Ok(ReasoningEffort::Low),
             "medium" | "Medium" => Ok(ReasoningEffort::Medium),
@@ -9577,8 +9709,9 @@ impl magnus::IntoValue for EmbeddingFormat {
 impl magnus::TryConvert for EmbeddingFormat {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "float" | "Float" => Ok(EmbeddingFormat::Float),
             "base64" | "Base64" => Ok(EmbeddingFormat::Base64),
@@ -9598,6 +9731,7 @@ unsafe impl TryConvertOwned for EmbeddingFormat {}
 pub enum EmbeddingInput {
     Single(String),
     Multiple(Vec<String>),
+    Multimodal(Vec<EmbeddingContentPart>),
 }
 
 impl Default for EmbeddingInput {
@@ -9649,6 +9783,70 @@ impl magnus::TryConvert for EmbeddingInput {
 unsafe impl IntoValueFromNative for EmbeddingInput {}
 unsafe impl TryConvertOwned for EmbeddingInput {}
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "type")]
+pub enum EmbeddingContentPart {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image_url")]
+    ImageUrl { image_url: ImageUrl },
+    #[serde(rename = "image_base64")]
+    ImageBase64 { image_base64: String },
+}
+
+impl Default for EmbeddingContentPart {
+    fn default() -> Self {
+        Self::Text {
+            text: Default::default(),
+        }
+    }
+}
+
+impl magnus::IntoValue for EmbeddingContentPart {
+    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 EmbeddingContentPart {
+    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 EmbeddingContentPart: {}", 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 EmbeddingContentPart {}
+unsafe impl TryConvertOwned for EmbeddingContentPart {}
+impl EmbeddingContentPart {}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(untagged)]
 pub enum ModerationInput {
@@ -9849,7 +10047,7 @@ impl magnus::IntoValue for FilePurpose {
         let sym = match self {
             FilePurpose::Assistants => "assistants",
             FilePurpose::Batch => "batch",
-            FilePurpose::FineTune => "fine_tune",
+            FilePurpose::FineTune => "fine-tune",
             FilePurpose::Vision => "vision",
         };
         handle.to_symbol(sym).into_value_with(handle)
@@ -9859,12 +10057,13 @@ impl magnus::IntoValue for FilePurpose {
 impl magnus::TryConvert for FilePurpose {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "assistants" | "Assistants" => Ok(FilePurpose::Assistants),
             "batch" | "Batch" => Ok(FilePurpose::Batch),
-            "fine_tune" | "FineTune" => Ok(FilePurpose::FineTune),
+            "fine-tune" | "fine_tune" | "FineTune" => Ok(FilePurpose::FineTune),
             "vision" | "Vision" => Ok(FilePurpose::Vision),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
@@ -9915,8 +10114,9 @@ impl magnus::IntoValue for BatchStatus {
 impl magnus::TryConvert for BatchStatus {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "validating" | "Validating" => Ok(BatchStatus::Validating),
             "failed" | "Failed" => Ok(BatchStatus::Failed),
@@ -10019,8 +10219,9 @@ impl magnus::IntoValue for StreamFormat {
 impl magnus::TryConvert for StreamFormat {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "sse" | "Sse" => Ok(StreamFormat::Sse),
             "aws_event_stream" | "AwsEventStream" => Ok(StreamFormat::AwsEventStream),
@@ -10054,7 +10255,7 @@ impl magnus::IntoValue for AuthType {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
             AuthType::Bearer => "bearer",
-            AuthType::ApiKey => "api_key",
+            AuthType::ApiKey => "api-key",
             AuthType::None => "none",
             AuthType::Unknown => "unknown",
         };
@@ -10065,11 +10266,12 @@ impl magnus::IntoValue for AuthType {
 impl magnus::TryConvert for AuthType {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
             "bearer" | "Bearer" => Ok(AuthType::Bearer),
-            "api_key" | "ApiKey" => Ok(AuthType::ApiKey),
+            "api-key" | "api_key" | "ApiKey" => Ok(AuthType::ApiKey),
             "none" | "None" => Ok(AuthType::None),
             "unknown" | "Unknown" => Ok(AuthType::Unknown),
             other => Err(magnus::Error::new(
@@ -10098,8 +10300,8 @@ impl Default for Enforcement {
 impl magnus::IntoValue for Enforcement {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            Enforcement::Hard => "hard",
-            Enforcement::Soft => "soft",
+            Enforcement::Hard => "Hard",
+            Enforcement::Soft => "Soft",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -10108,11 +10310,12 @@ impl magnus::IntoValue for Enforcement {
 impl magnus::TryConvert for Enforcement {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
-            "hard" | "Hard" => Ok(Enforcement::Hard),
-            "soft" | "Soft" => Ok(Enforcement::Soft),
+            "Hard" | "hard" => Ok(Enforcement::Hard),
+            "Soft" | "soft" => Ok(Enforcement::Soft),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid Enforcement value: {other}"),
@@ -10199,9 +10402,9 @@ impl Default for CircuitState {
 impl magnus::IntoValue for CircuitState {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            CircuitState::Closed => "closed",
-            CircuitState::Open => "open",
-            CircuitState::HalfOpen => "half_open",
+            CircuitState::Closed => "Closed",
+            CircuitState::Open => "Open",
+            CircuitState::HalfOpen => "HalfOpen",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -10210,12 +10413,13 @@ impl magnus::IntoValue for CircuitState {
 impl magnus::TryConvert for CircuitState {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
-            "closed" | "Closed" => Ok(CircuitState::Closed),
-            "open" | "Open" => Ok(CircuitState::Open),
-            "half_open" | "HalfOpen" => Ok(CircuitState::HalfOpen),
+            "Closed" | "closed" => Ok(CircuitState::Closed),
+            "Open" | "open" => Ok(CircuitState::Open),
+            "HalfOpen" | "half_open" => Ok(CircuitState::HalfOpen),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid CircuitState value: {other}"),
@@ -10242,8 +10446,8 @@ impl Default for HealthStatus {
 impl magnus::IntoValue for HealthStatus {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         let sym = match self {
-            HealthStatus::Healthy => "healthy",
-            HealthStatus::Unhealthy => "unhealthy",
+            HealthStatus::Healthy => "Healthy",
+            HealthStatus::Unhealthy => "Unhealthy",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -10252,11 +10456,12 @@ impl magnus::IntoValue for HealthStatus {
 impl magnus::TryConvert for HealthStatus {
     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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
-            "healthy" | "Healthy" => Ok(HealthStatus::Healthy),
-            "unhealthy" | "Unhealthy" => Ok(HealthStatus::Unhealthy),
+            "Healthy" | "healthy" => Ok(HealthStatus::Healthy),
+            "Unhealthy" | "unhealthy" => Ok(HealthStatus::Unhealthy),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid HealthStatus value: {other}"),
@@ -10284,9 +10489,9 @@ impl Default for RefreshOutcome {
 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",
+            RefreshOutcome::Disabled => "Disabled",
+            RefreshOutcome::FromCache => "FromCache",
+            RefreshOutcome::Fetched => "Fetched",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -10295,12 +10500,13 @@ impl magnus::IntoValue for RefreshOutcome {
 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.
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
         match s.as_str() {
-            "disabled" | "Disabled" => Ok(RefreshOutcome::Disabled),
-            "from_cache" | "FromCache" => Ok(RefreshOutcome::FromCache),
-            "fetched" | "Fetched" => Ok(RefreshOutcome::Fetched),
+            "Disabled" | "disabled" => Ok(RefreshOutcome::Disabled),
+            "FromCache" | "from_cache" => 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}"),
@@ -12374,6 +12580,7 @@ impl From<liter_llm::client::LlmConfig> for LlmConfig {
             cache: val.cache.map(Into::into),
             budget: val.budget.map(Into::into),
             rate_limit: val.rate_limit.map(Into::into),
+            in_flight_limit: val.in_flight_limit.map(Into::into),
             cost_tracking: val.cost_tracking,
             tracing: val.tracing,
             cooldown_secs: val.cooldown_secs,
@@ -12459,6 +12666,24 @@ impl From<liter_llm::client::LlmRateLimitConfig> for LlmRateLimitConfig {
     }
 }
 
+#[allow(clippy::needless_update)]
+impl From<LlmInFlightLimitConfig> for liter_llm::client::LlmInFlightLimitConfig {
+    fn from(val: LlmInFlightLimitConfig) -> Self {
+        Self {
+            max_in_flight: val.max_in_flight,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<liter_llm::client::LlmInFlightLimitConfig> for LlmInFlightLimitConfig {
+    fn from(val: liter_llm::client::LlmInFlightLimitConfig) -> Self {
+        Self {
+            max_in_flight: val.max_in_flight,
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 impl From<LlmProviderConfig> for liter_llm::client::LlmProviderConfig {
     fn from(val: LlmProviderConfig) -> Self {
@@ -12779,6 +13004,14 @@ impl From<liter_llm::CacheConfig> for CacheConfig {
     }
 }
 
+impl From<liter_llm::InFlightLimitConfig> for InFlightLimitConfig {
+    fn from(val: liter_llm::InFlightLimitConfig) -> Self {
+        Self {
+            max_in_flight: val.max_in_flight,
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 impl From<RateLimitConfig> for liter_llm::RateLimitConfig {
     fn from(val: RateLimitConfig) -> Self {
@@ -13169,6 +13402,7 @@ impl From<EmbeddingInput> for liter_llm::types::EmbeddingInput {
         match val {
             EmbeddingInput::Single(_0) => Self::Single(_0),
             EmbeddingInput::Multiple(_0) => Self::Multiple(_0.into_iter().collect()),
+            EmbeddingInput::Multimodal(_0) => Self::Multimodal(_0.into_iter().map(Into::into).collect()),
         }
     }
 }
@@ -13178,6 +13412,37 @@ impl From<liter_llm::types::EmbeddingInput> for EmbeddingInput {
         match val {
             liter_llm::types::EmbeddingInput::Single(_0) => Self::Single(_0),
             liter_llm::types::EmbeddingInput::Multiple(_0) => Self::Multiple(_0.into_iter().collect()),
+            liter_llm::types::EmbeddingInput::Multimodal(_0) => {
+                Self::Multimodal(_0.into_iter().map(Into::into).collect())
+            }
+        }
+    }
+}
+
+impl From<EmbeddingContentPart> for liter_llm::types::EmbeddingContentPart {
+    fn from(val: EmbeddingContentPart) -> Self {
+        match val {
+            EmbeddingContentPart::Text { text } => Self::Text { text: text },
+            EmbeddingContentPart::ImageUrl { image_url } => Self::ImageUrl {
+                image_url: image_url.into(),
+            },
+            EmbeddingContentPart::ImageBase64 { image_base64 } => Self::ImageBase64 {
+                image_base64: image_base64,
+            },
+        }
+    }
+}
+
+impl From<liter_llm::types::EmbeddingContentPart> for EmbeddingContentPart {
+    fn from(val: liter_llm::types::EmbeddingContentPart) -> Self {
+        match val {
+            liter_llm::types::EmbeddingContentPart::Text { text } => Self::Text { text: text.to_string() },
+            liter_llm::types::EmbeddingContentPart::ImageUrl { image_url } => Self::ImageUrl {
+                image_url: image_url.into(),
+            },
+            liter_llm::types::EmbeddingContentPart::ImageBase64 { image_base64 } => Self::ImageBase64 {
+                image_base64: image_base64.to_string(),
+            },
         }
     }
 }
@@ -14552,6 +14817,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("rate_limit", method!(LlmConfig::rate_limit, 0))?;
 
+    class.define_method("in_flight_limit", method!(LlmConfig::in_flight_limit, 0))?;
+
     class.define_method("cost_tracking", method!(LlmConfig::cost_tracking, 0))?;
 
     class.define_method("tracing", method!(LlmConfig::tracing, 0))?;
@@ -14594,6 +14861,12 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("window_seconds", method!(LlmRateLimitConfig::window_seconds, 0))?;
 
+    let class = module.define_class("LlmInFlightLimitConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(LlmInFlightLimitConfig::new, -1))?;
+
+    class.define_method("max_in_flight", method!(LlmInFlightLimitConfig::max_in_flight, 0))?;
+
     let class = module.define_class("LlmProviderConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(LlmProviderConfig::new, -1))?;
@@ -14902,6 +15175,12 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("SingleflightResult", ruby.class_object())?;
 
+    let class = module.define_class("InFlightLimitConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(InFlightLimitConfig::new, -1))?;
+
+    class.define_method("max_in_flight", method!(InFlightLimitConfig::max_in_flight, 0))?;
+
     let class = module.define_class("RateLimitConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(RateLimitConfig::new, -1))?;

data/lib/liter_llm/native.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:22279669d98fa4ccf8fbbb4ad5a2b8ac72ae4eb02a46d2c25430da6aad7b80fb
+# alef:hash:a963d30e17380908f8f67a9244a29d7e6ad83445dac64977569ca4c3b4b53f6a
 # To regenerate: alef generate
 # To verify freshness: alef verify
 # frozen_string_literal: true
@@ -556,6 +556,93 @@ module LiterLlm
   end
 end
 
+module LiterLlm
+  # A content part in a multimodal embedding input.
+  module EmbeddingContentPart
+    extend T::Helpers
+    extend T::Sig
+
+    interface!
+
+    # Dispatch from a Hash to the appropriate variant constructor.
+    # @param hash [Hash] with discriminator field and variant-specific fields
+    # @return [variant_class] an instance of the appropriate variant
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.untyped) }
+    def self.from_hash(hash)
+      discriminator = hash[:type] || hash["type"]
+      case discriminator
+      when "text" then EmbeddingContentPartText.from_hash(hash)
+      when "image_url" then EmbeddingContentPartImageUrl.from_hash(hash)
+      when "image_base64" then EmbeddingContentPartImageBase64.from_hash(hash)
+      else raise "Unknown discriminator: #{discriminator}"
+      end
+    end
+  end
+  ## Plain text.
+  EmbeddingContentPartText = Data.define(:text) do
+    include EmbeddingContentPart
+    extend T::Sig
+
+    # @return [String]
+    sig { returns(String) }
+    def text = super # rubocop:disable Lint/UselessMethodDefinition
+    sig { returns(T::Boolean) }
+    def text? = true
+    sig { returns(T::Boolean) }
+    def image_url? = false
+    sig { returns(T::Boolean) }
+    def image_base64? = false
+    # @param hash [Hash] deserialized from the native extension
+    # @return [self]
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.attached_class) }
+    def self.from_hash(hash)
+      new(text: hash[:text] || hash["text"])
+    end
+  end
+  ## Image identified by a data URL or HTTP/HTTPS URL.
+  EmbeddingContentPartImageUrl = Data.define(:image_url) do
+    include EmbeddingContentPart
+    extend T::Sig
+
+    # @return [ImageUrl]
+    sig { returns(ImageUrl) }
+    def image_url = super # rubocop:disable Lint/UselessMethodDefinition
+    sig { returns(T::Boolean) }
+    def text? = false
+    sig { returns(T::Boolean) }
+    def image_url? = true
+    sig { returns(T::Boolean) }
+    def image_base64? = false
+    # @param hash [Hash] deserialized from the native extension
+    # @return [self]
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.attached_class) }
+    def self.from_hash(hash)
+      new(image_url: hash[:image_url] || hash["image_url"])
+    end
+  end
+  ## Image encoded as a complete data URL.
+  EmbeddingContentPartImageBase64 = Data.define(:image_base64) do
+    include EmbeddingContentPart
+    extend T::Sig
+
+    # @return [String]
+    sig { returns(String) }
+    def image_base64 = super # rubocop:disable Lint/UselessMethodDefinition
+    sig { returns(T::Boolean) }
+    def text? = false
+    sig { returns(T::Boolean) }
+    def image_url? = false
+    sig { returns(T::Boolean) }
+    def image_base64? = true
+    # @param hash [Hash] deserialized from the native extension
+    # @return [self]
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T.attached_class) }
+    def self.from_hash(hash)
+      new(image_base64: hash[:image_base64] || hash["image_base64"])
+    end
+  end
+end
+
 module LiterLlm
   # Document input for OCR — either a URL or inline base64 data.
   module OcrDocument

data/lib/liter_llm/version.rb

@@ -1,10 +1,10 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:2fa028ca6b2a895c045b5e1d6db85593c92d1c2c4245a025c8828d42585afb14
+# alef:hash:9cad1aa634ead525aea0040c6902c806b7daab37eb7802e5be0d0c5f48aa8847
 # To regenerate: alef generate
 # To verify freshness: alef verify
 # frozen_string_literal: true
 
 module LiterLlm
   ## The version string for this package.
-  VERSION = "1.17.3"
+  VERSION = "1.18.0"
 end

data/lib/liter_llm.rb

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:2b8f0579821576133e6d5bff77bf1b62637bc64e5b026d466a10ba1506d635fc
+# alef:hash:b8684376c861ef7e78cc307694871bb74d674153abe531df23adc8a37901a153
 # To regenerate: alef generate
 # To verify freshness: alef verify
 # frozen_string_literal: true

data/sig/types.rbs

@@ -1,5 +1,5 @@
 # This file is auto-generated by alef — DO NOT EDIT.
-# alef:hash:a5339cc792b0081109ce66c00a4664ef4c1c15ecb5f0096c5d6ff9a4cc32c72a
+# alef:hash:182fb885a8ef562d0a181ae0aadb5dd6e9b1a440c76f7dffbfea998a71b1eb6d
 # To regenerate: alef generate
 # To verify freshness: alef verify
 
@@ -692,13 +692,14 @@ module LiterLlm
     attr_reader cache: LlmCacheConfig?
     attr_reader budget: LlmBudgetConfig?
     attr_reader rate_limit: LlmRateLimitConfig?
+    attr_reader in_flight_limit: LlmInFlightLimitConfig?
     attr_reader cost_tracking: bool?
     attr_reader tracing: bool?
     attr_reader cooldown_secs: Integer?
     attr_reader health_check_secs: Integer?
     attr_reader 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
+    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, ?in_flight_limit: LlmInFlightLimitConfig, ?cost_tracking: bool, ?tracing: bool, ?cooldown_secs: Integer, ?health_check_secs: Integer, ?bedrock: BedrockConfig) -> void
   end
 
   class LlmCacheConfig
@@ -726,6 +727,12 @@ module LiterLlm
     def initialize: (?rpm: Integer, ?tpm: Integer, ?window_seconds: Integer) -> void
   end
 
+  class LlmInFlightLimitConfig
+    attr_reader max_in_flight: Integer?
+
+    def initialize: (?max_in_flight: Integer) -> void
+  end
+
   class LlmProviderConfig
     attr_reader name: String
     attr_reader base_url: String
@@ -878,6 +885,12 @@ module LiterLlm
   class SingleflightResult
   end
 
+  class InFlightLimitConfig
+    attr_reader max_in_flight: Integer?
+
+    def initialize: (?max_in_flight: Integer) -> void
+  end
+
   class RateLimitConfig
     attr_reader rpm: Integer?
     attr_reader tpm: Integer?
@@ -958,6 +971,9 @@ module LiterLlm
   class EmbeddingInput
   end
 
+  class EmbeddingContentPart
+  end
+
   class ModerationInput
   end
 
@@ -970,7 +986,7 @@ module LiterLlm
   end
 
   class FilePurpose
-    type value = :assistants | :batch | :fine_tune | :vision
+    type value = :assistants | :batch | :fine-tune | :vision
   end
 
   class BatchStatus
@@ -985,26 +1001,26 @@ module LiterLlm
   end
 
   class AuthType
-    type value = :bearer | :api_key | :none | :unknown
+    type value = :bearer | :api-key | :none | :unknown
   end
 
   class Enforcement
-    type value = :hard | :soft
+    type value = :Hard | :Soft
   end
 
   class CacheBackend
   end
 
   class CircuitState
-    type value = :closed | :open | :half_open
+    type value = :Closed | :Open | :HalfOpen
   end
 
   class HealthStatus
-    type value = :healthy | :unhealthy
+    type value = :Healthy | :Unhealthy
   end
 
   class RefreshOutcome
-    type value = :disabled | :from_cache | :fetched
+    type value = :Disabled | :FromCache | :Fetched
   end
 
   def self.create_client: (String api_key, ?String base_url, ?Integer timeout_secs, ?Integer max_retries, ?String model_hint) -> DefaultClient

metadata

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