Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Return typed completion errors from Cloud provider (#58997)
Conrad Irwina98485809be0
diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex c1520827484..c34df08273c 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -4206,10 +4206,8 @@ impl Thread {max_attempts: 3,})}- Other(err) if err.is::<language_model::PaymentRequiredError>() => {- // Retrying won't help for Payment Required errors.- None- }+ // Retrying won't help for Payment Required errors.+ PaymentRequired => None,// Retrying won't help until the user consents to data retention// or switches models.DataRetentionConsentRequired { .. } => None,diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rsindex f59420b1f2b..95f8b7d8097 100644--- a/crates/agent_ui/src/conversation_view.rs+++ b/crates/agent_ui/src/conversation_view.rs@@ -163,8 +163,6 @@ impl From<anyhow::Error> for ThreadError {Self::MaxOutputTokens} else if error.is::<NoModelConfiguredError>() {Self::NoModelSelected- } else if error.is::<language_model::PaymentRequiredError>() {- Self::PaymentRequired} else if let Some(acp_error) = error.downcast_ref::<acp::Error>()&& acp_error.code == acp::ErrorCode::AuthRequired{@@ -181,6 +179,7 @@ impl From<anyhow::Error> for ThreadError {}}PromptTooLarge { .. } => Self::PromptTooLarge,+ PaymentRequired => Self::PaymentRequired,NoApiKey { provider } => Self::NoApiKey {provider: provider.to_string().into(),},diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rsindex 5cf1a6ea087..1eb2ec5b680 100644--- a/crates/language_model/src/language_model.rs+++ b/crates/language_model/src/language_model.rs@@ -1,5 +1,4 @@mod api_key;-mod model;mod registry;mod request;@@ -17,7 +16,6 @@ use parking_lot::Mutex;use std::sync::Arc;pub use crate::api_key::{ApiKey, ApiKeyState};-pub use crate::model::*;pub use crate::registry::*;pub use crate::request::{LanguageModelImageExt, gpui_size_to_image_size, image_size_to_gpui};pub use env_var::{EnvVar, env_var};diff --git a/crates/language_model/src/model.rs b/crates/language_model/src/model.rsdeleted file mode 100644index db4c55daa7d..00000000000--- a/crates/language_model/src/model.rs+++ /dev/null@@ -1,3 +0,0 @@-pub mod cloud_model;--pub use cloud_model::*;diff --git a/crates/language_model/src/model/cloud_model.rs b/crates/language_model/src/model/cloud_model.rsdeleted file mode 100644index 8cd71928b10..00000000000--- a/crates/language_model/src/model/cloud_model.rs+++ /dev/null@@ -1,15 +0,0 @@-use std::fmt;--use thiserror::Error;--#[derive(Error, Debug)]-pub struct PaymentRequiredError;--impl fmt::Display for PaymentRequiredError {- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {- write!(- f,- "Payment required to use this language model. Please upgrade your account."- )- }-}diff --git a/crates/language_model_core/src/language_model_core.rs b/crates/language_model_core/src/language_model_core.rsindex 3dd8330f71c..bc3d8b8e521 100644--- a/crates/language_model_core/src/language_model_core.rs+++ b/crates/language_model_core/src/language_model_core.rs@@ -174,6 +174,8 @@ pub enum LanguageModelCompletionError {},#[error("stream from {provider} ended unexpectedly")]StreamEndedUnexpectedly { provider: LanguageModelProviderName },+ #[error("payment required to use this language model; please upgrade your account")]+ PaymentRequired,#[error(transparent)]Other(#[from] anyhow::Error),}diff --git a/crates/language_models_cloud/src/language_models_cloud.rs b/crates/language_models_cloud/src/language_models_cloud.rsindex c129042dec6..6fdd11caf57 100644--- a/crates/language_models_cloud/src/language_models_cloud.rs+++ b/crates/language_models_cloud/src/language_models_cloud.rs@@ -1,5 +1,5 @@use anthropic::AnthropicModelMode;-use anyhow::{Context as _, Result, anyhow};+use anyhow::{Context as _, Result};use cloud_llm_client::{CLIENT_SUPPORTS_STATUS_MESSAGES_HEADER_NAME, CLIENT_SUPPORTS_STATUS_STREAM_ENDED_HEADER_NAME,CLIENT_SUPPORTS_X_AI_HEADER_NAME, CompletionBody, CompletionEvent, CompletionRequestStatus,@@ -23,9 +23,8 @@ use language_model::{LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,LanguageModelEffortLevel, LanguageModelId, LanguageModelName, LanguageModelProviderId,LanguageModelProviderName, LanguageModelRequest, LanguageModelToolChoice,- LanguageModelToolSchemaFormat, OPEN_AI_PROVIDER_ID, OPEN_AI_PROVIDER_NAME,- PaymentRequiredError, RateLimiter, X_AI_PROVIDER_ID, X_AI_PROVIDER_NAME, ZED_CLOUD_PROVIDER_ID,- ZED_CLOUD_PROVIDER_NAME,+ LanguageModelToolSchemaFormat, OPEN_AI_PROVIDER_ID, OPEN_AI_PROVIDER_NAME, RateLimiter,+ X_AI_PROVIDER_ID, X_AI_PROVIDER_NAME, ZED_CLOUD_PROVIDER_ID, ZED_CLOUD_PROVIDER_NAME,};use schemars::JsonSchema;@@ -123,9 +122,16 @@ impl<TP: CloudLlmTokenProvider> CloudLanguageModel<TP> {auth_context: TP::AuthContext,app_version: Option<Version>,body: CompletionBody,- ) -> Result<PerformLlmCompletionResponse> {- let url = http_client.build_zed_llm_url("/completions", &[])?;- let body = serde_json::to_string(&body)?;+ ) -> Result<PerformLlmCompletionResponse, LanguageModelCompletionError> {+ let url = http_client+ .build_zed_llm_url("/completions", &[])+ .map_err(LanguageModelCompletionError::Other)?;+ let body = serde_json::to_string(&body).map_err(|error| {+ LanguageModelCompletionError::SerializeRequest {+ provider: PROVIDER_NAME,+ error,+ }+ })?;let mut response =authenticated_llm_request(http_client, token_provider, auth_context, |token| {Ok(http_client::Request::builder()@@ -140,7 +146,11 @@ impl<TP: CloudLlmTokenProvider> CloudLanguageModel<TP> {.header(CLIENT_SUPPORTS_STATUS_STREAM_ENDED_HEADER_NAME, "true").body(body.clone().into())?)})- .await?;+ .await+ .map_err(|error| LanguageModelCompletionError::HttpSend {+ provider: PROVIDER_NAME,+ error,+ })?;let status = response.status();if status.is_success() {@@ -156,17 +166,25 @@ impl<TP: CloudLlmTokenProvider> CloudLanguageModel<TP> {}if status == StatusCode::PAYMENT_REQUIRED {- return Err(anyhow!(PaymentRequiredError));+ return Err(LanguageModelCompletionError::PaymentRequired);}let mut body = String::new();let headers = response.headers().clone();- response.body_mut().read_to_string(&mut body).await?;- Err(anyhow!(ApiError {+ response+ .body_mut()+ .read_to_string(&mut body)+ .await+ .map_err(|error| LanguageModelCompletionError::ApiReadResponseError {+ provider: PROVIDER_NAME,+ error,+ })?;+ Err(ApiError {status,body,- headers- }))+ headers,+ }+ .into())}}@@ -469,15 +487,15 @@ impl<TP: CloudLlmTokenProvider + 'static> LanguageModel for CloudLanguageModel<Tprompt_id,provider: cloud_llm_client::LanguageModelProvider::Anthropic,model: request.model.clone(),- provider_request: serde_json::to_value(&request)- .map_err(|e| anyhow!(e))?,+ provider_request: serde_json::to_value(&request).map_err(|error| {+ LanguageModelCompletionError::SerializeRequest {+ provider: provider_name.clone(),+ error,+ }+ })?,},)- .await- .map_err(|err| match err.downcast::<ApiError>() {- Ok(api_err) => anyhow!(LanguageModelCompletionError::from(api_err)),- Err(err) => anyhow!(err),- })?;+ .await?;let mut mapper = AnthropicEventMapper::new();Ok(map_cloud_completion_events(@@ -534,8 +552,12 @@ impl<TP: CloudLlmTokenProvider + 'static> LanguageModel for CloudLanguageModel<Tprompt_id,provider: cloud_llm_client::LanguageModelProvider::OpenAi,model: request.model.clone(),- provider_request: serde_json::to_value(&request)- .map_err(|e| anyhow!(e))?,+ provider_request: serde_json::to_value(&request).map_err(|error| {+ LanguageModelCompletionError::SerializeRequest {+ provider: provider_name.clone(),+ error,+ }+ })?,},).await?;@@ -576,8 +598,12 @@ impl<TP: CloudLlmTokenProvider + 'static> LanguageModel for CloudLanguageModel<Tprompt_id,provider: cloud_llm_client::LanguageModelProvider::XAi,model: request.model.clone(),- provider_request: serde_json::to_value(&request)- .map_err(|e| anyhow!(e))?,+ provider_request: serde_json::to_value(&request).map_err(|error| {+ LanguageModelCompletionError::SerializeRequest {+ provider: provider_name.clone(),+ error,+ }+ })?,},).await?;@@ -611,8 +637,12 @@ impl<TP: CloudLlmTokenProvider + 'static> LanguageModel for CloudLanguageModel<Tprompt_id,provider: cloud_llm_client::LanguageModelProvider::Google,model: request.model.model_id.clone(),- provider_request: serde_json::to_value(&request)- .map_err(|e| anyhow!(e))?,+ provider_request: serde_json::to_value(&request).map_err(|error| {+ LanguageModelCompletionError::SerializeRequest {+ provider: provider_name.clone(),+ error,+ }+ })?,},).await?;@@ -772,7 +802,7 @@ impl<TP: CloudLlmTokenProvider + 'static> CloudModelProvider<TP> {}pub fn map_cloud_completion_events<T, F>(- stream: Pin<Box<dyn Stream<Item = Result<CompletionEvent<T>>> + Send>>,+ stream: Pin<Box<dyn Stream<Item = Result<CompletionEvent<T>, ResponseStreamError>> + Send>>,provider: &LanguageModelProviderName,mut map_callback: F,) -> BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>@@ -804,7 +834,7 @@ wherePoll::Ready(Some(event)) => {let items = match event {Err(error) => {- vec![Err(LanguageModelCompletionError::from(error))]+ vec![Err(error.into_completion_error(provider.clone()))]}Ok(CompletionEvent::Status(CompletionRequestStatus::StreamEnded)) => {saw_stream_ended = true;@@ -852,10 +882,36 @@ pub fn provider_name(}}+/// A failure while reading the streamed completion response body.+///+/// Kept as a typed error (rather than `anyhow::Error`) so the consumer can+/// attach the provider name and build a structured+/// [`LanguageModelCompletionError`] without a runtime downcast.+pub enum ResponseStreamError {+ Read(std::io::Error),+ Deserialize(serde_json::Error),+}++impl ResponseStreamError {+ fn into_completion_error(+ self,+ provider: LanguageModelProviderName,+ ) -> LanguageModelCompletionError {+ match self {+ ResponseStreamError::Read(error) => {+ LanguageModelCompletionError::ApiReadResponseError { provider, error }+ }+ ResponseStreamError::Deserialize(error) => {+ LanguageModelCompletionError::DeserializeResponse { provider, error }+ }+ }+ }+}+pub fn response_lines<T: DeserializeOwned>(response: Response<AsyncBody>,includes_status_messages: bool,-) -> impl Stream<Item = Result<CompletionEvent<T>>> {+) -> impl Stream<Item = Result<CompletionEvent<T>, ResponseStreamError>> {futures::stream::try_unfold((String::new(), BufReader::new(response.into_body())),move |(mut line, mut body)| async move {@@ -863,15 +919,19 @@ pub fn response_lines<T: DeserializeOwned>(Ok(0) => Ok(None),Ok(_) => {let event = if includes_status_messages {- serde_json::from_str::<CompletionEvent<T>>(&line)?+ serde_json::from_str::<CompletionEvent<T>>(&line)+ .map_err(ResponseStreamError::Deserialize)?} else {- CompletionEvent::Event(serde_json::from_str::<T>(&line)?)+ CompletionEvent::Event(+ serde_json::from_str::<T>(&line)+ .map_err(ResponseStreamError::Deserialize)?,+ )};line.clear();Ok(Some((event, (line, body))))}- Err(e) => Err(e.into()),+ Err(error) => Err(ResponseStreamError::Read(error)),}},)@@ -1027,4 +1087,32 @@ mod tests {),}}++ #[test]+ fn test_response_stream_error_maps_to_structured_variant() {+ // Read/deserialize failures mid-stream must keep their structured+ // variant rather than collapsing into `Other` (the source of the+ // generic "Request failed." message).+ let read = ResponseStreamError::Read(std::io::Error::from(std::io::ErrorKind::BrokenPipe))+ .into_completion_error(PROVIDER_NAME);+ assert!(+ matches!(+ read,+ LanguageModelCompletionError::ApiReadResponseError { .. }+ ),+ "Expected ApiReadResponseError, got: {read:?}"+ );++ let deserialize = ResponseStreamError::Deserialize(+ serde_json::from_str::<serde_json::Value>("not json").unwrap_err(),+ )+ .into_completion_error(PROVIDER_NAME);+ assert!(+ matches!(+ deserialize,+ LanguageModelCompletionError::DeserializeResponse { .. }+ ),+ "Expected DeserializeResponse, got: {deserialize:?}"+ );+ }}