Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
google_ai: Improve error messages and handle retries (#64865)
Bennet Bo Fennerfa6aeecf2ac2
diff --git a/crates/google_ai/src/google_ai.rs b/crates/google_ai/src/google_ai.rsindex 00a195b43d8..8c762e84a7a 100644--- a/crates/google_ai/src/google_ai.rs+++ b/crates/google_ai/src/google_ai.rs@@ -4,8 +4,12 @@ use anyhow::{Result, anyhow, bail};use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};use http_client::{AsyncBody, CustomHeaders, HttpClient, Method, Request as HttpRequest, RequestBuilderExt,+ StatusCode, http::HeaderMap,};pub use language_model_core::ModelMode as GoogleModelMode;+use language_model_core::{+ GOOGLE_PROVIDER_NAME, LanguageModelCompletionError, ProviderErrorCategory,+};use serde::{Deserialize, Deserializer, Serialize, Serializer};pub mod completion;@@ -17,7 +21,7 @@ pub async fn stream_generate_content(api_key: &str,mut request: GenerateContentRequest,extra_headers: &CustomHeaders,-) -> Result<BoxStream<'static, Result<GenerateContentResponse>>> {+) -> Result<BoxStream<'static, Result<GenerateContentResponse>>, LanguageModelCompletionError> {let api_key = api_key.trim();validate_generate_content_request(&request)?;@@ -32,8 +36,25 @@ pub async fn stream_generate_content(.uri(uri).header("Content-Type", "application/json").extra_headers(extra_headers)- .body(AsyncBody::from(serde_json::to_string(&request)?))?;- let mut response = client.send(request).await?;+ .body(AsyncBody::from(serde_json::to_string(&request).map_err(+ |error| LanguageModelCompletionError::SerializeRequest {+ provider: GOOGLE_PROVIDER_NAME,+ error,+ },+ )?))+ .map_err(|error| LanguageModelCompletionError::BuildRequestBody {+ provider: GOOGLE_PROVIDER_NAME,+ error,+ })?;+ let mut response =+ client+ .send(request)+ .await+ .map_err(|error| LanguageModelCompletionError::HttpSend {+ provider: GOOGLE_PROVIDER_NAME,+ host: api_url.to_string(),+ error,+ })?;if response.status().is_success() {let reader = BufReader::new(response.into_body());Ok(reader@@ -66,13 +87,122 @@ pub async fn stream_generate_content(}).boxed())} else {- let mut text = String::new();- response.body_mut().read_to_string(&mut text).await?;- Err(anyhow!(- "error during streamGenerateContent, status code: {:?}, body: {}",- response.status(),- text- ))+ let status = response.status();+ let headers = response.headers().clone();+ let mut body = String::new();+ response+ .body_mut()+ .read_to_string(&mut body)+ .await+ .map_err(|error| LanguageModelCompletionError::ApiReadResponseError {+ provider: GOOGLE_PROVIDER_NAME,+ error,+ })?;+ Err(completion_error_from_response(status, &headers, body))+ }+}++fn completion_error_from_response(+ status: StatusCode,+ headers: &HeaderMap,+ body: String,+) -> LanguageModelCompletionError {+ let retry_after = headers+ .get(http_client::http::header::RETRY_AFTER)+ .and_then(|value| value.to_str().ok()?.parse::<u64>().ok())+ .map(std::time::Duration::from_secs);+ let parsed_error = serde_json::from_str::<GoogleErrorEnvelope>(&body)+ .ok()+ .map(|envelope| envelope.error);+ let message = parsed_error+ .as_ref()+ .map(|error| error.message.clone())+ .unwrap_or(body);+ let code = parsed_error.and_then(|error| error.status);+ let category = ProviderErrorCategory::from_http_status(status, &message);++ LanguageModelCompletionError::from_provider_response(+ GOOGLE_PROVIDER_NAME,+ Some(status),+ code,+ message,+ retry_after,+ category,+ )+}++#[derive(Deserialize)]+struct GoogleErrorEnvelope {+ error: GoogleError,+}++#[derive(Deserialize)]+struct GoogleError {+ message: String,+ status: Option<String>,+}++#[cfg(test)]+mod provider_error_tests {+ use super::*;++ #[test]+ fn google_rejections_preserve_wire_details_and_semantic_category() {+ let mut headers = HeaderMap::new();+ headers.insert(+ http_client::http::header::RETRY_AFTER,+ http_client::http::HeaderValue::from_static("7"),+ );+ let error = completion_error_from_response(+ StatusCode::SERVICE_UNAVAILABLE,+ &headers,+ r#"{"error":{"code":503,"message":"The model is overloaded. Please try again later.","status":"UNAVAILABLE"}}"#+ .to_string(),+ );++ assert!(matches!(+ error,+ LanguageModelCompletionError::ProviderRejection {+ provider,+ status: Some(StatusCode::SERVICE_UNAVAILABLE),+ code: Some(code),+ message,+ retry_after: Some(retry_after),+ category: ProviderErrorCategory::Overloaded,+ } if provider == GOOGLE_PROVIDER_NAME+ && code == "UNAVAILABLE"+ && message == "The model is overloaded. Please try again later."+ && retry_after == std::time::Duration::from_secs(7)+ ));+ }++ #[test]+ fn google_rejections_use_shared_http_classification() {+ for (status, expected_category) in [+ (+ StatusCode::UNAUTHORIZED,+ ProviderErrorCategory::Authentication,+ ),+ (+ StatusCode::PAYMENT_REQUIRED,+ ProviderErrorCategory::PaymentRequired,+ ),+ (+ StatusCode::TOO_MANY_REQUESTS,+ ProviderErrorCategory::RateLimit,+ ),+ ] {+ let error = completion_error_from_response(+ status,+ &HeaderMap::new(),+ r#"{"error":{"code":0,"message":"rejected","status":"REJECTED"}}"#.to_string(),+ );+ assert!(matches!(+ error,+ LanguageModelCompletionError::ProviderRejection { category, .. }+ if category == expected_category+ ));+ }}}diff --git a/crates/language_models/src/provider/google.rs b/crates/language_models/src/provider/google.rsindex f256b7e1d1e..b31ecb35cd6 100644--- a/crates/language_models/src/provider/google.rs+++ b/crates/language_models/src/provider/google.rs@@ -1,4 +1,4 @@-use anyhow::{Context as _, Result};+use anyhow::Result;use collections::BTreeMap;use credentials_provider::CredentialsProvider;use futures::{FutureExt, StreamExt, future::BoxFuture};@@ -170,7 +170,10 @@ impl GoogleLanguageModelProvider {cx: &AsyncApp,) -> BoxFuture<'static,- Result<futures::stream::BoxStream<'static, Result<GenerateContentResponse>>>,+ Result<+ futures::stream::BoxStream<'static, Result<GenerateContentResponse>>,+ LanguageModelCompletionError,+ >,> {let http_client = self.http_client.clone();@@ -183,7 +186,11 @@ impl GoogleLanguageModelProvider {});async move {- let api_key = api_key.context("Missing Google API key")?;+ let Some(api_key) = api_key else {+ return Err(LanguageModelCompletionError::NoApiKey {+ provider: PROVIDER_NAME,+ });+ };let request = google_ai::stream_generate_content(http_client.as_ref(),&api_url,@@ -191,7 +198,7 @@ impl GoogleLanguageModelProvider {request,&extra_headers,);- request.await.context("failed to stream completion")+ request.await}.boxed()}@@ -298,7 +305,7 @@ impl LanguageModelClient for GoogleLanguageModelProvider {};let request = self.stream_google_request(request, cx);let future = request_limiter.stream(async move {- let response = request.await.map_err(LanguageModelCompletionError::from)?;+ let response = request.await?;Ok(GoogleEventMapper::new().map_stream(response))});async move { Ok(future.await?.boxed()) }.boxed()