error.rs

crates/cortex-core/src/provider/error.rs

1. //! Provider failures, mapped to what a person can act on.
2. //!
3. //! There is no automatic retry anywhere: a retry is another billed request,
4. //! so the UI offers one and the person decides.
6. use serde::Serialize;
8. #[derive(Debug, Clone, PartialEq, thiserror::Error)]
9. pub enum ProviderError {
10. #[error("The API key was rejected. Check it in Settings.")]
11. InvalidKey,
12. #[error("The account is out of credit.")]
13. InsufficientBalance,
14. #[error("Rate limited by the provider{}.", retry_after.map(|s| format!("; try again in {s} s")).unwrap_or_default())]
15. RateLimited { retry_after: Option<u64> },
16. #[error("The provider had an error ({status}): {message}")]
17. Upstream { status: u16, message: String },
18. #[error("The request was refused ({status}): {message}")]
19. BadRequest { status: u16, message: String },
20. #[error("Could not reach {url}. Is the server running?")]
21. Unreachable { url: String },
22. #[error("The stream stopped with an error: {0}")]
23. Stream(String),
24. #[error("{0}")]
25. Other(String),
26. }
28. impl ProviderError {
29. /// A stable machine name, stored with a failed message and used by the UI.
30. pub fn kind(&self) -> &'static str {
31. match self {
32. Self::InvalidKey => "invalid_key",
33. Self::InsufficientBalance => "insufficient_balance",
34. Self::RateLimited { .. } => "rate_limited",
35. Self::Upstream { .. } => "upstream",
36. Self::BadRequest { .. } => "bad_request",
37. Self::Unreachable { .. } => "unreachable",
38. Self::Stream(_) => "stream",
39. Self::Other(_) => "other",
40. }
41. }
43. /// Map an HTTP error response. `body` is the response text, if any.
44. pub fn from_status(status: u16, body: &str, retry_after: Option<u64>) -> Self {
45. let message = error_message(body).unwrap_or_else(|| body.chars().take(300).collect());
46. match status {
47. 401 | 403 => Self::InvalidKey,
48. 402 => Self::InsufficientBalance,
49. 429 => Self::RateLimited { retry_after },
50. 500..=599 => Self::Upstream { status, message },
51. _ => Self::BadRequest { status, message },
52. }
53. }
54. }
56. /// `{"error": {"message": ...}}`, `{"error": "..."}` or `{"detail": ...}`.
57. pub fn error_message(body: &str) -> Option<String> {
58. let v: serde_json::Value = serde_json::from_str(body).ok()?;
59. let e = v.get("error").or_else(|| v.get("detail"))?;
60. match e {
61. serde_json::Value::String(s) => Some(s.clone()),
62. serde_json::Value::Object(o) => o.get("message").and_then(|m| m.as_str()).map(str::to_string),
63. _ => None,
64. }
65. }
67. impl Serialize for ProviderError {
68. fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
69. use serde::ser::SerializeStruct;
70. let mut st = s.serialize_struct("ProviderError", 2)?;
71. st.serialize_field("kind", self.kind())?;
72. st.serialize_field("message", &self.to_string())?;
73. st.end()
74. }
75. }
77. #[cfg(test)]
78. mod tests {
79. use super::*;
81. #[test]
82. fn maps_statuses() {
83. let di = r#"{"error":{"message":"Invalid API key","type":"invalid_request_error","code":"invalid_api_key"}}"#;
84. assert_eq!(ProviderError::from_status(401, di, None), ProviderError::InvalidKey);
85. assert_eq!(ProviderError::from_status(402, "", None).kind(), "insufficient_balance");
86. let r = ProviderError::from_status(429, "{}", Some(7));
87. assert_eq!(r.to_string(), "Rate limited by the provider; try again in 7 s.");
88. assert_eq!(
89. ProviderError::from_status(503, r#"{"detail":"overloaded"}"#, None),
90. ProviderError::Upstream { status: 503, message: "overloaded".into() }
91. );
92. assert_eq!(ProviderError::from_status(400, r#"{"error":"bad model"}"#, None).kind(), "bad_request");
93. }
94. }