liter_llm 1.5.0 → 1.6.3

data/ext/liter_llm_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:93a82f0d43d1c6af3f54574908a88a952d597f9e2cca238de810ede5a8948e48
+// alef:hash:0c694843abf5c6a9fc8b410dfa73aea7c94ee538a40dc746dd72c50e7c986f97
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -21,6 +21,7 @@
 
 use futures::StreamExt as _;
 use liter_llm::client::BatchClient;
+use liter_llm::client::BatchRetriever;
 use liter_llm::client::FileClient;
 use liter_llm::client::LlmClient;
 use liter_llm::client::ResponseClient;
@@ -6256,6 +6257,92 @@ impl ResponseUsage {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::WaitForBatchConfig")]
+pub struct WaitForBatchConfig {
+    initial_interval_secs: f64,
+    max_interval_secs: f64,
+    backoff_multiplier: f32,
+    timeout_secs: Option<f64>,
+}
+
+unsafe impl IntoValueFromNative for WaitForBatchConfig {}
+
+impl magnus::TryConvert for WaitForBatchConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&WaitForBatchConfig 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 WaitForBatchConfig: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<WaitForBatchConfig>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize WaitForBatchConfig: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for WaitForBatchConfig {}
+
+impl Default for WaitForBatchConfig {
+    fn default() -> Self {
+        liter_llm::client::WaitForBatchConfig::default().into()
+    }
+}
+
+impl WaitForBatchConfig {
+    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 {
+            initial_interval_secs: kwargs
+                .get(ruby.to_symbol("initial_interval_secs"))
+                .and_then(|v| f64::try_convert(v).ok())
+                .unwrap_or(5.0),
+            max_interval_secs: kwargs
+                .get(ruby.to_symbol("max_interval_secs"))
+                .and_then(|v| f64::try_convert(v).ok())
+                .unwrap_or(60.0),
+            backoff_multiplier: kwargs
+                .get(ruby.to_symbol("backoff_multiplier"))
+                .and_then(|v| f32::try_convert(v).ok())
+                .unwrap_or(1.5),
+            timeout_secs: kwargs
+                .get(ruby.to_symbol("timeout_secs"))
+                .and_then(|v| f64::try_convert(v).ok()),
+        })
+    }
+
+    fn initial_interval_secs(&self) -> f64 {
+        self.initial_interval_secs
+    }
+
+    fn max_interval_secs(&self) -> f64 {
+        self.max_interval_secs
+    }
+
+    fn backoff_multiplier(&self) -> f32 {
+        self.backoff_multiplier
+    }
+
+    fn timeout_secs(&self) -> Option<f64> {
+        self.timeout_secs
+    }
+}
+
 #[derive(Clone)]
 #[magnus::wrap(class = "LiterLlm::DefaultClient")]
 pub struct DefaultClient {
@@ -6613,6 +6700,44 @@ impl DefaultClient {
         Ok(result.into())
     }
 
+    fn fetch_batch_for_polling_async(&self, batch_id: String) -> Result<BatchObject, Error> {
+        let inner = self.inner.clone();
+        let rt = tokio::runtime::Runtime::new().map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        let result = rt
+            .block_on(async { inner.fetch_batch_for_polling(&batch_id).await })
+            .map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+        Ok(result.into())
+    }
+
+    fn wait_for_batch_async(&self, batch_id: String, config: WaitForBatchConfig) -> Result<BatchObject, Error> {
+        let inner = self.inner.clone();
+        let rt = tokio::runtime::Runtime::new().map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        let result = rt
+            .block_on(async { inner.wait_for_batch(&batch_id, config.into()).await })
+            .map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+        Ok(result.into())
+    }
+
     fn create_response_async(&self, req: CreateResponseRequest) -> Result<ResponseObject, Error> {
         let inner = self.inner.clone();
         let rt = tokio::runtime::Runtime::new().map_err(|e| {
@@ -6794,6 +6919,120 @@ impl CustomProviderConfig {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::ProviderCapabilities")]
+pub struct ProviderCapabilities {
+    vision: bool,
+    reasoning: bool,
+    structured_output: bool,
+    function_calling: bool,
+    audio_in: bool,
+    audio_out: bool,
+    video_in: bool,
+}
+
+unsafe impl IntoValueFromNative for ProviderCapabilities {}
+
+impl magnus::TryConvert for ProviderCapabilities {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ProviderCapabilities 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 ProviderCapabilities: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ProviderCapabilities>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ProviderCapabilities: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ProviderCapabilities {}
+
+impl Default for ProviderCapabilities {
+    fn default() -> Self {
+        liter_llm::provider::ProviderCapabilities::default().into()
+    }
+}
+
+impl ProviderCapabilities {
+    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 {
+            vision: kwargs
+                .get(ruby.to_symbol("vision"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            reasoning: kwargs
+                .get(ruby.to_symbol("reasoning"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            structured_output: kwargs
+                .get(ruby.to_symbol("structured_output"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            function_calling: kwargs
+                .get(ruby.to_symbol("function_calling"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            audio_in: kwargs
+                .get(ruby.to_symbol("audio_in"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            audio_out: kwargs
+                .get(ruby.to_symbol("audio_out"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            video_in: kwargs
+                .get(ruby.to_symbol("video_in"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn vision(&self) -> bool {
+        self.vision
+    }
+
+    fn reasoning(&self) -> bool {
+        self.reasoning
+    }
+
+    fn structured_output(&self) -> bool {
+        self.structured_output
+    }
+
+    fn function_calling(&self) -> bool {
+        self.function_calling
+    }
+
+    fn audio_in(&self) -> bool {
+        self.audio_in
+    }
+
+    fn audio_out(&self) -> bool {
+        self.audio_out
+    }
+
+    fn video_in(&self) -> bool {
+        self.video_in
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "LiterLlm::ProviderConfig")]
 pub struct ProviderConfig {
@@ -7042,6 +7281,25 @@ impl BudgetConfig {
     }
 }
 
+#[derive(Clone)]
+#[magnus::wrap(class = "LiterLlm::SingleflightResult")]
+pub struct SingleflightResult {
+    inner: Arc<liter_llm::tower::SingleflightResult>,
+}
+
+unsafe impl IntoValueFromNative for SingleflightResult {}
+
+impl magnus::TryConvert for SingleflightResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &SingleflightResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+
+unsafe impl TryConvertOwned for SingleflightResult {}
+
+impl SingleflightResult {}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::RateLimitConfig")]
@@ -7114,6 +7372,77 @@ impl RateLimitConfig {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "LiterLlm::IntentPrototype")]
+pub struct IntentPrototype {
+    name: String,
+    embedding: Vec<f64>,
+    model: String,
+}
+
+unsafe impl IntoValueFromNative for IntentPrototype {}
+
+impl magnus::TryConvert for IntentPrototype {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&IntentPrototype 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 IntentPrototype: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<IntentPrototype>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize IntentPrototype: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for IntentPrototype {}
+
+impl IntentPrototype {
+    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 {
+            name: kwargs
+                .get(ruby.to_symbol("name"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            embedding: kwargs
+                .get(ruby.to_symbol("embedding"))
+                .and_then(|v| <Vec<f64>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            model: kwargs
+                .get(ruby.to_symbol("model"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+        })
+    }
+
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn embedding(&self) -> Vec<f64> {
+        self.embedding.clone()
+    }
+
+    fn model(&self) -> String {
+        self.model.clone()
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "role")]
 pub enum Message {
@@ -8165,6 +8494,48 @@ impl magnus::TryConvert for AuthHeaderFormat {
 unsafe impl IntoValueFromNative for AuthHeaderFormat {}
 unsafe impl TryConvertOwned for AuthHeaderFormat {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum StreamFormat {
+    Sse,
+    AwsEventStream,
+}
+
+impl Default for StreamFormat {
+    fn default() -> Self {
+        Self::Sse
+    }
+}
+
+impl magnus::IntoValue for StreamFormat {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            StreamFormat::Sse => "sse",
+            StreamFormat::AwsEventStream => "aws_event_stream",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+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.
+        match s.as_str() {
+            "sse" | "Sse" => Ok(StreamFormat::Sse),
+            "aws_event_stream" | "AwsEventStream" => Ok(StreamFormat::AwsEventStream),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid StreamFormat value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for StreamFormat {}
+unsafe impl TryConvertOwned for StreamFormat {}
+
 #[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum AuthType {
@@ -8254,6 +8625,91 @@ impl magnus::TryConvert for Enforcement {
 unsafe impl IntoValueFromNative for Enforcement {}
 unsafe impl TryConvertOwned for Enforcement {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum CircuitState {
+    Closed,
+    Open,
+    HalfOpen,
+}
+
+impl Default for CircuitState {
+    fn default() -> Self {
+        Self::Closed
+    }
+}
+
+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",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+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.
+        match s.as_str() {
+            "closed" | "Closed" => Ok(CircuitState::Closed),
+            "open" | "Open" => Ok(CircuitState::Open),
+            "half_open" | "HalfOpen" => Ok(CircuitState::HalfOpen),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid CircuitState value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for CircuitState {}
+unsafe impl TryConvertOwned for CircuitState {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum HealthStatus {
+    Healthy,
+    Unhealthy,
+}
+
+impl Default for HealthStatus {
+    fn default() -> Self {
+        Self::Healthy
+    }
+}
+
+impl magnus::IntoValue for HealthStatus {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            HealthStatus::Healthy => "healthy",
+            HealthStatus::Unhealthy => "unhealthy",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+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.
+        match s.as_str() {
+            "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}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for HealthStatus {}
+unsafe impl TryConvertOwned for HealthStatus {}
+
 fn create_client(args: &[magnus::Value]) -> Result<DefaultClient, Error> {
     let args = magnus::scan_args::scan_args::<
         (String,),
@@ -8331,6 +8787,10 @@ fn unregister_custom_provider(name: String) -> Result<bool, Error> {
     Ok(result)
 }
 
+fn capabilities(provider_name: String) -> ProviderCapabilities {
+    liter_llm::provider::capabilities(&provider_name).into()
+}
+
 fn all_providers() -> Result<Vec<ProviderConfig>, Error> {
     let result = liter_llm::provider::all_providers().map_err(|e| {
         magnus::Error::new(
@@ -8364,6 +8824,10 @@ fn completion_cost_with_cache(
     liter_llm::completion_cost_with_cache(&model, prompt_tokens, cached_tokens, completion_tokens)
 }
 
+fn clear() -> () {
+    liter_llm::guardrail::registry::clear()
+}
+
 fn count_tokens(model: String, text: String) -> Result<usize, Error> {
     let result = liter_llm::count_tokens(&model, &text).map_err(|e| {
         magnus::Error::new(
@@ -8401,6 +8865,17 @@ fn count_request_tokens(args: &[magnus::Value]) -> Result<usize, Error> {
     Ok(result)
 }
 
+fn check_bound(context: String, current_len: usize, incoming: usize, limit: usize) -> Result<(), Error> {
+    let result = liter_llm::util::bounds::check_bound(&context, current_len, incoming, limit).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
+#[cfg(all(feature = "native-http", not(target_os = "windows")))]
 fn ensure_crypto_provider() -> () {
     liter_llm::ensure_crypto_provider()
 }
@@ -10053,6 +10528,30 @@ impl From<liter_llm::types::ResponseUsage> for ResponseUsage {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<WaitForBatchConfig> for liter_llm::client::WaitForBatchConfig {
+    fn from(val: WaitForBatchConfig) -> Self {
+        Self {
+            initial_interval_secs: val.initial_interval_secs,
+            max_interval_secs: val.max_interval_secs,
+            backoff_multiplier: val.backoff_multiplier,
+            timeout_secs: val.timeout_secs,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::client::WaitForBatchConfig> for WaitForBatchConfig {
+    fn from(val: liter_llm::client::WaitForBatchConfig) -> Self {
+        Self {
+            initial_interval_secs: val.initial_interval_secs,
+            max_interval_secs: val.max_interval_secs,
+            backoff_multiplier: val.backoff_multiplier,
+            timeout_secs: val.timeout_secs,
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<CustomProviderConfig> for liter_llm::provider::custom::CustomProviderConfig {
     fn from(val: CustomProviderConfig) -> Self {
@@ -10077,6 +10576,36 @@ impl From<liter_llm::provider::custom::CustomProviderConfig> for CustomProviderC
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<ProviderCapabilities> for liter_llm::provider::ProviderCapabilities {
+    fn from(val: ProviderCapabilities) -> Self {
+        Self {
+            vision: val.vision,
+            reasoning: val.reasoning,
+            structured_output: val.structured_output,
+            function_calling: val.function_calling,
+            audio_in: val.audio_in,
+            audio_out: val.audio_out,
+            video_in: val.video_in,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::provider::ProviderCapabilities> for ProviderCapabilities {
+    fn from(val: liter_llm::provider::ProviderCapabilities) -> Self {
+        Self {
+            vision: val.vision,
+            reasoning: val.reasoning,
+            structured_output: val.structured_output,
+            function_calling: val.function_calling,
+            audio_in: val.audio_in,
+            audio_out: val.audio_out,
+            video_in: val.video_in,
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ProviderConfig> for liter_llm::provider::ProviderConfig {
     fn from(val: ProviderConfig) -> Self {
@@ -10175,6 +10704,17 @@ impl From<liter_llm::RateLimitConfig> for RateLimitConfig {
     }
 }
 
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<liter_llm::tower::IntentPrototype> for IntentPrototype {
+    fn from(val: liter_llm::tower::IntentPrototype) -> Self {
+        Self {
+            name: val.name.to_string(),
+            embedding: val.embedding.into_iter().collect(),
+            model: val.model.to_string(),
+        }
+    }
+}
+
 impl From<Message> for liter_llm::types::Message {
     fn from(val: Message) -> Self {
         match val {
@@ -10580,6 +11120,15 @@ impl From<liter_llm::provider::custom::AuthHeaderFormat> for AuthHeaderFormat {
     }
 }
 
+impl From<liter_llm::provider::StreamFormat> for StreamFormat {
+    fn from(val: liter_llm::provider::StreamFormat) -> Self {
+        match val {
+            liter_llm::provider::StreamFormat::Sse => Self::Sse,
+            liter_llm::provider::StreamFormat::AwsEventStream => Self::AwsEventStream,
+        }
+    }
+}
+
 impl From<AuthType> for liter_llm::provider::AuthType {
     fn from(val: AuthType) -> Self {
         match val {
@@ -10620,6 +11169,25 @@ impl From<liter_llm::Enforcement> for Enforcement {
     }
 }
 
+impl From<liter_llm::tower::CircuitState> for CircuitState {
+    fn from(val: liter_llm::tower::CircuitState) -> Self {
+        match val {
+            liter_llm::tower::CircuitState::Closed => Self::Closed,
+            liter_llm::tower::CircuitState::Open => Self::Open,
+            liter_llm::tower::CircuitState::HalfOpen => Self::HalfOpen,
+        }
+    }
+}
+
+impl From<liter_llm::tower::HealthStatus> for HealthStatus {
+    fn from(val: liter_llm::tower::HealthStatus) -> Self {
+        match val {
+            liter_llm::tower::HealthStatus::Healthy => Self::Healthy,
+            liter_llm::tower::HealthStatus::Unhealthy => Self::Unhealthy,
+        }
+    }
+}
+
 /// Convert a `liter_llm::error::LiterLlmError` error to a Magnus runtime error.
 #[allow(dead_code)]
 fn liter_llm_error_to_magnus_err(e: liter_llm::error::LiterLlmError) -> magnus::Error {
@@ -11661,6 +12229,21 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("total_tokens", method!(ResponseUsage::total_tokens, 0))?;
 
+    let class = module.define_class("WaitForBatchConfig", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(WaitForBatchConfig::new, -1))?;
+
+    class.define_method(
+        "initial_interval_secs",
+        method!(WaitForBatchConfig::initial_interval_secs, 0),
+    )?;
+
+    class.define_method("max_interval_secs", method!(WaitForBatchConfig::max_interval_secs, 0))?;
+
+    class.define_method("backoff_multiplier", method!(WaitForBatchConfig::backoff_multiplier, 0))?;
+
+    class.define_method("timeout_secs", method!(WaitForBatchConfig::timeout_secs, 0))?;
+
     let class = module.define_class("DefaultClient", ruby.class_object())?;
 
     class.define_method("chat_async", method!(DefaultClient::chat_async, 1))?;
@@ -11701,6 +12284,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("cancel_batch_async", method!(DefaultClient::cancel_batch_async, 1))?;
 
+    class.define_method(
+        "fetch_batch_for_polling_async",
+        method!(DefaultClient::fetch_batch_for_polling_async, 1),
+    )?;
+
+    class.define_method("wait_for_batch_async", method!(DefaultClient::wait_for_batch_async, 2))?;
+
     class.define_method(
         "create_response_async",
         method!(DefaultClient::create_response_async, 1),
@@ -11730,6 +12320,24 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("model_prefixes", method!(CustomProviderConfig::model_prefixes, 0))?;
 
+    let class = module.define_class("ProviderCapabilities", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(ProviderCapabilities::new, -1))?;
+
+    class.define_method("vision", method!(ProviderCapabilities::vision, 0))?;
+
+    class.define_method("reasoning", method!(ProviderCapabilities::reasoning, 0))?;
+
+    class.define_method("structured_output", method!(ProviderCapabilities::structured_output, 0))?;
+
+    class.define_method("function_calling", method!(ProviderCapabilities::function_calling, 0))?;
+
+    class.define_method("audio_in", method!(ProviderCapabilities::audio_in, 0))?;
+
+    class.define_method("audio_out", method!(ProviderCapabilities::audio_out, 0))?;
+
+    class.define_method("video_in", method!(ProviderCapabilities::video_in, 0))?;
+
     let class = module.define_class("ProviderConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ProviderConfig::new, -1))?;
@@ -11766,6 +12374,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("enforcement", method!(BudgetConfig::enforcement, 0))?;
 
+    let class = module.define_class("SingleflightResult", ruby.class_object())?;
+
     let class = module.define_class("RateLimitConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(RateLimitConfig::new, -1))?;
@@ -11776,6 +12386,16 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("window", method!(RateLimitConfig::window, 0))?;
 
+    let class = module.define_class("IntentPrototype", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(IntentPrototype::new, -1))?;
+
+    class.define_method("name", method!(IntentPrototype::name, 0))?;
+
+    class.define_method("embedding", method!(IntentPrototype::embedding, 0))?;
+
+    class.define_method("model", method!(IntentPrototype::model, 0))?;
+
     let class = module.define_class("ChatStreamIterator", ruby.class_object())?;
     class.define_method("next_chunk", method!(ChatStreamIterator::next_chunk, 0))?;
     class.define_method("each", method!(ChatStreamIterator::each, 0))?;
@@ -11789,6 +12409,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("unregister_custom_provider", function!(unregister_custom_provider, 1))?;
 
+    module.define_module_function("capabilities", function!(capabilities, 1))?;
+
     module.define_module_function("all_providers", function!(all_providers, 0))?;
 
     module.define_module_function("complex_provider_names", function!(complex_provider_names, 0))?;
@@ -11797,10 +12419,14 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("completion_cost_with_cache", function!(completion_cost_with_cache, 4))?;
 
+    module.define_module_function("clear", function!(clear, 0))?;
+
     module.define_module_function("count_tokens", function!(count_tokens, 2))?;
 
     module.define_module_function("count_request_tokens", function!(count_request_tokens, -1))?;
 
+    module.define_module_function("check_bound", function!(check_bound, 4))?;
+
     module.define_module_function("ensure_crypto_provider", function!(ensure_crypto_provider, 0))?;
 
     module.define_module_function("chat_stream", function!(chat_stream, 2))?;