Skip to content

armgit / zed

Public Imported from GitHub
0

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.rs
index 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.rs
index 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()),