1use http::StatusCode;
10
11#[derive(Debug, Clone, PartialEq, Eq)]
15pub struct ProviderResponseError {
16 pub status: Option<StatusCode>,
18 pub body: String,
20 pub provider_request_id: Option<String>,
22 pub headers: Option<http::HeaderMap>,
25 pub code: Option<String>,
30 pub transient: Option<bool>,
33 pub refusal: bool,
36 pub route: Option<String>,
40}
41
42impl ProviderResponseError {
43 pub fn new(status: StatusCode, body: impl Into<String>) -> Self {
45 let status = Some(status);
46 Self {
47 status,
48 ..Self::without_status(body)
49 }
50 }
51
52 pub fn without_status(body: impl Into<String>) -> Self {
55 Self {
56 status: None,
57 body: body.into(),
58 provider_request_id: None,
59 headers: None,
60 code: None,
61 transient: None,
62 refusal: false,
63 route: None,
64 }
65 }
66
67 pub fn from_body(body: impl Into<String>) -> Self {
73 let mut reply = Self::without_status(body);
74 let status = reply.located(|envelope| envelope.http_status().filter(|_| envelope.nested));
75 reply.status = status.and_then(|status| StatusCode::from_u16(status).ok());
76 reply
77 }
78
79 pub fn with_refusal(mut self, refusal: bool) -> Self {
82 self.refusal = refusal;
83 self
84 }
85
86 pub fn with_status(mut self, status: Option<StatusCode>) -> Self {
90 if self.status.is_none() {
91 self.status = status;
92 }
93 self
94 }
95
96 pub fn with_code(mut self, code: Option<String>) -> Self {
98 self.code = code.filter(|code| !code.is_empty());
99 self
100 }
101
102 pub fn with_transient(mut self, transient: Option<bool>) -> Self {
105 self.transient = transient;
106 self
107 }
108
109 pub fn is_retryable(&self) -> bool {
120 if self.refusal {
121 return false;
122 }
123 let read = |envelope: Envelope<'_>| Some((envelope.is_final(), envelope.verdict()));
124 let (is_final, known) = match &self.code {
125 Some(code) => read(Envelope::default().named(code)),
126 None => self.located(read),
127 }
128 .unwrap_or_default();
129 if is_final {
130 return false;
131 }
132 if let Some(status) = self.status.filter(|status| !status.is_success()) {
133 return crate::error::retryable_status(Some(status.as_u16()));
134 }
135 known.or(self.transient).unwrap_or(false)
136 }
137
138 pub fn machine_code(&self) -> Option<String> {
142 self.code
143 .clone()
144 .or_else(|| self.located(|envelope| envelope.code()))
145 }
146
147 pub fn envelope_json(&self) -> Option<serde_json::Value> {
150 let doc: serde_json::Value = serde_json::from_str(&self.body).ok()?;
151 let envelope = envelope(&doc)?;
152 let error = envelope.error?.clone();
153 Some(match envelope.nested {
154 true => serde_json::json!({ "error": error }),
155 false => error,
156 })
157 }
158
159 fn located<T>(&self, f: impl FnOnce(Envelope<'_>) -> Option<T>) -> Option<T> {
161 let doc: serde_json::Value = serde_json::from_str(&self.body).ok()?;
162 delivered(&doc).and_then(f)
163 }
164
165 pub fn with_provider_request_id(mut self, request_id: Option<String>) -> Self {
167 self.provider_request_id = request_id.filter(|id| !id.is_empty());
168 self
169 }
170
171 pub fn with_headers(mut self, headers: Option<http::HeaderMap>) -> Self {
173 self.headers = headers;
174 self
175 }
176}
177
178impl std::fmt::Display for ProviderResponseError {
179 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
180 match self.status {
181 Some(status) => write!(f, "status {status}: {}", self.body)?,
182 None => write!(f, "{}", self.body)?,
183 }
184 if let Some(request_id) = &self.provider_request_id {
186 write!(f, " (request id: {request_id})")?;
187 }
188 if let Some(route) = &self.route {
189 write!(f, " [{route}]")?;
190 }
191 Ok(())
192 }
193}
194
195impl std::error::Error for ProviderResponseError {}
196
197#[derive(serde::Serialize, serde::Deserialize)]
200#[serde(deny_unknown_fields)]
201struct ProviderResponseErrorWire {
202 status: Option<u16>,
203 body: String,
204 provider_request_id: Option<String>,
205 #[serde(default, skip_serializing_if = "Option::is_none")]
206 code: Option<String>,
207 #[serde(default, skip_serializing_if = "Option::is_none")]
208 transient: Option<bool>,
209 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
210 refusal: bool,
211}
212
213impl serde::Serialize for ProviderResponseError {
214 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
215 ProviderResponseErrorWire {
216 status: self.status.map(|status| status.as_u16()),
217 body: self.body.clone(),
218 provider_request_id: self.provider_request_id.clone(),
219 code: self.code.clone(),
220 transient: self.transient,
221 refusal: self.refusal,
222 }
223 .serialize(serializer)
224 }
225}
226
227impl<'de> serde::Deserialize<'de> for ProviderResponseError {
228 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
229 use serde::de::Error as _;
230 let wire = ProviderResponseErrorWire::deserialize(deserializer)?;
231 let status = wire
232 .status
233 .map(StatusCode::from_u16)
234 .transpose()
235 .map_err(D::Error::custom)?;
236 Ok(Self {
237 status,
238 body: wire.body,
239 provider_request_id: wire.provider_request_id,
240 headers: None,
241 code: wire.code,
242 transient: wire.transient,
243 refusal: wire.refusal,
244 route: None,
245 })
246 }
247}
248
249#[derive(Default)]
252struct Envelope<'a> {
253 error: Option<&'a serde_json::Value>,
255 name: Option<&'a str>,
256 number: Option<i64>,
257 nested: bool,
260}
261
262const TRANSIENT: &[&str] = &[
265 "overloaded",
266 "overloaded_error",
267 "api_error",
268 "rate_limit_error",
269 "rate_limit_exceeded",
270 "too_many_requests",
271 "server_error",
272 "server_is_overloaded",
273 "slow_down",
274 "unavailable",
275 "resource_exhausted",
276 "deadline_exceeded",
277 "aborted",
278 "ThrottlingException",
279 "ServiceUnavailableException",
280 "InternalServerException",
281 "ModelNotReadyException",
282 "ModelTimeoutException",
283 "ModelStreamErrorException",
284];
285
286const FINAL: &[&str] = &[
288 "insufficient_quota",
289 "quota_exceeded",
290 "billing_hard_limit_reached",
291 "context_length_exceeded",
292 "invalid_prompt",
293];
294
295fn envelope(doc: &serde_json::Value) -> Option<Envelope<'_>> {
302 use serde_json::Value;
303 const FIELDS: &[&str] = &["code", "status", "type"];
304 let object = |value: &&Value| value.as_object().is_some_and(|fields| !fields.is_empty());
305 if let Some(error) = doc.pointer("/response/error").filter(object) {
306 return Some(Envelope::of(error, FIELDS, true));
307 }
308 match doc.get("error") {
309 Some(error) if object(&error) => Some(Envelope::of(error, FIELDS, true)),
310 Some(error @ Value::String(message)) if !message.is_empty() => {
311 Some(Envelope::of(error, &[], true))
312 }
313 _ => (doc.get("type").and_then(Value::as_str) == Some("error"))
314 .then(|| Envelope::of(doc, &["code"], false)),
315 }
316}
317
318fn delivered(doc: &serde_json::Value) -> Option<Envelope<'_>> {
326 if let Some(items) = doc.as_array() {
327 return items.iter().find_map(delivered);
328 }
329 let message = doc.get("message").and_then(serde_json::Value::as_str);
330 let bare = message.is_some_and(|message| !message.is_empty())
331 && doc.get("error").is_none()
332 && doc.get("response").is_none();
333 envelope(doc).or_else(|| bare.then(|| Envelope::of(doc, &["code", "status", "type"], false)))
334}
335
336impl<'a> Envelope<'a> {
337 fn named(mut self, name: &'a str) -> Self {
338 self.name = Some(name);
339 self
340 }
341
342 fn of(error: &'a serde_json::Value, fields: &[&str], nested: bool) -> Self {
343 let values = || fields.iter().filter_map(|field| error.get(field));
344 Self {
345 error: Some(error),
346 name: values().find_map(|value| value.as_str().filter(|name| !name.is_empty())),
347 number: values().find_map(serde_json::Value::as_i64),
348 nested,
349 }
350 }
351
352 fn code(&self) -> Option<String> {
354 let number = || self.number.map(|number| number.to_string());
355 self.name.map(str::to_owned).or_else(number)
356 }
357
358 fn verdict(&self) -> Option<bool> {
363 let status = || {
364 self.http_status()
365 .map(|s| crate::error::retryable_status(Some(s)))
366 };
367 (self.named_in(TRANSIENT).then_some(true))
368 .or_else(|| self.is_final().then_some(false))
369 .or_else(status)
370 }
371
372 fn is_final(&self) -> bool {
374 self.named_in(FINAL)
375 }
376
377 fn named_in(&self, codes: &[&str]) -> bool {
378 let name = self.name.unwrap_or_default();
379 codes.iter().any(|code| code.eq_ignore_ascii_case(name))
380 }
381
382 fn http_status(&self) -> Option<u16> {
383 let number = u16::try_from(self.number?).ok();
384 number.filter(|number| (400..=599).contains(number))
385 }
386}
387
388pub(crate) fn reported(id: Option<String>) -> Option<String> {
390 id.filter(|id| !id.is_empty())
391}
392
393pub(crate) fn json(body: Option<&str>) -> Result<Option<serde_json::Value>, serde_json::Error> {
400 body.filter(|body| !body.is_empty())
401 .map(serde_json::from_str)
402 .transpose()
403}
404
405#[cfg(test)]
406mod tests;