feat: add helper method to parse raw error into custom type

Author: moldhouse

async-openai/src/client.rs

@@ -523,7 +523,7 @@ async fn read_response(response: Response) -> Result<Bytes, OpenAIError> {
         #[cfg(feature = "string-errors")]
         {
             let message: String = String::from_utf8_lossy(&bytes).into_owned();
-            return Err(OpenAIError::ApiError(message));
+            return Err(OpenAIError::ApiError(crate::error::RawApiError(message)));
         }
     }
 

async-openai/src/error.rs

@@ -2,6 +2,28 @@
 
 use serde::{Deserialize, Serialize};
 
+/// Raw API error string from providers with custom error formats
+///
+/// Only available with the `string-errors` feature.
+#[cfg(feature = "string-errors")]
+#[derive(Debug, Clone)]
+pub struct RawApiError(pub String);
+
+#[cfg(feature = "string-errors")]
+impl std::fmt::Display for RawApiError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+#[cfg(feature = "string-errors")]
+impl RawApiError {
+    /// Parse the raw error string into a custom type
+    pub fn parse<T: serde::de::DeserializeOwned>(&self) -> Result<T, serde_json::Error> {
+        serde_json::from_str(&self.0)
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum OpenAIError {
     /// Underlying error from reqwest library after an API call was made
@@ -15,7 +37,7 @@ pub enum OpenAIError {
     /// This feature leaves deserialization to the user, not even assuming json.
     #[cfg(feature = "string-errors")]
     #[error("{0}")]
-    ApiError(String),
+    ApiError(RawApiError),
     /// Error when a response cannot be deserialized into a Rust type
     #[error("failed to deserialize api response: error:{0} content:{1}")]
     JSONDeserialize(serde_json::Error, String),

async-openai/tests/string-errors.rs

@@ -12,8 +12,8 @@ async fn test_byot_errors() {
     let _r: Result<Value, OpenAIError> = client.chat().create_byot(json!({})).await;
 
     match _r.unwrap_err() {
-        OpenAIError::ApiError(value) => {
-            let _value = serde_json::from_str::<Value>(&value).unwrap();
+        OpenAIError::ApiError(raw_error) => {
+            let _value: Value = raw_error.parse().unwrap();
         }
         _ => {}
     };

examples/string-errors/src/main.rs

@@ -30,8 +30,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .await;
 
     match result.unwrap_err() {
-        OpenAIError::ApiError(error_string) => {
-            let error = serde_json::from_str::<ErrorWrapper>(&error_string).unwrap();
+        OpenAIError::ApiError(raw_error) => {
+            let error: ErrorWrapper = raw_error.parse().unwrap();
             println!("Code: {}", error.error.code);
             println!("Message: {}", error.error.message);
         }