liter_llm 2.0.2 → 2.1.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:6423443d8189e0b67fd55f0b3e0fad7fdb360e3c24a0f3334fd01896befda4b5
+// alef:hash:c38ee16af03a7f5880934b3b89c3209a36af80d907b6491debc2153c4df4d7bf
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -4724,7 +4724,12 @@ impl EmbeddingRequest {
                         format!("invalid value for `input`: {}", e),
                     )
                 })?,
-                None => Default::default(),
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: input",
+                    ));
+                }
             },
             encoding_format: match kwargs.get(ruby.to_symbol("encoding_format")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(EmbeddingFormat::try_convert(v).map_err(|e| {
@@ -8135,7 +8140,12 @@ impl ModerationRequest {
                         format!("invalid value for `input`: {}", e),
                     )
                 })?,
-                None => Default::default(),
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: input",
+                    ));
+                }
             },
             model: match kwargs.get(ruby.to_symbol("model")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(String::try_convert(v).map_err(|e| {
@@ -8623,7 +8633,12 @@ impl OcrRequest {
                         format!("invalid value for `document`: {}", e),
                     )
                 })?,
-                None => Default::default(),
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: document",
+                    ));
+                }
             },
             pages: match kwargs.get(ruby.to_symbol("pages")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(<Vec<u32>>::try_convert(v).map_err(|e| {
@@ -11227,7 +11242,12 @@ impl SystemMessage {
                         format!("invalid value for `content`: {}", e),
                     )
                 })?,
-                None => Default::default(),
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: content",
+                    ));
+                }
             },
             name: match kwargs.get(ruby.to_symbol("name")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(String::try_convert(v).map_err(|e| {
@@ -11412,7 +11432,12 @@ impl ToolMessage {
                         format!("invalid value for `content`: {}", e),
                     )
                 })?,
-                None => Default::default(),
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: content",
+                    ));
+                }
             },
             tool_call_id: match kwargs.get(ruby.to_symbol("tool_call_id")) {
                 Some(v) => String::try_convert(v).map_err(|e| {
@@ -11852,7 +11877,12 @@ impl UserMessage {
                         format!("invalid value for `content`: {}", e),
                     )
                 })?,
-                None => Default::default(),
+                None => {
+                    return Err(magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
+                        "missing required field: content",
+                    ));
+                }
             },
             name: match kwargs.get(ruby.to_symbol("name")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(String::try_convert(v).map_err(|e| {
@@ -11995,12 +12025,6 @@ pub enum AssistantContent {
     Parts(Vec<AssistantPart>),
 }
 
-impl Default for AssistantContent {
-    fn default() -> Self {
-        Self::Text(Default::default())
-    }
-}
-
 impl magnus::IntoValue for AssistantContent {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -12054,14 +12078,6 @@ pub enum AssistantPart {
     OutputAudio { audio: AudioContent },
 }
 
-impl Default for AssistantPart {
-    fn default() -> Self {
-        Self::Text {
-            text: Default::default(),
-        }
-    }
-}
-
 impl magnus::IntoValue for AssistantPart {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -12073,7 +12089,8 @@ impl magnus::IntoValue for AssistantPart {
 
 impl magnus::TryConvert for AssistantPart {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -12105,12 +12122,13 @@ impl magnus::TryConvert for AssistantPart {
 
 unsafe impl IntoValueFromNative for AssistantPart {}
 unsafe impl TryConvertOwned for AssistantPart {}
+
 impl AssistantPart {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum AuthHeaderFormat {
     Bearer,
-    ApiKey { _0: String },
+    ApiKey(String),
     None,
 }
 
@@ -12163,7 +12181,7 @@ impl magnus::TryConvert for AuthHeaderFormat {
 unsafe impl IntoValueFromNative for AuthHeaderFormat {}
 unsafe impl TryConvertOwned for AuthHeaderFormat {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum AuthType {
     Bearer,
@@ -12192,7 +12210,14 @@ impl magnus::IntoValue for AuthType {
 
 impl magnus::TryConvert for AuthType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12212,7 +12237,7 @@ impl magnus::TryConvert for AuthType {
 unsafe impl IntoValueFromNative for AuthType {}
 unsafe impl TryConvertOwned for AuthType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum BatchStatus {
     Validating,
@@ -12249,7 +12274,14 @@ impl magnus::IntoValue for BatchStatus {
 
 impl magnus::TryConvert for BatchStatus {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12298,7 +12330,8 @@ impl magnus::IntoValue for CacheBackend {
 
 impl magnus::TryConvert for CacheBackend {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -12330,9 +12363,10 @@ impl magnus::TryConvert for CacheBackend {
 
 unsafe impl IntoValueFromNative for CacheBackend {}
 unsafe impl TryConvertOwned for CacheBackend {}
+
 impl CacheBackend {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum CircuitState {
     Closed,
     Open,
@@ -12358,7 +12392,14 @@ impl magnus::IntoValue for CircuitState {
 
 impl magnus::TryConvert for CircuitState {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12390,14 +12431,6 @@ pub enum ContentPart {
     InputAudio { input_audio: AudioContent },
 }
 
-impl Default for ContentPart {
-    fn default() -> Self {
-        Self::Text {
-            text: Default::default(),
-        }
-    }
-}
-
 impl magnus::IntoValue for ContentPart {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -12409,7 +12442,8 @@ impl magnus::IntoValue for ContentPart {
 
 impl magnus::TryConvert for ContentPart {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -12441,6 +12475,7 @@ impl magnus::TryConvert for ContentPart {
 
 unsafe impl IntoValueFromNative for ContentPart {}
 unsafe impl TryConvertOwned for ContentPart {}
+
 impl ContentPart {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -12454,14 +12489,6 @@ pub enum EmbeddingContentPart {
     ImageBase64 { image_base64: String },
 }
 
-impl Default for EmbeddingContentPart {
-    fn default() -> Self {
-        Self::Text {
-            text: Default::default(),
-        }
-    }
-}
-
 impl magnus::IntoValue for EmbeddingContentPart {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -12473,7 +12500,8 @@ impl magnus::IntoValue for EmbeddingContentPart {
 
 impl magnus::TryConvert for EmbeddingContentPart {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -12505,9 +12533,10 @@ impl magnus::TryConvert for EmbeddingContentPart {
 
 unsafe impl IntoValueFromNative for EmbeddingContentPart {}
 unsafe impl TryConvertOwned for EmbeddingContentPart {}
+
 impl EmbeddingContentPart {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum EmbeddingFormat {
     Float,
@@ -12532,7 +12561,14 @@ impl magnus::IntoValue for EmbeddingFormat {
 
 impl magnus::TryConvert for EmbeddingFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12558,12 +12594,6 @@ pub enum EmbeddingInput {
     Multimodal(Vec<EmbeddingContentPart>),
 }
 
-impl Default for EmbeddingInput {
-    fn default() -> Self {
-        Self::Single(Default::default())
-    }
-}
-
 impl magnus::IntoValue for EmbeddingInput {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -12607,7 +12637,7 @@ impl magnus::TryConvert for EmbeddingInput {
 unsafe impl IntoValueFromNative for EmbeddingInput {}
 unsafe impl TryConvertOwned for EmbeddingInput {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum Enforcement {
     Hard,
     Soft,
@@ -12631,7 +12661,14 @@ impl magnus::IntoValue for Enforcement {
 
 impl magnus::TryConvert for Enforcement {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12649,7 +12686,7 @@ impl magnus::TryConvert for Enforcement {
 unsafe impl IntoValueFromNative for Enforcement {}
 unsafe impl TryConvertOwned for Enforcement {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum FilePurpose {
     Assistants,
@@ -12678,7 +12715,14 @@ impl magnus::IntoValue for FilePurpose {
 
 impl magnus::TryConvert for FilePurpose {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12698,7 +12742,7 @@ impl magnus::TryConvert for FilePurpose {
 unsafe impl IntoValueFromNative for FilePurpose {}
 unsafe impl TryConvertOwned for FilePurpose {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum FinishReason {
     Stop,
@@ -12732,7 +12776,14 @@ impl magnus::IntoValue for FinishReason {
 
 impl magnus::TryConvert for FinishReason {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12754,7 +12805,7 @@ impl magnus::TryConvert for FinishReason {
 unsafe impl IntoValueFromNative for FinishReason {}
 unsafe impl TryConvertOwned for FinishReason {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum HealthStatus {
     Healthy,
     Unhealthy,
@@ -12778,7 +12829,14 @@ impl magnus::IntoValue for HealthStatus {
 
 impl magnus::TryConvert for HealthStatus {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12796,7 +12854,7 @@ impl magnus::TryConvert for HealthStatus {
 unsafe impl IntoValueFromNative for HealthStatus {}
 unsafe impl TryConvertOwned for HealthStatus {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ImageDetail {
     Low,
@@ -12823,7 +12881,14 @@ impl magnus::IntoValue for ImageDetail {
 
 impl magnus::TryConvert for ImageDetail {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -12877,12 +12942,6 @@ pub enum Message {
     },
 }
 
-impl Default for Message {
-    fn default() -> Self {
-        Self::System { _0: Default::default() }
-    }
-}
-
 impl magnus::IntoValue for Message {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -12894,7 +12953,32 @@ impl magnus::IntoValue for Message {
 
 impl magnus::TryConvert for Message {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?;
+        if class_name.as_deref() == Some("LiterLlm::MessageSystem") {
+            let payload: SystemMessage = val.funcall("value", ())?;
+            return Ok(Self::System { _0: payload });
+        }
+        if class_name.as_deref() == Some("LiterLlm::MessageUser") {
+            let payload: UserMessage = val.funcall("value", ())?;
+            return Ok(Self::User { _0: payload });
+        }
+        if class_name.as_deref() == Some("LiterLlm::MessageAssistant") {
+            let payload: AssistantMessage = val.funcall("value", ())?;
+            return Ok(Self::Assistant { _0: payload });
+        }
+        if class_name.as_deref() == Some("LiterLlm::MessageTool") {
+            let payload: ToolMessage = val.funcall("value", ())?;
+            return Ok(Self::Tool { _0: payload });
+        }
+        if class_name.as_deref() == Some("LiterLlm::MessageDeveloper") {
+            let payload: DeveloperMessage = val.funcall("value", ())?;
+            return Ok(Self::Developer { _0: payload });
+        }
+        if class_name.as_deref() == Some("LiterLlm::MessageFunction") {
+            let payload: FunctionMessage = val.funcall("value", ())?;
+            return Ok(Self::Function { _0: payload });
+        } // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -12926,6 +13010,7 @@ impl magnus::TryConvert for Message {
 
 unsafe impl IntoValueFromNative for Message {}
 unsafe impl TryConvertOwned for Message {}
+
 impl Message {
     pub fn system(&self) -> Option<&SystemMessage> {
         match self {
@@ -12965,7 +13050,7 @@ impl Message {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum Modality {
     Text,
@@ -12992,7 +13077,14 @@ impl magnus::IntoValue for Modality {
 
 impl magnus::TryConvert for Modality {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -13018,12 +13110,6 @@ pub enum ModerationInput {
     Multiple(Vec<String>),
 }
 
-impl Default for ModerationInput {
-    fn default() -> Self {
-        Self::Single(Default::default())
-    }
-}
-
 impl magnus::IntoValue for ModerationInput {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -13076,14 +13162,6 @@ pub enum OcrDocument {
     Base64 { data: String, media_type: String },
 }
 
-impl Default for OcrDocument {
-    fn default() -> Self {
-        Self::Url {
-            url: Default::default(),
-        }
-    }
-}
-
 impl magnus::IntoValue for OcrDocument {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -13095,7 +13173,8 @@ impl magnus::IntoValue for OcrDocument {
 
 impl magnus::TryConvert for OcrDocument {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -13127,9 +13206,10 @@ impl magnus::TryConvert for OcrDocument {
 
 unsafe impl IntoValueFromNative for OcrDocument {}
 unsafe impl TryConvertOwned for OcrDocument {}
+
 impl OcrDocument {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ReasoningEffort {
     Low,
@@ -13160,7 +13240,14 @@ impl magnus::IntoValue for ReasoningEffort {
 
 impl magnus::TryConvert for ReasoningEffort {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -13181,7 +13268,7 @@ impl magnus::TryConvert for ReasoningEffort {
 unsafe impl IntoValueFromNative for ReasoningEffort {}
 unsafe impl TryConvertOwned for ReasoningEffort {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum RefreshOutcome {
     Disabled,
     FromCache,
@@ -13207,7 +13294,14 @@ impl magnus::IntoValue for RefreshOutcome {
 
 impl magnus::TryConvert for RefreshOutcome {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -13233,12 +13327,6 @@ pub enum RerankDocument {
     Object { text: String },
 }
 
-impl Default for RerankDocument {
-    fn default() -> Self {
-        Self::Text(Default::default())
-    }
-}
-
 impl magnus::IntoValue for RerankDocument {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -13316,7 +13404,8 @@ impl magnus::IntoValue for ResponseFormat {
 
 impl magnus::TryConvert for ResponseFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -13348,6 +13437,7 @@ impl magnus::TryConvert for ResponseFormat {
 
 unsafe impl IntoValueFromNative for ResponseFormat {}
 unsafe impl TryConvertOwned for ResponseFormat {}
+
 impl ResponseFormat {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -13357,12 +13447,6 @@ pub enum StopSequence {
     Multiple(Vec<String>),
 }
 
-impl Default for StopSequence {
-    fn default() -> Self {
-        Self::Single(Default::default())
-    }
-}
-
 impl magnus::IntoValue for StopSequence {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -13406,7 +13490,7 @@ impl magnus::TryConvert for StopSequence {
 unsafe impl IntoValueFromNative for StopSequence {}
 unsafe impl TryConvertOwned for StopSequence {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum StreamFormat {
     Sse,
@@ -13431,7 +13515,14 @@ impl magnus::IntoValue for StreamFormat {
 
 impl magnus::TryConvert for StreamFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -13450,62 +13541,44 @@ unsafe impl IntoValueFromNative for StreamFormat {}
 unsafe impl TryConvertOwned for StreamFormat {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "LiterLlm::ToolChoice")]
 #[serde(untagged)]
 pub enum ToolChoice {
     Mode(ToolChoiceMode),
     Specific(SpecificToolChoice),
 }
 
-impl Default for ToolChoice {
-    fn default() -> Self {
-        Self::Mode(Default::default())
-    }
-}
-
-impl magnus::IntoValue for ToolChoice {
-    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
-        match serde_json::to_value(&self) {
-            Ok(v) => json_to_ruby(handle, v),
-            Err(_) => handle.qnil().into_value_with(handle),
-        }
-    }
-}
-
 impl magnus::TryConvert for ToolChoice {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
-        // For unit enums or when passed as a string, fall back to string-based conversion.
-        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
-            s
-        } else {
-            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
-                magnus::Error::new(
-                    unsafe { Ruby::get_unchecked() }.exception_type_error(),
-                    format!("no implicit conversion into ToolChoice: {}", e),
-                )
-            })?
-        };
-        // Try deserializing as JSON first (handles JSON strings like "\"markdown\"" or "{\"click\":{\"selector\":\"...\"}}\"")
-        // For internally-tagged enums, a bare variant string is wrapped as {"<tag>": value}.
-        // If that fails, try treating it as a plain string value and wrap in quotes
-        // If both fail, try as Custom variant (for untagged enum support)
-        serde_json::from_str(&json_str)
-            .or_else(|_| serde_json::from_str(&format!("\"{json_str}\"")))
-            .or_else(|_| {
-                // Try as a JSON string for Custom variant (untagged enums accept any remaining value)
-                match serde_json::to_value(&json_str) {
-                    Ok(val) => serde_json::from_value(val),
-                    Err(e) => Err(e),
-                }
-            })
-            .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
+        <&Self as magnus::TryConvert>::try_convert(val).cloned()
     }
 }
 
 unsafe impl IntoValueFromNative for ToolChoice {}
 unsafe impl TryConvertOwned for ToolChoice {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+impl ToolChoice {
+    pub fn from_mode(value: ToolChoiceMode) -> Self {
+        Self::Mode(value)
+    }
+    pub fn mode(&self) -> Option<ToolChoiceMode> {
+        match self {
+            Self::Mode(value) => Some(value.clone()),
+            _ => None,
+        }
+    }
+    pub fn from_specific(value: SpecificToolChoice) -> Self {
+        Self::Specific(value)
+    }
+    pub fn specific(&self) -> Option<SpecificToolChoice> {
+        match self {
+            Self::Specific(value) => Some(value.clone()),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ToolChoiceMode {
     Auto,
@@ -13532,7 +13605,14 @@ impl magnus::IntoValue for ToolChoiceMode {
 
 impl magnus::TryConvert for ToolChoiceMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -13551,7 +13631,7 @@ impl magnus::TryConvert for ToolChoiceMode {
 unsafe impl IntoValueFromNative for ToolChoiceMode {}
 unsafe impl TryConvertOwned for ToolChoiceMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ToolType {
     #[serde(rename = "function")]
     Function,
@@ -13574,7 +13654,14 @@ impl magnus::IntoValue for ToolType {
 
 impl magnus::TryConvert for ToolType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -13598,12 +13685,6 @@ pub enum UserContent {
     Parts(Vec<ContentPart>),
 }
 
-impl Default for UserContent {
-    fn default() -> Self {
-        Self::Text(Default::default())
-    }
-}
-
 impl magnus::IntoValue for UserContent {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -14221,6 +14302,24 @@ impl From<liter_llm::cost::refresh::CatalogRefreshConfig> for CatalogRefreshConf
     }
 }
 
+#[allow(clippy::needless_update)]
+#[allow(clippy::useless_conversion)]
+impl From<ChatCompletionChunk> for liter_llm::types::ChatCompletionChunk {
+    fn from(val: ChatCompletionChunk) -> Self {
+        Self {
+            id: val.id,
+            object: val.object,
+            created: val.created,
+            model: val.model,
+            choices: val.choices.into_iter().map(Into::into).collect(),
+            usage: val.usage.map(Into::into),
+            system_fingerprint: val.system_fingerprint,
+            service_tier: val.service_tier,
+            ..Default::default()
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<liter_llm::types::ChatCompletionChunk> for ChatCompletionChunk {
     fn from(val: liter_llm::types::ChatCompletionChunk) -> Self {
@@ -15943,6 +16042,19 @@ impl From<liter_llm::types::SpecificToolChoice> for SpecificToolChoice {
     }
 }
 
+#[allow(clippy::needless_update)]
+#[allow(clippy::useless_conversion)]
+impl From<StreamChoice> for liter_llm::types::StreamChoice {
+    fn from(val: StreamChoice) -> Self {
+        Self {
+            index: val.index,
+            delta: val.delta.into(),
+            finish_reason: val.finish_reason.map(Into::into),
+            ..Default::default()
+        }
+    }
+}
+
 #[allow(clippy::useless_conversion)]
 impl From<liter_llm::types::StreamChoice> for StreamChoice {
     fn from(val: liter_llm::types::StreamChoice) -> Self {
@@ -15954,6 +16066,22 @@ impl From<liter_llm::types::StreamChoice> for StreamChoice {
     }
 }
 
+#[allow(clippy::needless_update)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
+impl From<StreamDelta> for liter_llm::types::StreamDelta {
+    fn from(val: StreamDelta) -> Self {
+        Self {
+            role: val.role,
+            content: val.content,
+            tool_calls: val.tool_calls.map(|v| v.into_iter().map(Into::into).collect()),
+            function_call: val.function_call.map(Into::into),
+            refusal: val.refusal,
+            reasoning_content: val.reasoning_content,
+            ..Default::default()
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<liter_llm::types::StreamDelta> for StreamDelta {
     fn from(val: liter_llm::types::StreamDelta) -> Self {
@@ -15968,6 +16096,17 @@ impl From<liter_llm::types::StreamDelta> for StreamDelta {
     }
 }
 
+#[allow(clippy::needless_update)]
+impl From<StreamFunctionCall> for liter_llm::types::StreamFunctionCall {
+    fn from(val: StreamFunctionCall) -> Self {
+        Self {
+            name: val.name,
+            arguments: val.arguments,
+            ..Default::default()
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure)]
 impl From<liter_llm::types::StreamFunctionCall> for StreamFunctionCall {
     fn from(val: liter_llm::types::StreamFunctionCall) -> Self {
@@ -15996,6 +16135,20 @@ impl From<liter_llm::types::StreamOptions> for StreamOptions {
     }
 }
 
+#[allow(clippy::needless_update)]
+#[allow(clippy::useless_conversion)]
+impl From<StreamToolCall> for liter_llm::types::StreamToolCall {
+    fn from(val: StreamToolCall) -> Self {
+        Self {
+            index: val.index,
+            id: val.id,
+            call_type: val.call_type.map(Into::into),
+            function: val.function.map(Into::into),
+            ..Default::default()
+        }
+    }
+}
+
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<liter_llm::types::StreamToolCall> for StreamToolCall {
     fn from(val: liter_llm::types::StreamToolCall) -> Self {
@@ -16250,7 +16403,7 @@ impl From<AuthHeaderFormat> for liter_llm::provider::custom::AuthHeaderFormat {
     fn from(val: AuthHeaderFormat) -> Self {
         match val {
             AuthHeaderFormat::Bearer => Self::Bearer,
-            AuthHeaderFormat::ApiKey { _0 } => Self::ApiKey(_0),
+            AuthHeaderFormat::ApiKey(_0) => Self::ApiKey(_0),
             AuthHeaderFormat::None => Self::None,
         }
     }
@@ -16260,7 +16413,7 @@ impl From<liter_llm::provider::custom::AuthHeaderFormat> for AuthHeaderFormat {
     fn from(val: liter_llm::provider::custom::AuthHeaderFormat) -> Self {
         match val {
             liter_llm::provider::custom::AuthHeaderFormat::Bearer => Self::Bearer,
-            liter_llm::provider::custom::AuthHeaderFormat::ApiKey(_0) => Self::ApiKey { _0: _0.to_string() },
+            liter_llm::provider::custom::AuthHeaderFormat::ApiKey(_0) => Self::ApiKey(_0),
             liter_llm::provider::custom::AuthHeaderFormat::None => Self::None,
         }
     }
@@ -16525,6 +16678,16 @@ impl From<liter_llm::types::FinishReason> for FinishReason {
     }
 }
 
+#[cfg(feature = "tower")]
+impl From<HealthStatus> for liter_llm::tower::HealthStatus {
+    fn from(val: HealthStatus) -> Self {
+        match val {
+            HealthStatus::Healthy => Self::Healthy,
+            HealthStatus::Unhealthy => Self::Unhealthy,
+        }
+    }
+}
+
 #[cfg(feature = "tower")]
 impl From<liter_llm::tower::HealthStatus> for HealthStatus {
     fn from(val: liter_llm::tower::HealthStatus) -> Self {
@@ -18374,6 +18537,12 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_singleton_method("object", function!(RerankDocument::_factory_object, 1))?;
 
+    let class = module.define_class("ToolChoice", ruby.class_object())?;
+    class.undef_default_alloc_func();
+    class.define_singleton_method("from_mode", function!(ToolChoice::from_mode, 1))?;
+    class.define_method("mode", method!(ToolChoice::mode, 0))?;
+    class.define_singleton_method("from_specific", function!(ToolChoice::from_specific, 1))?;
+    class.define_method("specific", method!(ToolChoice::specific, 0))?;
     let class = module.define_class("ChatStreamIterator", ruby.class_object())?;
     class.define_method("next_chunk", method!(ChatStreamIterator::next_chunk, 0))?;
     class.define_method("each", method!(ChatStreamIterator::each, 0))?;