Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Emit ordinary stop events for Zed-hosted Gemini models (#64263)
Cole Miller46ee98a8e026
diff --git a/crates/google_ai/src/completion.rs b/crates/google_ai/src/completion.rsindex fda7eb16354..67f44b38359 100644--- a/crates/google_ai/src/completion.rs+++ b/crates/google_ai/src/completion.rs@@ -1,10 +1,10 @@use anyhow::Result;-use futures::{Stream, StreamExt};+use futures::{Stream, StreamExt, TryStreamExt};use language_model_core::{- LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelRequest,- LanguageModelRequestToolInput, LanguageModelToolChoice, LanguageModelToolUse,- LanguageModelToolUseId, LanguageModelToolUseInput, MessageContent, Role, StopReason,- TokenUsage,+ GOOGLE_PROVIDER_NAME, LanguageModelCompletionError, LanguageModelCompletionEvent,+ LanguageModelRequest, LanguageModelRequestToolInput, LanguageModelToolChoice,+ LanguageModelToolUse, LanguageModelToolUseId, LanguageModelToolUseInput, MessageContent, Role,+ StopReason, TokenUsage,};use std::pin::Pin;use std::sync::Arc;@@ -282,34 +282,38 @@ fn supports_thinking_budget_disable(model_id: &str) -> bool {pub struct GoogleEventMapper {usage: UsageMetadata,- stop_reason: StopReason,+ stop_emitted: bool,}impl GoogleEventMapper {pub fn new() -> Self {Self {usage: UsageMetadata::default(),- stop_reason: StopReason::EndTurn,+ stop_emitted: false,}}pub fn map_stream(- mut self,+ self,events: Pin<Box<dyn Send + Stream<Item = Result<GenerateContentResponse>>>>,) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>{- events- .map(Some)- .chain(futures::stream::once(async { None }))- .flat_map(move |event| {- futures::stream::iter(match event {- Some(Ok(event)) => self.map_event(event),- Some(Err(error)) => {- vec![Err(LanguageModelCompletionError::from(error))]- }- None => vec![Ok(LanguageModelCompletionEvent::Stop(self.stop_reason))],- })- })+ futures::stream::try_unfold((self, events), |(mut mapper, mut events)| async move {+ match events.next().await {+ Some(event) => {+ let event = event.map_err(LanguageModelCompletionError::from)?;+ Ok(Some((+ futures::stream::iter(mapper.map_event(event)),+ (mapper, events),+ )))+ }+ None if mapper.stop_emitted => Ok(None),+ None => Err(LanguageModelCompletionError::StreamEndedUnexpectedly {+ provider: GOOGLE_PROVIDER_NAME,+ }),+ }+ })+ .try_flatten()}pub fn map_event(@@ -320,6 +324,7 @@ impl GoogleEventMapper {let mut events: Vec<_> = Vec::new();let mut wants_to_use_tool = false;+ let mut stop_reason = None;if let Some(usage_metadata) = event.usage_metadata {update_usage(&mut self.usage, &usage_metadata);events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(@@ -330,7 +335,7 @@ impl GoogleEventMapper {if let Some(prompt_feedback) = event.prompt_feedback&& let Some(block_reason) = prompt_feedback.block_reason.as_deref(){- self.stop_reason = match block_reason {+ let stop_reason = match block_reason {"SAFETY" | "OTHER" | "BLOCKLIST" | "PROHIBITED_CONTENT" | "IMAGE_SAFETY" => {StopReason::Refusal}@@ -339,7 +344,10 @@ impl GoogleEventMapper {StopReason::Refusal}};- events.push(Ok(LanguageModelCompletionEvent::Stop(self.stop_reason)));+ if !self.stop_emitted {+ self.stop_emitted = true;+ events.push(Ok(LanguageModelCompletionEvent::Stop(stop_reason)));+ }return events;}@@ -347,7 +355,7 @@ impl GoogleEventMapper {if let Some(candidates) = event.candidates {for candidate in candidates {if let Some(finish_reason) = candidate.finish_reason.as_deref() {- self.stop_reason = match finish_reason {+ stop_reason = Some(match finish_reason {"STOP" => StopReason::EndTurn,"MAX_TOKENS" => StopReason::MaxTokens,"SAFETY"@@ -371,7 +379,7 @@ impl GoogleEventMapper {log::error!("Unexpected google finish_reason: {finish_reason}");StopReason::EndTurn}- };+ });}candidate.content@@ -441,8 +449,13 @@ impl GoogleEventMapper {// Even when Gemini wants to use a Tool, the API// responds with `finish_reason: STOP`if wants_to_use_tool {- self.stop_reason = StopReason::ToolUse;- events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::ToolUse)));+ stop_reason = Some(StopReason::ToolUse);+ }+ if let Some(stop_reason) = stop_reason+ && !self.stop_emitted+ {+ self.stop_emitted = true;+ events.push(Ok(LanguageModelCompletionEvent::Stop(stop_reason)));}events}@@ -493,6 +506,109 @@ mod tests {use language_model_core::{LanguageModelRequestMessage, LanguageModelRequestTool};use serde_json::json;+ #[test]+ fn completed_stream_emits_stop_once() {+ for (response, expected_stop) in [+ (+ json!({"candidates": [{+ "content": {"role": "model", "parts": [{"text": "Answer"}]},+ "finishReason": "STOP"+ }]}),+ StopReason::EndTurn,+ ),+ (+ json!({"candidates": [{+ "content": {"role": "model", "parts": [{+ "functionCall": {"name": "list_directory", "args": {}}+ }]},+ "finishReason": "STOP"+ }]}),+ StopReason::ToolUse,+ ),+ (+ json!({"promptFeedback": {"blockReason": "SAFETY"}}),+ StopReason::Refusal,+ ),+ ] {+ let responses = vec![+ Ok(serde_json::from_value(response).unwrap()),+ Ok(serde_json::from_value(json!({"candidates": [{+ "content": {"role": "model", "parts": []},+ "finishReason": "STOP"+ }]}))+ .unwrap()),+ ];+ let events = futures::executor::block_on(+ GoogleEventMapper::new()+ .map_stream(Box::pin(futures::stream::iter(responses)))+ .collect::<Vec<_>>(),+ );+ let stops = events+ .into_iter()+ .filter_map(|event| match event.unwrap() {+ LanguageModelCompletionEvent::Stop(reason) => Some(reason),+ _ => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(stops, vec![expected_stop]);+ }+ }++ #[test]+ fn incomplete_stream_reports_unexpected_end() {+ for has_content in [false, true] {+ let mut responses = Vec::new();+ if has_content {+ responses.push(Ok(serde_json::from_value(json!({"candidates": [{+ "content": {"role": "model", "parts": [{"text": "Partial answer"}]}+ }]}))+ .unwrap()));+ }+ futures::executor::block_on(async {+ let mut stream = GoogleEventMapper::new()+ .map_stream(Box::pin(futures::stream::iter(responses)))+ .boxed();+ if has_content {+ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::Text(text))) if text == "Partial answer"+ ));+ }+ assert!(matches!(+ stream.next().await,+ Some(Err(LanguageModelCompletionError::StreamEndedUnexpectedly { provider }))+ if provider == language_model_core::GOOGLE_PROVIDER_NAME+ ));+ assert!(stream.next().await.is_none());+ });+ }+ }++ #[test]+ fn stream_read_error_is_not_followed_by_completion() {+ let responses = vec![+ Ok(serde_json::from_value(json!({"candidates": [{+ "content": {"role": "model", "parts": [{"text": "Partial answer"}]}+ }]}))+ .unwrap()),+ Err(std::io::Error::new(std::io::ErrorKind::ConnectionReset, "read failed").into()),+ ];+ let events = futures::executor::block_on(+ GoogleEventMapper::new()+ .map_stream(Box::pin(futures::stream::iter(responses)))+ .collect::<Vec<_>>(),+ );+ assert!(matches!(+ events.as_slice(),+ [+ Ok(LanguageModelCompletionEvent::Text(text)),+ Err(LanguageModelCompletionError::Other(error)),+ ] if text == "Partial answer"+ && error.downcast_ref::<std::io::Error>()+ .is_some_and(|error| error.kind() == std::io::ErrorKind::ConnectionReset)+ ));+ }+fn text_request() -> LanguageModelRequest {LanguageModelRequest {messages: vec![LanguageModelRequestMessage {@@ -760,8 +876,10 @@ mod tests {usage_metadata: None,};- mapper.map_event(response);- assert_eq!(mapper.stop_reason, StopReason::Refusal);+ assert!(matches!(+ mapper.map_event(response).as_slice(),+ [Ok(LanguageModelCompletionEvent::Stop(StopReason::Refusal))]+ ));}#[test]diff --git a/crates/language_models_cloud/src/language_models_cloud.rs b/crates/language_models_cloud/src/language_models_cloud.rsindex 6e9ff077fbc..a98dfb00df1 100644--- a/crates/language_models_cloud/src/language_models_cloud.rs+++ b/crates/language_models_cloud/src/language_models_cloud.rs@@ -1357,11 +1357,129 @@ mod tests {use http_client::http::{HeaderMap, StatusCode};use language_model::{LanguageModelCompletionError, LanguageModelRequestMessage, MessageContent,- ProviderErrorCategory, Role, Speed,+ ProviderErrorCategory, Role, Speed, StopReason,};use serde_json::json;use std::sync::Mutex;+ #[gpui::test]+ async fn cloud_google_completion_emits_stop(cx: &mut gpui::TestAppContext) {+ for (finish_reason, expected_stop) in [+ ("STOP", StopReason::EndTurn),+ ("MAX_TOKENS", StopReason::MaxTokens),+ ("SAFETY", StopReason::Refusal),+ ] {+ let model = cloud_google_test_model(vec![+ json!({"event": {"candidates": [{+ "content": {"role": "model", "parts": [{"text": "Hello"}]}+ }]}}),+ json!({"event": {+ "candidates": [{+ "content": {"role": "model", "parts": [{"text": " world"}]},+ "finishReason": finish_reason+ }],+ "usageMetadata": {"promptTokenCount": 10, "candidatesTokenCount": 2}+ }}),+ json!({"status": "stream_ended"}),+ ]);+ let mut stream = model+ .stream_completion(LanguageModelRequest::default(), &cx.to_async())+ .await+ .unwrap();++ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::Text(text))) if text == "Hello"+ ));+ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::UsageUpdate(usage)))+ if usage.input_tokens == 10 && usage.output_tokens == 2+ ));+ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::Text(text))) if text == " world"+ ));+ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::Stop(reason))) if reason == expected_stop+ ));+ assert!(stream.next().await.is_none());+ }+ }++ #[gpui::test]+ async fn cloud_google_tool_completion_preserves_transport_errors(+ cx: &mut gpui::TestAppContext,+ ) {+ for stream_ended in [false, true] {+ let mut events = vec![json!({"event": {"candidates": [{+ "content": {"role": "model", "parts": [{+ "functionCall": {"name": "list_directory", "args": {"path": "."}}+ }]},+ "finishReason": "STOP"+ }]}})];+ if stream_ended {+ events.push(json!({"status": "stream_ended"}));+ }+ let model = cloud_google_test_model(events);+ let mut stream = model+ .stream_completion(LanguageModelRequest::default(), &cx.to_async())+ .await+ .unwrap();++ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::ToolUse(tool)))+ if tool.name.as_ref() == "list_directory"+ ));+ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::Stop(StopReason::ToolUse)))+ ));+ if !stream_ended {+ assert!(matches!(+ stream.next().await,+ Some(Err(+ LanguageModelCompletionError::StreamEndedUnexpectedly { .. }+ ))+ ));+ }+ assert!(stream.next().await.is_none());+ }+ }++ #[gpui::test]+ async fn cloud_google_incomplete_completion_does_not_emit_stop(cx: &mut gpui::TestAppContext) {+ for stream_ended in [false, true] {+ let mut events = vec![json!({"event": {"candidates": [{+ "content": {"role": "model", "parts": [{"text": "Partial answer"}]}+ }]}})];+ if stream_ended {+ events.push(json!({"status": "stream_ended"}));+ }+ let model = cloud_google_test_model(events);+ let mut stream = model+ .stream_completion(LanguageModelRequest::default(), &cx.to_async())+ .await+ .unwrap();++ assert!(matches!(+ stream.next().await,+ Some(Ok(LanguageModelCompletionEvent::Text(text))) if text == "Partial answer"+ ));+ if !stream_ended {+ assert!(matches!(+ stream.next().await,+ Some(Err(+ LanguageModelCompletionError::StreamEndedUnexpectedly { .. }+ ))+ ));+ }+ assert!(stream.next().await.is_none());+ }+ }+#[gpui::test]async fn cloud_explicit_compaction_forwards_supported_request_fields(cx: &mut gpui::TestAppContext,@@ -2108,6 +2226,30 @@ mod tests {}}+ fn cloud_google_test_model(+ events: Vec<serde_json::Value>,+ ) -> CloudLanguageModel<TestTokenProvider> {+ let body = events+ .into_iter()+ .map(|event| format!("{event}\n"))+ .collect::<String>();+ let http_client = FakeHttpClient::create(move |_| {+ let body = body.clone();+ async move {+ Ok(Response::builder()+ .status(200)+ .header(SERVER_SUPPORTS_STATUS_MESSAGES_HEADER_NAME, "true")+ .body(AsyncBody::from(body))?)+ }+ });+ let mut model = cloud_test_model(http_client);+ model.id = LanguageModelId::from("gemini-3.1-pro-preview".to_string());+ let metadata = Arc::make_mut(&mut model.model);+ metadata.provider = cloud_llm_client::LanguageModelProvider::Google;+ metadata.id = cloud_llm_client::LanguageModelId(Arc::from("gemini-3.1-pro-preview"));+ model+ }+fn compact_test_request() -> LanguageModelRequest {LanguageModelRequest {thread_id: Some("thread-123".to_string()),