Bring Your Own Error Type

[moldhouse]

When using the BYOT features with third-party providers, the error format of these APIs often does not match the expectation of this library. For example, this library deserializes errors into this format:

pub struct ApiError {
    pub message: String,
    #[serde(rename = "type")]
    pub r#type: Option<String>,
    pub param: Option<String>,
    #[serde(deserialize_with = "deserialize_code")]
    pub code: Option<String>,
}

However, OpenRouter provides errors in the following format:

{
    "error": {
        "message": "User not found.",
        "code": 401
    }
}

with the small difference that code is an integer, leading to a deserialization error when using this library.

Before implementing a possible "bring-your-own-error-type" feature, I want to check if this would be within the scope of this library, and about how to architect it. One option might be that users bring their own error type for deserialization that must implement a trait to convert itself into an OpenAIError.

[64bit]

A byot-error feature having ability to provide custom error type would be a nice feature.

I think because in OpenAIError only thing that needs to be customizable is ApiError a simpler implementation could be to allow it to be just serde_json::Value variant when enabled. That way user can convert it into they own type like you said.

#[derive(Debug, thiserror::Error)]
pub enum OpenAIError {
      
     #[cfg(not(feature = "byot-error"))]
     #[error("{0}")]
     ApiError(ApiError),

     #[cfg(feature = "byot-error")]
     #[error("{0}")]
     ApiError(serde_json::Value)

    ... other variants ...
     
}

The other option to have generics with trait bounds for whole OpenAIError would be more complex and require a larger change.

Having serde_json::Value to be ApiError would also be compatible when checking for rate limits and retries in execute_raw. Could it be ApiError( something-generic-or-dynamic ) ?.

Or perhaps WrappedError is what needs to be customizable, because that's what gets deserialized for errors.

#[cfg(not(feature = "byot-error"))]
pub struct WrappedError { .. existing one .. }

#[cfg(feature = "byot-error")]
pub struct WrappedError  {
... (based on serde_json::Value)? ..
}

There could be other unknowns - but having a working implementation should surface that.
Let me know if there's something better / simpler?