liter_llm 2.2.4 → 2.4.0

data/ext/liter_llm_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:3861ed195f3c3e52018feb23f8f7da4fefbc958be2e63235f137618ed6fec98a
+// alef:hash:f56903f2fe41ec4d6589bdea2776c5b41c4a388341f774d49faee678da6246dc
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -1539,6 +1539,268 @@ impl CatalogInfo {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default)]
+#[magnus::wrap(class = "LiterLlm::CatalogModel")]
+pub struct CatalogModel {
+    key: String,
+    provider: String,
+    model: String,
+    mode: Option<String>,
+    max_tokens: Option<u64>,
+    max_input_tokens: Option<u64>,
+    max_output_tokens: Option<u64>,
+    supports_vision: Option<bool>,
+    supports_function_calling: Option<bool>,
+    supports_reasoning: Option<bool>,
+    supports_structured_output: Option<bool>,
+    supports_audio_input: Option<bool>,
+    supports_audio_output: Option<bool>,
+    supports_prompt_caching: Option<bool>,
+}
+
+unsafe impl IntoValueFromNative for CatalogModel {}
+
+impl magnus::TryConvert for CatalogModel {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&CatalogModel 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 CatalogModel: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<CatalogModel>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize CatalogModel: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for CatalogModel {}
+
+impl Default for CatalogModel {
+    fn default() -> Self {
+        liter_llm::CatalogModel::default().into()
+    }
+}
+
+impl CatalogModel {
+    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 {
+            key: match kwargs.get(ruby.to_symbol("key")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `key`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            provider: match kwargs.get(ruby.to_symbol("provider")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `provider`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            model: match kwargs.get(ruby.to_symbol("model")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `model`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            mode: match kwargs.get(ruby.to_symbol("mode")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `mode`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            max_tokens: match kwargs.get(ruby.to_symbol("max_tokens")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_tokens`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            max_input_tokens: match kwargs.get(ruby.to_symbol("max_input_tokens")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_input_tokens`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            max_output_tokens: match kwargs.get(ruby.to_symbol("max_output_tokens")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `max_output_tokens`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            supports_vision: match kwargs.get(ruby.to_symbol("supports_vision")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `supports_vision`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            supports_function_calling: match kwargs
+                .get(ruby.to_symbol("supports_function_calling"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `supports_function_calling`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            supports_reasoning: match kwargs.get(ruby.to_symbol("supports_reasoning")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `supports_reasoning`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            supports_structured_output: match kwargs
+                .get(ruby.to_symbol("supports_structured_output"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `supports_structured_output`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            supports_audio_input: match kwargs
+                .get(ruby.to_symbol("supports_audio_input"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `supports_audio_input`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            supports_audio_output: match kwargs
+                .get(ruby.to_symbol("supports_audio_output"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `supports_audio_output`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            supports_prompt_caching: match kwargs
+                .get(ruby.to_symbol("supports_prompt_caching"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `supports_prompt_caching`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+        })
+    }
+
+    fn key(&self) -> String {
+        self.key.clone()
+    }
+
+    fn provider(&self) -> String {
+        self.provider.clone()
+    }
+
+    fn model(&self) -> String {
+        self.model.clone()
+    }
+
+    fn mode(&self) -> Option<String> {
+        self.mode.clone()
+    }
+
+    fn max_tokens(&self) -> Option<u64> {
+        self.max_tokens
+    }
+
+    fn max_input_tokens(&self) -> Option<u64> {
+        self.max_input_tokens
+    }
+
+    fn max_output_tokens(&self) -> Option<u64> {
+        self.max_output_tokens
+    }
+
+    fn supports_vision(&self) -> Option<bool> {
+        self.supports_vision
+    }
+
+    fn supports_function_calling(&self) -> Option<bool> {
+        self.supports_function_calling
+    }
+
+    fn supports_reasoning(&self) -> Option<bool> {
+        self.supports_reasoning
+    }
+
+    fn supports_structured_output(&self) -> Option<bool> {
+        self.supports_structured_output
+    }
+
+    fn supports_audio_input(&self) -> Option<bool> {
+        self.supports_audio_input
+    }
+
+    fn supports_audio_output(&self) -> Option<bool> {
+        self.supports_audio_output
+    }
+
+    fn supports_prompt_caching(&self) -> Option<bool> {
+        self.supports_prompt_caching
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(default)]
 #[magnus::wrap(class = "LiterLlm::CatalogRefreshConfig")]
@@ -2681,6 +2943,7 @@ pub struct ClientOptions {
     api_key: String,
     base_url: Option<String>,
     timeout_secs: Option<u64>,
+    connect_timeout_secs: Option<u64>,
     max_retries: Option<u32>,
     max_response_bytes: Option<u64>,
     model_hint: Option<String>,
@@ -2759,6 +3022,18 @@ impl ClientOptions {
                 })?),
                 None => None,
             },
+            connect_timeout_secs: match kwargs
+                .get(ruby.to_symbol("connect_timeout_secs"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `connect_timeout_secs`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
             max_retries: match kwargs.get(ruby.to_symbol("max_retries")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(u32::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -2801,6 +3076,10 @@ impl ClientOptions {
         self.timeout_secs
     }
 
+    fn connect_timeout_secs(&self) -> Option<u64> {
+        self.connect_timeout_secs
+    }
+
     fn max_retries(&self) -> Option<u32> {
         self.max_retries
     }
@@ -3115,6 +3394,7 @@ pub struct CreateImageRequest {
     style: Option<String>,
     response_format: Option<String>,
     user: Option<String>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for CreateImageRequest {}
@@ -3238,6 +3518,15 @@ impl CreateImageRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -3272,6 +3561,10 @@ impl CreateImageRequest {
     fn user(&self) -> Option<String> {
         self.user.clone()
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -3468,6 +3761,7 @@ pub struct CreateSpeechRequest {
     voice: String,
     response_format: Option<String>,
     speed: Option<f64>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for CreateSpeechRequest {}
@@ -3564,6 +3858,15 @@ impl CreateSpeechRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -3586,6 +3889,10 @@ impl CreateSpeechRequest {
     fn speed(&self) -> Option<f64> {
         self.speed
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -3598,6 +3905,7 @@ pub struct CreateTranscriptionRequest {
     prompt: Option<String>,
     response_format: Option<String>,
     temperature: Option<f64>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for CreateTranscriptionRequest {}
@@ -3703,6 +4011,15 @@ impl CreateTranscriptionRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -3729,6 +4046,10 @@ impl CreateTranscriptionRequest {
     fn temperature(&self) -> Option<f64> {
         self.temperature
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -3950,18 +4271,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.chat(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.chat(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -3977,18 +4290,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.embed(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.embed(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4003,18 +4308,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.list_models().await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.list_models().await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4030,20 +4327,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.image_generate(req_core).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4059,18 +4346,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.speech(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.speech(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.to_vec())
     }
 
@@ -4086,18 +4365,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.transcribe(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.transcribe(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4113,18 +4384,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.moderate(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.moderate(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4140,18 +4403,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.rerank(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.rerank(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4167,18 +4422,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.search(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.search(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4194,18 +4441,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.ocr(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.ocr(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4221,18 +4460,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.create_file(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.create_file(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4247,20 +4478,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.retrieve_file(&file_id).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4275,18 +4496,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.delete_file(&file_id).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.delete_file(&file_id).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4302,18 +4515,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.list_files(query_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.list_files(query_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4328,18 +4533,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.file_content(&file_id).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.file_content(&file_id).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.to_vec())
     }
 
@@ -4355,18 +4552,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
-        let result = rt.block_on(async { inner.create_batch(req_core).await }).map_err(|e| {
-            magnus::Error::new(
-                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                e.to_string(),
-            )
-        })?;
+            .map_err(alef_magnus_err)?;
+        let result = rt
+            .block_on(async { inner.create_batch(req_core).await })
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4381,20 +4570,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.retrieve_batch(&batch_id).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4410,20 +4589,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.list_batches(query_core).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4438,20 +4607,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.cancel_batch(&batch_id).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4466,20 +4625,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         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(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4492,23 +4641,13 @@ impl DefaultClient {
         // stack overflow aborts the process with SIGBUS instead of raising a catchable panic.
         const ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES: usize = 16 * 1024 * 1024;
         let rt = tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
-            .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .enable_all()
+            .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
+            .build()
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.wait_for_batch(&batch_id, config_core).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4524,20 +4663,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.create_response(req_core).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4552,20 +4681,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.retrieve_response(&response_id).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 
@@ -4580,20 +4699,10 @@ impl DefaultClient {
             .enable_all()
             .thread_stack_size(ASYNC_METHOD_RUNTIME_STACK_SIZE_BYTES)
             .build()
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let result = rt
             .block_on(async { inner.cancel_response(&response_id).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         Ok(result.into())
     }
 }
@@ -4626,12 +4735,7 @@ impl DefaultClient {
         );
         let stream = runtime
             .block_on(async { inner.chat_stream(core_req).await })
-            .map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-                    e.to_string(),
-                )
-            })?;
+            .map_err(alef_magnus_err)?;
         let iterator = ChatStreamIterator {
             inner: Arc::new(tokio::sync::Mutex::new(Some(stream))),
             runtime,
@@ -5006,6 +5110,7 @@ pub struct EmbeddingRequest {
     encoding_format: Option<EmbeddingFormat>,
     dimensions: Option<u32>,
     user: Option<String>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for EmbeddingRequest {}
@@ -5107,6 +5212,15 @@ impl EmbeddingRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -5129,6 +5243,10 @@ impl EmbeddingRequest {
     fn user(&self) -> Option<String> {
         self.user.clone()
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -6652,6 +6770,7 @@ pub struct LlmConfig {
     api_key: Option<String>,
     base_url: Option<String>,
     timeout_secs: Option<u64>,
+    connect_timeout_secs: Option<u64>,
     max_retries: Option<u32>,
     temperature: Option<f64>,
     max_tokens: Option<u64>,
@@ -6754,6 +6873,18 @@ impl LlmConfig {
                 })?),
                 None => None,
             },
+            connect_timeout_secs: match kwargs
+                .get(ruby.to_symbol("connect_timeout_secs"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `connect_timeout_secs`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
             max_retries: match kwargs.get(ruby.to_symbol("max_retries")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(u32::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -6908,6 +7039,10 @@ impl LlmConfig {
         self.timeout_secs
     }
 
+    fn connect_timeout_secs(&self) -> Option<u64> {
+        self.connect_timeout_secs
+    }
+
     fn max_retries(&self) -> Option<u32> {
         self.max_retries
     }
@@ -8473,6 +8608,7 @@ impl ModerationCategoryScores {
 pub struct ModerationRequest {
     input: ModerationInput,
     model: Option<String>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for ModerationRequest {}
@@ -8547,6 +8683,15 @@ impl ModerationRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -8557,6 +8702,10 @@ impl ModerationRequest {
     fn model(&self) -> Option<String> {
         self.model.clone()
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -8957,6 +9106,7 @@ pub struct OcrRequest {
     document: OcrDocument,
     pages: Option<Vec<u32>>,
     include_image_base64: Option<bool>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for OcrRequest {}
@@ -9052,6 +9202,15 @@ impl OcrRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -9070,6 +9229,10 @@ impl OcrRequest {
     fn include_image_base64(&self) -> Option<bool> {
         self.include_image_base64
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -9748,6 +9911,7 @@ pub struct RerankRequest {
     documents: Vec<RerankDocument>,
     top_n: Option<u32>,
     return_documents: Option<bool>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for RerankRequest {}
@@ -9844,6 +10008,15 @@ impl RerankRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -9866,6 +10039,10 @@ impl RerankRequest {
     fn return_documents(&self) -> Option<bool> {
         self.return_documents
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -10583,6 +10760,7 @@ pub struct SearchRequest {
     max_results: Option<u32>,
     search_domain_filter: Option<Vec<String>>,
     country: Option<String>,
+    extra_body: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for SearchRequest {}
@@ -10682,6 +10860,15 @@ impl SearchRequest {
                 })?),
                 None => None,
             },
+            extra_body: match kwargs.get(ruby.to_symbol("extra_body")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extra_body`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -10704,6 +10891,10 @@ impl SearchRequest {
     fn country(&self) -> Option<String> {
         self.country.clone()
     }
+
+    fn extra_body(&self) -> Option<String> {
+        self.extra_body.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -13639,6 +13830,7 @@ pub enum ReasoningEffort {
     High,
     Minimal,
     Max,
+    None,
 }
 
 impl Default for ReasoningEffort {
@@ -13655,6 +13847,7 @@ impl magnus::IntoValue for ReasoningEffort {
             ReasoningEffort::High => "high",
             ReasoningEffort::Minimal => "minimal",
             ReasoningEffort::Max => "max",
+            ReasoningEffort::None => "none",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -13679,6 +13872,7 @@ impl magnus::TryConvert for ReasoningEffort {
             "high" | "High" => Ok(ReasoningEffort::High),
             "minimal" | "Minimal" => Ok(ReasoningEffort::Minimal),
             "max" | "Max" => Ok(ReasoningEffort::Max),
+            "none" | "None" => Ok(ReasoningEffort::None),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid ReasoningEffort value: {other}"),
@@ -13917,6 +14111,7 @@ unsafe impl TryConvertOwned for StopSequence {}
 pub enum StreamFormat {
     Sse,
     AwsEventStream,
+    Ndjson,
 }
 
 impl Default for StreamFormat {
@@ -13930,6 +14125,7 @@ impl magnus::IntoValue for StreamFormat {
         let sym = match self {
             StreamFormat::Sse => "sse",
             StreamFormat::AwsEventStream => "aws_event_stream",
+            StreamFormat::Ndjson => "ndjson",
         };
         handle.to_symbol(sym).into_value_with(handle)
     }
@@ -13951,6 +14147,7 @@ impl magnus::TryConvert for StreamFormat {
         match s.as_str() {
             "sse" | "Sse" => Ok(StreamFormat::Sse),
             "aws_event_stream" | "AwsEventStream" => Ok(StreamFormat::AwsEventStream),
+            "ndjson" | "Ndjson" => Ok(StreamFormat::Ndjson),
             other => Err(magnus::Error::new(
                 unsafe { Ruby::get_unchecked() }.exception_arg_error(),
                 format!("invalid StreamFormat value: {other}"),
@@ -14182,12 +14379,7 @@ unsafe impl IntoValueFromNative for UserContent {}
 unsafe impl TryConvertOwned for UserContent {}
 
 fn all_providers() -> Result<Vec<ProviderConfig>, Error> {
-    let result = liter_llm::provider::all_providers().map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::provider::all_providers().map_err(alef_magnus_err)?;
     Ok(result.iter().map(|v| v.clone().into()).collect())
 }
 
@@ -14200,12 +14392,8 @@ fn catalog_info() -> Option<CatalogInfo> {
 }
 
 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(),
-        )
-    })?;
+    let result =
+        liter_llm::util::bounds::check_bound(&context, current_len, incoming, limit).map_err(alef_magnus_err)?;
     Ok(result)
 }
 
@@ -14247,12 +14435,7 @@ fn completion_cost_with_cache_details(
 }
 
 fn complex_provider_names() -> Result<Vec<String>, Error> {
-    let result = liter_llm::provider::complex_provider_names().map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::provider::complex_provider_names().map_err(alef_magnus_err)?;
     Ok(result.iter().map(|s| s.to_string()).collect())
 }
 
@@ -14275,23 +14458,13 @@ fn count_request_tokens(args: &[magnus::Value]) -> Result<usize, Error> {
         }
         _ => Default::default(),
     };
-    let result = liter_llm::count_request_tokens(&model, &req_core).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::count_request_tokens(&model, &req_core).map_err(alef_magnus_err)?;
     Ok(result)
 }
 
 #[cfg(feature = "tokenizer")]
 fn count_tokens(model: String, text: String) -> Result<usize, Error> {
-    let result = liter_llm::count_tokens(&model, &text).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::count_tokens(&model, &text).map_err(alef_magnus_err)?;
     Ok(result)
 }
 
@@ -14299,7 +14472,12 @@ fn count_tokens(model: String, text: String) -> Result<usize, Error> {
 fn create_client(args: &[magnus::Value]) -> Result<DefaultClient, Error> {
     let args = magnus::scan_args::scan_args::<
         (String,),
-        (Option<magnus::Value>, Option<u64>, Option<u32>, Option<magnus::Value>),
+        (
+            Option<magnus::Value>,
+            Option<magnus::Value>,
+            Option<magnus::Value>,
+            Option<magnus::Value>,
+        ),
         (),
         (),
         (),
@@ -14309,28 +14487,28 @@ fn create_client(args: &[magnus::Value]) -> Result<DefaultClient, Error> {
 
     let (base_url, timeout_secs, max_retries, model_hint) = args.optional;
 
-    let base_url: Option<String> = base_url.and_then(|v| {
-        if v.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(v).unwrap_or_default())
-        }
-    });
+    let base_url: Option<String> = match base_url {
+        Some(v) if !v.is_nil() => Some(String::try_convert(v)?),
+        _ => None,
+    };
 
-    let model_hint: Option<String> = model_hint.and_then(|v| {
-        if v.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(v).unwrap_or_default())
-        }
-    });
+    let timeout_secs: Option<u64> = match timeout_secs {
+        Some(v) if !v.is_nil() => Some(u64::try_convert(v)?),
+        _ => None,
+    };
+
+    let max_retries: Option<u32> = match max_retries {
+        Some(v) if !v.is_nil() => Some(u32::try_convert(v)?),
+        _ => None,
+    };
+
+    let model_hint: Option<String> = match model_hint {
+        Some(v) if !v.is_nil() => Some(String::try_convert(v)?),
+        _ => None,
+    };
 
-    let result = liter_llm::create_client(api_key, base_url, timeout_secs, max_retries, model_hint).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result =
+        liter_llm::create_client(api_key, base_url, timeout_secs, max_retries, model_hint).map_err(alef_magnus_err)?;
     Ok(DefaultClient {
         inner: Arc::new(result),
     })
@@ -14338,12 +14516,7 @@ fn create_client(args: &[magnus::Value]) -> Result<DefaultClient, Error> {
 
 #[cfg(any(feature = "native-http", feature = "wasm-http"))]
 fn create_client_from_json(json: String) -> Result<DefaultClient, Error> {
-    let result = liter_llm::create_client_from_json(&json).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::create_client_from_json(&json).map_err(alef_magnus_err)?;
     Ok(DefaultClient {
         inner: Arc::new(result),
     })
@@ -14363,12 +14536,7 @@ fn create_client_with_options(args: &[magnus::Value]) -> Result<DefaultClient, E
         }
         _ => Default::default(),
     };
-    let result = liter_llm::create_client_with_options(options.into()).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::create_client_with_options(options.into()).map_err(alef_magnus_err)?;
     Ok(DefaultClient {
         inner: Arc::new(result),
     })
@@ -14384,13 +14552,10 @@ fn encode_data_url(args: &[magnus::Value]) -> Result<String, Error> {
 
     let (mime,) = args.optional;
 
-    let mime: Option<String> = mime.and_then(|v| {
-        if v.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(v).unwrap_or_default())
-        }
-    });
+    let mime: Option<String> = match mime {
+        Some(v) if !v.is_nil() => Some(String::try_convert(v)?),
+        _ => None,
+    };
 
     Ok(liter_llm::image::encode_data_url(&bytes, mime.as_deref()))
 }
@@ -14408,15 +14573,25 @@ fn exact_model_info(model: String) -> Option<ModelInfo> {
 }
 
 fn install_catalog_overlay_from_str(catalog_json: String) -> Result<(), Error> {
-    let result = liter_llm::install_catalog_overlay_from_str(&catalog_json).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::install_catalog_overlay_from_str(&catalog_json).map_err(alef_magnus_err)?;
     Ok(result)
 }
 
+fn list_catalog_models(args: &[magnus::Value]) -> Result<Vec<CatalogModel>, Error> {
+    let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (provider,) = args.optional;
+
+    let provider: Option<String> = match provider {
+        Some(v) if !v.is_nil() => Some(String::try_convert(v)?),
+        _ => None,
+    };
+
+    Ok(liter_llm::list_catalog_models(provider.as_deref())
+        .into_iter()
+        .map(Into::into)
+        .collect())
+}
+
 fn model_info(model: String) -> Option<ModelInfo> {
     liter_llm::model_info(&model).map(Into::into)
 }
@@ -14447,11 +14622,11 @@ fn refresh_catalog(args: &[magnus::Value]) -> Result<RefreshOutcome, Error> {
             .enable_all()
             .build()
             .map_err(|e| e.to_string())?;
-        rt.block_on(async { liter_llm::refresh_catalog(&config_core).await })
-            .map_err(|e| e.to_string())
+        Ok(rt.block_on(async { liter_llm::refresh_catalog(&config_core).await }))
     });
     let result = async_result
         .map_err(|message| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_runtime_error(), message))?;
+    let result = result.map_err(alef_magnus_err)?;
     Ok(result.into())
 }
 
@@ -14476,11 +14651,11 @@ fn refresh_catalog_async(args: &[magnus::Value]) -> Result<RefreshOutcome, Error
             .enable_all()
             .build()
             .map_err(|e| e.to_string())?;
-        rt.block_on(async { liter_llm::refresh_catalog(&config_core).await })
-            .map_err(|e| e.to_string())
+        Ok(rt.block_on(async { liter_llm::refresh_catalog(&config_core).await }))
     });
     let result = async_result
         .map_err(|message| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_runtime_error(), message))?;
+    let result = result.map_err(alef_magnus_err)?;
     Ok(result.into())
 }
 
@@ -14490,22 +14665,12 @@ fn register_custom_provider(config: magnus::Value) -> Result<(), Error> {
             .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))?;
         binding_val.into()
     };
-    let result = liter_llm::provider::custom::register_custom_provider(config.into()).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::provider::custom::register_custom_provider(config.into()).map_err(alef_magnus_err)?;
     Ok(result)
 }
 
 fn unregister_custom_provider(name: String) -> Result<bool, Error> {
-    let result = liter_llm::provider::custom::unregister_custom_provider(&name).map_err(|e| {
-        magnus::Error::new(
-            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
-            e.to_string(),
-        )
-    })?;
+    let result = liter_llm::provider::custom::unregister_custom_provider(&name).map_err(alef_magnus_err)?;
     Ok(result)
 }
 
@@ -14807,6 +14972,51 @@ impl From<liter_llm::CatalogInfo> for CatalogInfo {
     }
 }
 
+#[allow(clippy::needless_update)]
+impl From<CatalogModel> for liter_llm::CatalogModel {
+    fn from(val: CatalogModel) -> Self {
+        Self {
+            key: val.key,
+            provider: val.provider,
+            model: val.model,
+            mode: val.mode,
+            max_tokens: val.max_tokens,
+            max_input_tokens: val.max_input_tokens,
+            max_output_tokens: val.max_output_tokens,
+            supports_vision: val.supports_vision,
+            supports_function_calling: val.supports_function_calling,
+            supports_reasoning: val.supports_reasoning,
+            supports_structured_output: val.supports_structured_output,
+            supports_audio_input: val.supports_audio_input,
+            supports_audio_output: val.supports_audio_output,
+            supports_prompt_caching: val.supports_prompt_caching,
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure)]
+impl From<liter_llm::CatalogModel> for CatalogModel {
+    fn from(val: liter_llm::CatalogModel) -> Self {
+        Self {
+            key: val.key.to_string(),
+            provider: val.provider.to_string(),
+            model: val.model.to_string(),
+            mode: val.mode.map(|v| v.to_string()),
+            max_tokens: val.max_tokens,
+            max_input_tokens: val.max_input_tokens,
+            max_output_tokens: val.max_output_tokens,
+            supports_vision: val.supports_vision,
+            supports_function_calling: val.supports_function_calling,
+            supports_reasoning: val.supports_reasoning,
+            supports_structured_output: val.supports_structured_output,
+            supports_audio_input: val.supports_audio_input,
+            supports_audio_output: val.supports_audio_output,
+            supports_prompt_caching: val.supports_prompt_caching,
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 impl From<CatalogRefreshConfig> for liter_llm::CatalogRefreshConfig {
     fn from(val: CatalogRefreshConfig) -> Self {
@@ -15039,6 +15249,7 @@ impl From<ClientOptions> for liter_llm::ClientOptions {
             api_key: val.api_key,
             base_url: val.base_url,
             timeout_secs: val.timeout_secs,
+            connect_timeout_secs: val.connect_timeout_secs,
             max_retries: val.max_retries,
             max_response_bytes: val.max_response_bytes,
             model_hint: val.model_hint,
@@ -15055,6 +15266,7 @@ impl From<liter_llm::ClientOptions> for ClientOptions {
             api_key: val.api_key.to_string(),
             base_url: val.base_url.map(|v| v.to_string()),
             timeout_secs: val.timeout_secs,
+            connect_timeout_secs: val.connect_timeout_secs,
             max_retries: val.max_retries,
             max_response_bytes: val.max_response_bytes,
             model_hint: val.model_hint.map(|v| v.to_string()),
@@ -15130,6 +15342,7 @@ impl From<liter_llm::types::CreateFileRequest> for CreateFileRequest {
 }
 
 #[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure)]
 impl From<CreateImageRequest> for liter_llm::types::CreateImageRequest {
     fn from(val: CreateImageRequest) -> Self {
         Self {
@@ -15141,6 +15354,7 @@ impl From<CreateImageRequest> for liter_llm::types::CreateImageRequest {
             style: val.style,
             response_format: val.response_format,
             user: val.user,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -15158,6 +15372,7 @@ impl From<liter_llm::types::CreateImageRequest> for CreateImageRequest {
             style: val.style.map(|v| v.to_string()),
             response_format: val.response_format.map(|v| v.to_string()),
             user: val.user.map(|v| v.to_string()),
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
@@ -15199,6 +15414,7 @@ impl From<liter_llm::types::CreateResponseRequest> for CreateResponseRequest {
 }
 
 #[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure)]
 impl From<CreateSpeechRequest> for liter_llm::types::CreateSpeechRequest {
     fn from(val: CreateSpeechRequest) -> Self {
         Self {
@@ -15207,6 +15423,7 @@ impl From<CreateSpeechRequest> for liter_llm::types::CreateSpeechRequest {
             voice: val.voice,
             response_format: val.response_format,
             speed: val.speed,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -15221,11 +15438,13 @@ impl From<liter_llm::types::CreateSpeechRequest> for CreateSpeechRequest {
             voice: val.voice.to_string(),
             response_format: val.response_format.map(|v| v.to_string()),
             speed: val.speed,
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
 
 #[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure)]
 impl From<CreateTranscriptionRequest> for liter_llm::types::CreateTranscriptionRequest {
     fn from(val: CreateTranscriptionRequest) -> Self {
         Self {
@@ -15235,6 +15454,7 @@ impl From<CreateTranscriptionRequest> for liter_llm::types::CreateTranscriptionR
             prompt: val.prompt,
             response_format: val.response_format,
             temperature: val.temperature,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -15250,6 +15470,7 @@ impl From<liter_llm::types::CreateTranscriptionRequest> for CreateTranscriptionR
             prompt: val.prompt.map(|v| v.to_string()),
             response_format: val.response_format.map(|v| v.to_string()),
             temperature: val.temperature,
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
@@ -15384,7 +15605,7 @@ impl From<liter_llm::types::EmbeddingObject> for EmbeddingObject {
 }
 
 #[allow(clippy::needless_update)]
-#[allow(clippy::useless_conversion)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<EmbeddingRequest> for liter_llm::types::EmbeddingRequest {
     fn from(val: EmbeddingRequest) -> Self {
         Self {
@@ -15393,6 +15614,7 @@ impl From<EmbeddingRequest> for liter_llm::types::EmbeddingRequest {
             encoding_format: val.encoding_format.map(Into::into),
             dimensions: val.dimensions,
             user: val.user,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -15407,6 +15629,7 @@ impl From<liter_llm::types::EmbeddingRequest> for EmbeddingRequest {
             encoding_format: val.encoding_format.map(Into::into),
             dimensions: val.dimensions,
             user: val.user.map(|v| v.to_string()),
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
@@ -15749,6 +15972,7 @@ impl From<liter_llm::client::LlmConfig> for LlmConfig {
             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,
+            connect_timeout_secs: val.connect_timeout_secs,
             max_retries: val.max_retries,
             temperature: val.temperature,
             max_tokens: val.max_tokens,
@@ -16052,12 +16276,13 @@ impl From<liter_llm::types::ModerationCategoryScores> for ModerationCategoryScor
 }
 
 #[allow(clippy::needless_update)]
-#[allow(clippy::useless_conversion)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ModerationRequest> for liter_llm::types::ModerationRequest {
     fn from(val: ModerationRequest) -> Self {
         Self {
             input: val.input.into(),
             model: val.model,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -16069,6 +16294,7 @@ impl From<liter_llm::types::ModerationRequest> for ModerationRequest {
         Self {
             input: val.input.into(),
             model: val.model.map(|v| v.to_string()),
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
@@ -16169,6 +16395,7 @@ impl From<OcrRequest> for liter_llm::types::OcrRequest {
             document: val.document.into(),
             pages: val.pages.map(|v| v.into_iter().collect()),
             include_image_base64: val.include_image_base64,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -16182,6 +16409,7 @@ impl From<liter_llm::types::OcrRequest> for OcrRequest {
             document: val.document.into(),
             pages: val.pages.map(|v| v.into_iter().collect()),
             include_image_base64: val.include_image_base64,
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
@@ -16337,7 +16565,7 @@ impl From<liter_llm::RateLimitConfig> for RateLimitConfig {
 }
 
 #[allow(clippy::needless_update)]
-#[allow(clippy::useless_conversion)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<RerankRequest> for liter_llm::types::RerankRequest {
     fn from(val: RerankRequest) -> Self {
         Self {
@@ -16346,6 +16574,7 @@ impl From<RerankRequest> for liter_llm::types::RerankRequest {
             documents: val.documents.into_iter().map(Into::into).collect(),
             top_n: val.top_n,
             return_documents: val.return_documents,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -16360,6 +16589,7 @@ impl From<liter_llm::types::RerankRequest> for RerankRequest {
             documents: val.documents.into_iter().map(Into::into).collect(),
             top_n: val.top_n,
             return_documents: val.return_documents,
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
@@ -16528,6 +16758,7 @@ impl From<SearchRequest> for liter_llm::types::SearchRequest {
             max_results: val.max_results,
             search_domain_filter: val.search_domain_filter.map(|v| v.into_iter().collect()),
             country: val.country,
+            extra_body: val.extra_body.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             ..Default::default()
         }
     }
@@ -16542,6 +16773,7 @@ impl From<liter_llm::types::SearchRequest> for SearchRequest {
             max_results: val.max_results,
             search_domain_filter: val.search_domain_filter.map(|v| v.into_iter().collect()),
             country: val.country.map(|v| v.to_string()),
+            extra_body: val.extra_body.as_ref().map(ToString::to_string),
         }
     }
 }
@@ -17400,6 +17632,7 @@ impl From<ReasoningEffort> for liter_llm::types::ReasoningEffort {
             ReasoningEffort::High => Self::High,
             ReasoningEffort::Minimal => Self::Minimal,
             ReasoningEffort::Max => Self::Max,
+            ReasoningEffort::None => Self::None,
         }
     }
 }
@@ -17412,6 +17645,7 @@ impl From<liter_llm::types::ReasoningEffort> for ReasoningEffort {
             liter_llm::types::ReasoningEffort::High => Self::High,
             liter_llm::types::ReasoningEffort::Minimal => Self::Minimal,
             liter_llm::types::ReasoningEffort::Max => Self::Max,
+            liter_llm::types::ReasoningEffort::None => Self::None,
         }
     }
 }
@@ -17501,6 +17735,7 @@ impl From<liter_llm::provider::StreamFormat> for StreamFormat {
         match val {
             liter_llm::provider::StreamFormat::Sse => Self::Sse,
             liter_llm::provider::StreamFormat::AwsEventStream => Self::AwsEventStream,
+            liter_llm::provider::StreamFormat::Ndjson => Self::Ndjson,
         }
     }
 }
@@ -17577,18 +17812,99 @@ impl From<liter_llm::types::UserContent> for UserContent {
     }
 }
 
-/// Convert a `liter_llm::CatalogRefreshError` error to a Magnus runtime error.
+/// Convert the error a core call returned into the typed Ruby exception of its family. An error
+/// of a type with no converter becomes a `RuntimeError` with the message.
+#[allow(dead_code)]
+fn alef_magnus_err<E: std::fmt::Display + 'static>(e: E) -> magnus::Error {
+    let message = e.to_string();
+    #[allow(unused_variables)]
+    let any: Box<dyn std::any::Any> = Box::new(e);
+    let any = match any.downcast::<liter_llm::CatalogRefreshError>() {
+        Ok(typed) => return catalog_refresh_error_to_magnus_err(*typed),
+        Err(any) => any,
+    };
+    let any = match any.downcast::<liter_llm::LiterLlmError>() {
+        Ok(typed) => return liter_llm_error_to_magnus_err(*typed),
+        Err(any) => any,
+    };
+    let _ = any;
+    magnus::Error::new(
+        unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(),
+        message,
+    )
+}
+
+/// Convert a `liter_llm::CatalogRefreshError` error to a typed Ruby exception.
 #[allow(dead_code)]
 fn catalog_refresh_error_to_magnus_err(e: liter_llm::CatalogRefreshError) -> magnus::Error {
-    let msg = e.to_string();
-    magnus::Error::new(unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(), msg)
+    use magnus::prelude::*;
+    let message = e.to_string();
+    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+    #[allow(unreachable_patterns)]
+    let class_name = match &e {
+        liter_llm::CatalogRefreshError::Disabled => "DisabledError",
+        liter_llm::CatalogRefreshError::InsecureUrl { .. } => "InsecureUrlError",
+        liter_llm::CatalogRefreshError::Fetch { .. } => "FetchError",
+        liter_llm::CatalogRefreshError::Parse { .. } => "ParseError",
+        liter_llm::CatalogRefreshError::Cache { .. } => "CacheError",
+        liter_llm::CatalogRefreshError::Integrity { .. } => "IntegrityError",
+        _ => "CatalogRefreshError",
+    };
+    let build = || -> Result<magnus::Error, magnus::Error> {
+        let module = ruby.define_module("LiterLlm")?;
+        let class: magnus::ExceptionClass = module.const_get(class_name)?;
+        let exception = class.new_instance((message.as_str(),))?;
+        Ok(magnus::Error::from(exception))
+    };
+    build().unwrap_or_else(|_| magnus::Error::new(ruby.exception_runtime_error(), message))
 }
 
-/// Convert a `liter_llm::LiterLlmError` error to a Magnus runtime error.
+/// Convert a `liter_llm::LiterLlmError` error to a typed Ruby exception.
 #[allow(dead_code)]
 fn liter_llm_error_to_magnus_err(e: liter_llm::LiterLlmError) -> magnus::Error {
-    let msg = e.to_string();
-    magnus::Error::new(unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(), msg)
+    use magnus::prelude::*;
+    let message = e.to_string();
+    let ruby = unsafe { magnus::Ruby::get_unchecked() };
+    #[allow(unreachable_patterns)]
+    let class_name = match &e {
+        liter_llm::LiterLlmError::Authentication { .. } => "AuthenticationError",
+        liter_llm::LiterLlmError::RateLimited { .. } => "RateLimitedError",
+        liter_llm::LiterLlmError::BadRequest { .. } => "BadRequestError",
+        liter_llm::LiterLlmError::ContextWindowExceeded { .. } => "ContextWindowExceededError",
+        liter_llm::LiterLlmError::ContentPolicy { .. } => "ContentPolicyError",
+        liter_llm::LiterLlmError::NotFound { .. } => "NotFoundError",
+        liter_llm::LiterLlmError::ServerError { .. } => "ServerError",
+        liter_llm::LiterLlmError::ServiceUnavailable { .. } => "ServiceUnavailableError",
+        liter_llm::LiterLlmError::Timeout => "LiterLlmTimeoutError",
+        liter_llm::LiterLlmError::Network { .. } => "NetworkError",
+        liter_llm::LiterLlmError::Streaming { .. } => "StreamingError",
+        liter_llm::LiterLlmError::EndpointNotSupported { .. } => "EndpointNotSupportedError",
+        liter_llm::LiterLlmError::InvalidHeader { .. } => "InvalidHeaderError",
+        liter_llm::LiterLlmError::Serialization(..) => "SerializationError",
+        liter_llm::LiterLlmError::BudgetExceeded { .. } => "BudgetExceededError",
+        liter_llm::LiterLlmError::HookRejected { .. } => "HookRejectedError",
+        liter_llm::LiterLlmError::InternalError { .. } => "InternalError",
+        liter_llm::LiterLlmError::OutboundForbidden { .. } => "OutboundForbiddenError",
+        liter_llm::LiterLlmError::IdempotencyConflict { .. } => "IdempotencyConflictError",
+        liter_llm::LiterLlmError::IdempotencyInFlight { .. } => "IdempotencyInFlightError",
+        liter_llm::LiterLlmError::ProviderQuotaExceeded { .. } => "ProviderQuotaExceededError",
+        _ => "LiterLlmError",
+    };
+    let build = || -> Result<magnus::Error, magnus::Error> {
+        let module = ruby.define_module("LiterLlm")?;
+        let class: magnus::ExceptionClass = module.const_get(class_name)?;
+        let exception = class.new_instance((message.as_str(),))?;
+        exception.funcall::<_, _, magnus::Value>("instance_variable_set", ("@status_code", e.status_code()))?;
+        exception.funcall::<_, _, magnus::Value>(
+            "instance_variable_set",
+            ("@retry_after", e.retry_after().map(|d| d.as_millis() as i64)),
+        )?;
+        exception.funcall::<_, _, magnus::Value>("instance_variable_set", ("@is_transient", e.is_transient()))?;
+        exception
+            .funcall::<_, _, magnus::Value>("instance_variable_set", ("@error_type", e.error_type().to_string()))?;
+        Ok(magnus::Error::from(exception))
+    };
+    build().unwrap_or_else(|_| magnus::Error::new(ruby.exception_runtime_error(), message))
 }
 
 #[magnus::wrap(class = "LiterLlmErrorInfo", free_immediately, size)]
@@ -17679,7 +17995,7 @@ impl ChatStreamIterator {
                 let binding: ChatCompletionChunk = chunk.into();
                 Ok(binding.into_value_with(&ruby))
             }
-            Some(Err(e)) => Err(Error::new(ruby.exception_runtime_error(), e.to_string())),
+            Some(Err(e)) => Err(alef_magnus_err(e)),
             None => {
                 // Drop the stream to release any resources.
                 let inner = self.inner.clone();
@@ -17887,6 +18203,47 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("origin", method!(CatalogInfo::origin, 0))?;
 
+    let class = module.define_class("CatalogModel", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(CatalogModel::new, -1))?;
+
+    class.define_method("key", method!(CatalogModel::key, 0))?;
+
+    class.define_method("provider", method!(CatalogModel::provider, 0))?;
+
+    class.define_method("model", method!(CatalogModel::model, 0))?;
+
+    class.define_method("mode", method!(CatalogModel::mode, 0))?;
+
+    class.define_method("max_tokens", method!(CatalogModel::max_tokens, 0))?;
+
+    class.define_method("max_input_tokens", method!(CatalogModel::max_input_tokens, 0))?;
+
+    class.define_method("max_output_tokens", method!(CatalogModel::max_output_tokens, 0))?;
+
+    class.define_method("supports_vision", method!(CatalogModel::supports_vision, 0))?;
+
+    class.define_method(
+        "supports_function_calling",
+        method!(CatalogModel::supports_function_calling, 0),
+    )?;
+
+    class.define_method("supports_reasoning", method!(CatalogModel::supports_reasoning, 0))?;
+
+    class.define_method(
+        "supports_structured_output",
+        method!(CatalogModel::supports_structured_output, 0),
+    )?;
+
+    class.define_method("supports_audio_input", method!(CatalogModel::supports_audio_input, 0))?;
+
+    class.define_method("supports_audio_output", method!(CatalogModel::supports_audio_output, 0))?;
+
+    class.define_method(
+        "supports_prompt_caching",
+        method!(CatalogModel::supports_prompt_caching, 0),
+    )?;
+
     let class = module.define_class("CatalogRefreshConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(CatalogRefreshConfig::new, -1))?;
@@ -18055,6 +18412,9 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     #[cfg(any(feature = "native-http", feature = "wasm-http"))]
     class.define_method("timeout_secs", method!(ClientOptions::timeout_secs, 0))?;
 
+    #[cfg(any(feature = "native-http", feature = "wasm-http"))]
+    class.define_method("connect_timeout_secs", method!(ClientOptions::connect_timeout_secs, 0))?;
+
     #[cfg(any(feature = "native-http", feature = "wasm-http"))]
     class.define_method("max_retries", method!(ClientOptions::max_retries, 0))?;
 
@@ -18115,6 +18475,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("user", method!(CreateImageRequest::user, 0))?;
 
+    class.define_method("extra_body", method!(CreateImageRequest::extra_body, 0))?;
+
     let class = module.define_class("CreateResponseRequest", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(CreateResponseRequest::new, -1))?;
@@ -18154,6 +18516,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("speed", method!(CreateSpeechRequest::speed, 0))?;
 
+    class.define_method("extra_body", method!(CreateSpeechRequest::extra_body, 0))?;
+
     let class = module.define_class("CreateTranscriptionRequest", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(CreateTranscriptionRequest::new, -1))?;
@@ -18173,6 +18537,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("temperature", method!(CreateTranscriptionRequest::temperature, 0))?;
 
+    class.define_method("extra_body", method!(CreateTranscriptionRequest::extra_body, 0))?;
+
     let class = module.define_class("CustomProviderConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(CustomProviderConfig::new, -1))?;
@@ -18333,6 +18699,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("user", method!(EmbeddingRequest::user, 0))?;
 
+    class.define_method("extra_body", method!(EmbeddingRequest::extra_body, 0))?;
+
     let class = module.define_class("EmbeddingResponse", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(EmbeddingResponse::new, -1))?;
@@ -18507,6 +18875,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("timeout_secs", method!(LlmConfig::timeout_secs, 0))?;
 
+    class.define_method("connect_timeout_secs", method!(LlmConfig::connect_timeout_secs, 0))?;
+
     class.define_method("max_retries", method!(LlmConfig::max_retries, 0))?;
 
     class.define_method("temperature", method!(LlmConfig::temperature, 0))?;
@@ -18773,6 +19143,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("model", method!(ModerationRequest::model, 0))?;
 
+    class.define_method("extra_body", method!(ModerationRequest::extra_body, 0))?;
+
     let class = module.define_class("ModerationResponse", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ModerationResponse::new, -1))?;
@@ -18825,6 +19197,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("include_image_base64", method!(OcrRequest::include_image_base64, 0))?;
 
+    class.define_method("extra_body", method!(OcrRequest::extra_body, 0))?;
+
     let class = module.define_class("OcrResponse", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(OcrResponse::new, -1))?;
@@ -18920,6 +19294,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("return_documents", method!(RerankRequest::return_documents, 0))?;
 
+    class.define_method("extra_body", method!(RerankRequest::extra_body, 0))?;
+
     let class = module.define_class("RerankResponse", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(RerankResponse::new, -1))?;
@@ -19006,6 +19382,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("country", method!(SearchRequest::country, 0))?;
 
+    class.define_method("extra_body", method!(SearchRequest::extra_body, 0))?;
+
     let class = module.define_class("SearchResponse", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(SearchResponse::new, -1))?;
@@ -19263,6 +19641,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         function!(install_catalog_overlay_from_str, 1),
     )?;
 
+    module.define_module_function("list_catalog_models", function!(list_catalog_models, -1))?;
+
     module.define_module_function("model_info", function!(model_info, 1))?;
 
     #[cfg(feature = "tower")]
@@ -19276,6 +19656,147 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("chat_stream", function!(chat_stream, 2))?;
 
+    let catalog_refresh_error_class = module.define_error("CatalogRefreshError", ruby.exception_standard_error())?;
+    let disabled_error_class = module.define_error("DisabledError", catalog_refresh_error_class)?;
+    let insecure_url_error_class = module.define_error("InsecureUrlError", catalog_refresh_error_class)?;
+    let fetch_error_class = module.define_error("FetchError", catalog_refresh_error_class)?;
+    let parse_error_class = module.define_error("ParseError", catalog_refresh_error_class)?;
+    let cache_error_class = module.define_error("CacheError", catalog_refresh_error_class)?;
+    let integrity_error_class = module.define_error("IntegrityError", catalog_refresh_error_class)?;
+    let liter_llm_error_class = module.define_error("LiterLlmError", ruby.exception_standard_error())?;
+    liter_llm_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    liter_llm_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    liter_llm_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    liter_llm_error_class.define_alias("transient?", "is_transient")?;
+    liter_llm_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let authentication_error_class = module.define_error("AuthenticationError", liter_llm_error_class)?;
+    authentication_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    authentication_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    authentication_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    authentication_error_class.define_alias("transient?", "is_transient")?;
+    authentication_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let rate_limited_error_class = module.define_error("RateLimitedError", liter_llm_error_class)?;
+    rate_limited_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    rate_limited_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    rate_limited_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    rate_limited_error_class.define_alias("transient?", "is_transient")?;
+    rate_limited_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let bad_request_error_class = module.define_error("BadRequestError", liter_llm_error_class)?;
+    bad_request_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    bad_request_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    bad_request_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    bad_request_error_class.define_alias("transient?", "is_transient")?;
+    bad_request_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let context_window_exceeded_error_class =
+        module.define_error("ContextWindowExceededError", liter_llm_error_class)?;
+    context_window_exceeded_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    context_window_exceeded_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    context_window_exceeded_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    context_window_exceeded_error_class.define_alias("transient?", "is_transient")?;
+    context_window_exceeded_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let content_policy_error_class = module.define_error("ContentPolicyError", liter_llm_error_class)?;
+    content_policy_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    content_policy_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    content_policy_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    content_policy_error_class.define_alias("transient?", "is_transient")?;
+    content_policy_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let not_found_error_class = module.define_error("NotFoundError", liter_llm_error_class)?;
+    not_found_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    not_found_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    not_found_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    not_found_error_class.define_alias("transient?", "is_transient")?;
+    not_found_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let server_error_class = module.define_error("ServerError", liter_llm_error_class)?;
+    server_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    server_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    server_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    server_error_class.define_alias("transient?", "is_transient")?;
+    server_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let service_unavailable_error_class = module.define_error("ServiceUnavailableError", liter_llm_error_class)?;
+    service_unavailable_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    service_unavailable_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    service_unavailable_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    service_unavailable_error_class.define_alias("transient?", "is_transient")?;
+    service_unavailable_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let liter_llm_timeout_error_class = module.define_error("LiterLlmTimeoutError", liter_llm_error_class)?;
+    liter_llm_timeout_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    liter_llm_timeout_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    liter_llm_timeout_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    liter_llm_timeout_error_class.define_alias("transient?", "is_transient")?;
+    liter_llm_timeout_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let network_error_class = module.define_error("NetworkError", liter_llm_error_class)?;
+    network_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    network_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    network_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    network_error_class.define_alias("transient?", "is_transient")?;
+    network_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let streaming_error_class = module.define_error("StreamingError", liter_llm_error_class)?;
+    streaming_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    streaming_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    streaming_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    streaming_error_class.define_alias("transient?", "is_transient")?;
+    streaming_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let endpoint_not_supported_error_class = module.define_error("EndpointNotSupportedError", liter_llm_error_class)?;
+    endpoint_not_supported_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    endpoint_not_supported_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    endpoint_not_supported_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    endpoint_not_supported_error_class.define_alias("transient?", "is_transient")?;
+    endpoint_not_supported_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let invalid_header_error_class = module.define_error("InvalidHeaderError", liter_llm_error_class)?;
+    invalid_header_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    invalid_header_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    invalid_header_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    invalid_header_error_class.define_alias("transient?", "is_transient")?;
+    invalid_header_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let serialization_error_class = module.define_error("SerializationError", liter_llm_error_class)?;
+    serialization_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    serialization_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    serialization_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    serialization_error_class.define_alias("transient?", "is_transient")?;
+    serialization_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let budget_exceeded_error_class = module.define_error("BudgetExceededError", liter_llm_error_class)?;
+    budget_exceeded_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    budget_exceeded_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    budget_exceeded_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    budget_exceeded_error_class.define_alias("transient?", "is_transient")?;
+    budget_exceeded_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let hook_rejected_error_class = module.define_error("HookRejectedError", liter_llm_error_class)?;
+    hook_rejected_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    hook_rejected_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    hook_rejected_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    hook_rejected_error_class.define_alias("transient?", "is_transient")?;
+    hook_rejected_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let internal_error_class = module.define_error("InternalError", liter_llm_error_class)?;
+    internal_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    internal_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    internal_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    internal_error_class.define_alias("transient?", "is_transient")?;
+    internal_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let outbound_forbidden_error_class = module.define_error("OutboundForbiddenError", liter_llm_error_class)?;
+    outbound_forbidden_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    outbound_forbidden_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    outbound_forbidden_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    outbound_forbidden_error_class.define_alias("transient?", "is_transient")?;
+    outbound_forbidden_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let idempotency_conflict_error_class = module.define_error("IdempotencyConflictError", liter_llm_error_class)?;
+    idempotency_conflict_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    idempotency_conflict_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    idempotency_conflict_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    idempotency_conflict_error_class.define_alias("transient?", "is_transient")?;
+    idempotency_conflict_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let idempotency_in_flight_error_class = module.define_error("IdempotencyInFlightError", liter_llm_error_class)?;
+    idempotency_in_flight_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    idempotency_in_flight_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    idempotency_in_flight_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    idempotency_in_flight_error_class.define_alias("transient?", "is_transient")?;
+    idempotency_in_flight_error_class.define_attr("error_type", magnus::Attr::Read)?;
+    let provider_quota_exceeded_error_class =
+        module.define_error("ProviderQuotaExceededError", liter_llm_error_class)?;
+    provider_quota_exceeded_error_class.define_attr("status_code", magnus::Attr::Read)?;
+    provider_quota_exceeded_error_class.define_attr("retry_after", magnus::Attr::Read)?;
+    provider_quota_exceeded_error_class.define_attr("is_transient", magnus::Attr::Read)?;
+    provider_quota_exceeded_error_class.define_alias("transient?", "is_transient")?;
+    provider_quota_exceeded_error_class.define_attr("error_type", magnus::Attr::Read)?;
     let liter_llm_error_info_class = module.define_class("LiterLlmErrorInfo", ruby.class_object())?;
     liter_llm_error_info_class.define_method("status_code", magnus::method!(LiterLlmErrorInfo::status_code, 0))?;
     liter_llm_error_info_class.define_method("retry_after", magnus::method!(LiterLlmErrorInfo::retry_after, 0))?;