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.

agent_ui: Fix inline assistant when reasoning precedes tool use (#61220)

Shuhei Kadowakic3b365d27615
diff --git a/crates/agent_ui/src/buffer_codegen.rs b/crates/agent_ui/src/buffer_codegen.rs
index 022bf5c6585..5782f7a086b 100644
--- a/crates/agent_ui/src/buffer_codegen.rs
+++ b/crates/agent_ui/src/buffer_codegen.rs
@@ -1,7 +1,7 @@
use crate::{context::LoadedContext, inline_prompt_editor::CodegenStatus};
use agent_settings::AgentSettings;
-use anyhow::{Context as _, Result};
-use collections::{HashMap, HashSet};
+use anyhow::{Context as _, Result, anyhow};
+use collections::HashSet;
use editor::{Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset as _, ToPoint};
use futures::FutureExt;
use futures::{
@@ -19,7 +19,7 @@ use language_model::{
CompletionIntent, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,
LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
LanguageModelRequestTool, LanguageModelTextStream, LanguageModelToolChoice,
- LanguageModelToolUse, LanguageModelToolUseId, Role, TokenUsage,
+ LanguageModelToolUse, LanguageModelToolUseId, Role, StopReason, TokenUsage,
};
use language_models::provider::anthropic::telemetry::{
AnthropicCompletionType, AnthropicEventData, AnthropicEventReporter, AnthropicEventType,
@@ -415,6 +415,7 @@ impl CodegenAlternative {
) -> Result<()> {
// Clear the model explanation since the user has started a new generation.
self.description = None;
+ self.failure = None;
if let Some(transformation_transaction_id) = self.transformation_transaction_id.take() {
self.buffer.update(cx, |buffer, cx| {
@@ -1163,162 +1164,293 @@ impl CodegenAlternative {
enum ToolUseOutput {
Rewrite {
text: String,
- description: Option<String>,
},
- Failure(String),
+ Failure {
+ message: String,
+ is_input_complete: bool,
+ },
}
- enum ModelUpdate {
- Description(String),
- Failure(String),
+ struct RewriteState {
+ tool_use_id: LanguageModelToolUseId,
+ chars_read: usize,
+ is_input_complete: bool,
}
- let chars_read_by_tool_id: Arc<Mutex<HashMap<LanguageModelToolUseId, usize>>> =
- Arc::new(Mutex::new(HashMap::default()));
- let process_tool_use = move |tool_use: LanguageModelToolUse| -> Option<ToolUseOutput> {
- let mut chars_read_by_tool_id = chars_read_by_tool_id.lock();
- match tool_use.name.as_ref() {
- REWRITE_SECTION_TOOL_NAME => {
- let Ok(input) = tool_use.input.parse::<RewriteSectionInput>() else {
- return None;
- };
- let chars_read_so_far =
- chars_read_by_tool_id.entry(tool_use.id).or_insert(0);
- let Some(text_slice) = input.replacement_text.get(*chars_read_so_far..)
- else {
- return None;
- };
- let text = text_slice.to_string();
- *chars_read_so_far = input.replacement_text.len();
- Some(ToolUseOutput::Rewrite {
- text,
- description: None,
- })
- }
- FAILURE_MESSAGE_TOOL_NAME => {
- let Ok(mut input) = tool_use.input.parse::<FailureMessageInput>() else {
- return None;
- };
- Some(ToolUseOutput::Failure(std::mem::take(&mut input.message)))
- }
- _ => None,
- }
- };
-
- let (message_tx, mut message_rx) = futures::channel::mpsc::unbounded::<ModelUpdate>();
-
- cx.spawn({
- let codegen = codegen.clone();
- async move |cx| {
- while let Some(update) = message_rx.next().await {
- let _ = codegen.update(cx, |this, _cx| match update {
- ModelUpdate::Description(d) => this.description = Some(d),
- ModelUpdate::Failure(f) => this.failure = Some(f),
- });
+ let rewrite_state: Arc<Mutex<Option<RewriteState>>> = Arc::new(Mutex::new(None));
+ let process_rewrite_state = rewrite_state.clone();
+ let process_tool_use =
+ move |tool_use: LanguageModelToolUse| -> Result<Option<ToolUseOutput>> {
+ match tool_use.name.as_ref() {
+ REWRITE_SECTION_TOOL_NAME => {
+ let input = match tool_use.input.parse::<RewriteSectionInput>() {
+ Ok(input) => input,
+ Err(_) if !tool_use.is_input_complete => return Ok(None),
+ Err(error) => {
+ return Err(error.context(format!(
+ "invalid input for `{REWRITE_SECTION_TOOL_NAME}` tool"
+ )));
+ }
+ };
+ let mut rewrite_state = process_rewrite_state.lock();
+ if let Some(state) = rewrite_state.as_ref()
+ && state.tool_use_id != tool_use.id
+ {
+ return Err(anyhow!(
+ "Inline assistant called `{REWRITE_SECTION_TOOL_NAME}` \
+ multiple times"
+ ));
+ }
+ let state = rewrite_state.get_or_insert_with(|| RewriteState {
+ tool_use_id: tool_use.id,
+ chars_read: 0,
+ is_input_complete: false,
+ });
+ let Some(text_slice) = input.replacement_text.get(state.chars_read..)
+ else {
+ return Ok(None);
+ };
+ let text = text_slice.to_string();
+ state.chars_read = input.replacement_text.len();
+ state.is_input_complete |= tool_use.is_input_complete;
+ Ok(Some(ToolUseOutput::Rewrite { text }))
+ }
+ FAILURE_MESSAGE_TOOL_NAME => {
+ let mut input = match tool_use.input.parse::<FailureMessageInput>() {
+ Ok(input) => input,
+ Err(_) if !tool_use.is_input_complete => return Ok(None),
+ Err(error) => {
+ return Err(error.context(format!(
+ "invalid input for `{FAILURE_MESSAGE_TOOL_NAME}` tool"
+ )));
+ }
+ };
+ Ok(Some(ToolUseOutput::Failure {
+ message: std::mem::take(&mut input.message),
+ is_input_complete: tool_use.is_input_complete,
+ }))
+ }
+ _ => Ok(None),
}
- }
- })
- .detach();
+ };
let mut message_id = None;
- let mut first_text = None;
+ let mut failure_started = false;
+ let mut failure_complete = false;
let last_token_usage = Arc::new(Mutex::new(TokenUsage::default()));
- let total_text = Arc::new(Mutex::new(String::new()));
- loop {
- if let Some(first_event) = completion_events.next().await {
- match first_event {
- Ok(LanguageModelCompletionEvent::StartMessage { message_id: id }) => {
- message_id = Some(id);
- }
- Ok(LanguageModelCompletionEvent::ToolUse(tool_use)) => {
- if let Some(output) = process_tool_use(tool_use) {
- let (text, update) = match output {
- ToolUseOutput::Rewrite { text, description } => {
- (Some(text), description.map(ModelUpdate::Description))
- }
- ToolUseOutput::Failure(message) => {
- (None, Some(ModelUpdate::Failure(message)))
+ let first_text = loop {
+ let Some(event) = completion_events.next().await else {
+ if failure_complete {
+ finish_with_status(CodegenStatus::Done, cx);
+ } else {
+ finish_with_status(
+ CodegenStatus::Error(anyhow!(
+ "Inline assistant response ended without completing \
+ `{REWRITE_SECTION_TOOL_NAME}` or `{FAILURE_MESSAGE_TOOL_NAME}`"
+ )),
+ cx,
+ );
+ }
+ return;
+ };
+
+ match event {
+ Ok(LanguageModelCompletionEvent::StartMessage { message_id: id }) => {
+ message_id = Some(id);
+ }
+ Ok(LanguageModelCompletionEvent::ToolUse(tool_use)) => {
+ let output = match process_tool_use(tool_use) {
+ Ok(output) => output,
+ Err(error) => {
+ finish_with_status(CodegenStatus::Error(error), cx);
+ return;
+ }
+ };
+ if let Some(output) = output {
+ match output {
+ ToolUseOutput::Rewrite { text } => {
+ if failure_started {
+ finish_with_status(
+ CodegenStatus::Error(anyhow!(
+ "Inline assistant called \
+ `{REWRITE_SECTION_TOOL_NAME}` after \
+ `{FAILURE_MESSAGE_TOOL_NAME}`"
+ )),
+ cx,
+ );
+ return;
}
- };
- if let Some(update) = update {
- let _ = message_tx.unbounded_send(update);
+ break text;
}
- first_text = text;
- if first_text.is_some() {
- break;
+ ToolUseOutput::Failure {
+ message,
+ is_input_complete,
+ } => {
+ failure_started = true;
+ failure_complete |= is_input_complete;
+ if is_input_complete
+ && codegen
+ .update(cx, |this, cx| {
+ this.failure = Some(message);
+ cx.notify();
+ })
+ .is_err()
+ {
+ return;
+ }
}
}
}
- Ok(LanguageModelCompletionEvent::UsageUpdate(token_usage)) => {
- *last_token_usage.lock() = token_usage;
- }
- Ok(LanguageModelCompletionEvent::Text(text)) => {
- let mut lock = total_text.lock();
- lock.push_str(&text);
- }
- Ok(e) => {
- log::warn!("Unexpected event: {:?}", e);
- break;
- }
- Err(e) => {
- finish_with_status(CodegenStatus::Error(e.into()), cx);
- break;
+ }
+ Ok(LanguageModelCompletionEvent::UsageUpdate(token_usage)) => {
+ *last_token_usage.lock() = token_usage;
+ }
+ Ok(LanguageModelCompletionEvent::Stop(reason)) => {
+ if !failure_complete {
+ finish_with_status(
+ CodegenStatus::Error(anyhow!(
+ "Inline assistant stopped before completing \
+ `{REWRITE_SECTION_TOOL_NAME}` or \
+ `{FAILURE_MESSAGE_TOOL_NAME}` ({reason:?})"
+ )),
+ cx,
+ );
+ } else if matches!(reason, StopReason::MaxTokens | StopReason::Refusal) {
+ finish_with_status(
+ CodegenStatus::Error(anyhow!(
+ "Inline assistant response was interrupted ({reason:?})"
+ )),
+ cx,
+ );
+ } else {
+ finish_with_status(CodegenStatus::Done, cx);
}
+ return;
+ }
+ Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
+ tool_name,
+ json_parse_error,
+ ..
+ }) => {
+ finish_with_status(
+ CodegenStatus::Error(anyhow!(
+ "Invalid input for inline assistant tool \
+ `{tool_name}`: {json_parse_error}"
+ )),
+ cx,
+ );
+ return;
+ }
+ Ok(
+ LanguageModelCompletionEvent::Queued { .. }
+ | LanguageModelCompletionEvent::Started
+ | LanguageModelCompletionEvent::Text(_)
+ | LanguageModelCompletionEvent::Thinking { .. }
+ | LanguageModelCompletionEvent::RedactedThinking { .. }
+ | LanguageModelCompletionEvent::ReasoningDetails(_)
+ | LanguageModelCompletionEvent::Compaction(_),
+ ) => {}
+ Err(error) => {
+ finish_with_status(CodegenStatus::Error(error.into()), cx);
+ return;
}
}
- }
-
- let Some(first_text) = first_text else {
- finish_with_status(CodegenStatus::Done, cx);
- return;
};
let move_last_token_usage = last_token_usage.clone();
-
- let text_stream = Box::pin(futures::stream::once(async { Ok(first_text) }).chain(
- completion_events.filter_map(move |e| {
- let process_tool_use = process_tool_use.clone();
- let last_token_usage = move_last_token_usage.clone();
- let total_text = total_text.clone();
- let mut message_tx = message_tx.clone();
- async move {
- match e {
- Ok(LanguageModelCompletionEvent::ToolUse(tool_use)) => {
- let Some(output) = process_tool_use(tool_use) else {
- return None;
- };
- let (text, update) = match output {
- ToolUseOutput::Rewrite { text, description } => {
- (Some(text), description.map(ModelUpdate::Description))
- }
- ToolUseOutput::Failure(message) => {
- (None, Some(ModelUpdate::Failure(message)))
- }
- };
- if let Some(update) = update {
- let _ = message_tx.send(update).await;
- }
- text.map(Ok)
- }
- Ok(LanguageModelCompletionEvent::UsageUpdate(token_usage)) => {
- *last_token_usage.lock() = token_usage;
- None
- }
- Ok(LanguageModelCompletionEvent::Text(text)) => {
- let mut lock = total_text.lock();
- lock.push_str(&text);
- None
+ let move_rewrite_state = rewrite_state.clone();
+
+ let remaining_text_stream = completion_events.filter_map(move |e| {
+ let process_tool_use = process_tool_use.clone();
+ let last_token_usage = move_last_token_usage.clone();
+ let rewrite_state = move_rewrite_state.clone();
+ async move {
+ match e {
+ Ok(LanguageModelCompletionEvent::ToolUse(tool_use)) => {
+ let output = match process_tool_use(tool_use) {
+ Ok(Some(output)) => output,
+ Ok(None) => return None,
+ Err(error) => return Some(Err(error.into())),
+ };
+ match output {
+ ToolUseOutput::Rewrite { text } => Some(Ok(text)),
+ ToolUseOutput::Failure { .. } => Some(Err(anyhow!(
+ "Inline assistant called `{FAILURE_MESSAGE_TOOL_NAME}` \
+ after starting `{REWRITE_SECTION_TOOL_NAME}`"
+ )
+ .into())),
}
- Ok(LanguageModelCompletionEvent::Stop(_reason)) => None,
- e => {
- log::error!("UNEXPECTED EVENT {:?}", e);
+ }
+ Ok(LanguageModelCompletionEvent::UsageUpdate(token_usage)) => {
+ *last_token_usage.lock() = token_usage;
+ None
+ }
+ Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
+ tool_name,
+ json_parse_error,
+ ..
+ }) => Some(Err(anyhow!(
+ "Invalid input for inline assistant tool \
+ `{tool_name}`: {json_parse_error}"
+ )
+ .into())),
+ Ok(LanguageModelCompletionEvent::Stop(reason)) => {
+ let rewrite_complete = rewrite_state
+ .lock()
+ .as_ref()
+ .is_some_and(|state| state.is_input_complete);
+ if !rewrite_complete {
+ Some(Err(anyhow!(
+ "Inline assistant stopped before completing \
+ `{REWRITE_SECTION_TOOL_NAME}` ({reason:?})"
+ )
+ .into()))
+ } else if matches!(reason, StopReason::MaxTokens | StopReason::Refusal)
+ {
+ Some(Err(anyhow!(
+ "Inline assistant response was interrupted ({reason:?})"
+ )
+ .into()))
+ } else {
None
}
}
+ Ok(
+ LanguageModelCompletionEvent::Queued { .. }
+ | LanguageModelCompletionEvent::Started
+ | LanguageModelCompletionEvent::Text(_)
+ | LanguageModelCompletionEvent::Thinking { .. }
+ | LanguageModelCompletionEvent::RedactedThinking { .. }
+ | LanguageModelCompletionEvent::StartMessage { .. }
+ | LanguageModelCompletionEvent::ReasoningDetails(_)
+ | LanguageModelCompletionEvent::Compaction(_),
+ ) => None,
+ Err(error) => Some(Err(error)),
}
- }),
- ));
+ }
+ });
+ let completion_status = futures::stream::once(async move {
+ if rewrite_state
+ .lock()
+ .as_ref()
+ .is_some_and(|state| state.is_input_complete)
+ {
+ None
+ } else {
+ Some(Err(anyhow!(
+ "Inline assistant response ended before completing \
+ `{REWRITE_SECTION_TOOL_NAME}`"
+ )
+ .into()))
+ }
+ })
+ .filter_map(futures::future::ready);
+ let text_stream = Box::pin(
+ futures::stream::once(async { Ok(first_text) })
+ .chain(remaining_text_stream)
+ .chain(completion_status),
+ );
let language_model_text_stream = LanguageModelTextStream {
message_id: message_id,
@@ -1870,35 +2002,306 @@ mod tests {
// than the first would cause an index-out-of-bounds panic because the
// chars_read_so_far counter was shared across all tool use IDs.
#[gpui::test]
- async fn test_separate_tool_uses_have_independent_char_counters(cx: &mut TestAppContext) {
- init_test(cx);
- let buffer = cx.new(|cx| Buffer::local("", cx));
- let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
- let range = buffer.read_with(cx, |buffer, cx| {
- let snapshot = buffer.snapshot(cx);
- snapshot.anchor_before(Point::new(0, 0))..snapshot.anchor_after(Point::new(0, 0))
+ async fn test_tool_completion_rejects_multiple_rewrite_tool_calls(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "longer replacement text", true))
+ .unwrap();
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_2", "short", true))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
});
- let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
- let codegen = cx.new(|cx| {
- CodegenAlternative::new(
- buffer.clone(),
- range.clone(),
- true,
- prompt_builder,
- Uuid::new_v4(),
- cx,
+ assert_eq!(
+ error.as_deref(),
+ Some("Inline assistant called `rewrite_section` multiple times")
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_ignores_non_tool_events(cx: &mut TestAppContext) {
+ let (buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Queued { position: 1 })
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Started)
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::StartMessage {
+ message_id: "message_1".into(),
+ })
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::ReasoningDetails(
+ serde_json::json!({ "encrypted_content": "reasoning" }),
+ ))
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Text(
+ "I'll update the section.".into(),
+ ))
+ .unwrap();
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "replace", false))
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Thinking {
+ text: "Finishing the rewrite".into(),
+ signature: None,
+ })
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::RedactedThinking {
+ data: "redacted".into(),
+ })
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
+ output_tokens: 1,
+ ..TokenUsage::default()
+ }))
+ .unwrap();
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "replacement", true))
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::EndTurn))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ assert_eq!(
+ buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
+ "replacement"
+ );
+ assert!(codegen.read_with(cx, |codegen, _cx| matches!(
+ &codegen.status,
+ CodegenStatus::Done
+ )));
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_when_stopped_without_tool_call(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::ReasoningDetails(
+ serde_json::json!([]),
+ ))
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::EndTurn))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some(
+ "Inline assistant stopped before completing `rewrite_section` or \
+ `failure_message` (EndTurn)"
)
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_on_eof_without_tool_call(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
});
+ assert_eq!(
+ error.as_deref(),
+ Some(
+ "Inline assistant response ended without completing `rewrite_section` or \
+ `failure_message`"
+ )
+ );
+ }
+ #[gpui::test]
+ async fn test_tool_completion_accepts_failure_message(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
let events_tx = simulate_tool_based_completion(&codegen, cx);
- // tool_1 has longer text; tool_2 has shorter text. With the old shared
- // counter, processing tool_2 would attempt replacement_text[N..] where
- // N > replacement_text.len(), panicking with index out of bounds.
+
events_tx
- .unbounded_send(rewrite_tool_use("tool_1", "longer replacement text", true))
+ .unbounded_send(failure_tool_use("The selection cannot be rewritten.", true))
.unwrap();
events_tx
- .unbounded_send(rewrite_tool_use("tool_2", "short", true))
+ .unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::EndTurn))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ assert!(codegen.read_with(cx, |codegen, _cx| matches!(
+ &codegen.status,
+ CodegenStatus::Done
+ )));
+ assert_eq!(
+ codegen.read_with(cx, |codegen, _cx| codegen.current_failure()),
+ Some("The selection cannot be rewritten.".into())
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_on_invalid_tool_json(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::ToolUseJsonParseError {
+ id: "tool_1".into(),
+ tool_name: REWRITE_SECTION_TOOL_NAME.into(),
+ raw_input: r#"{"replacement_text":"#.into(),
+ json_parse_error: "EOF while parsing a string".into(),
+ })
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some(
+ "Invalid input for inline assistant tool `rewrite_section`: \
+ EOF while parsing a string"
+ )
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_when_incomplete_rewrite_stops(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "partial", false))
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::MaxTokens))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some(
+ "Inline assistant stopped before completing `rewrite_section` \
+ (MaxTokens)"
+ )
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_when_incomplete_rewrite_reaches_eof(
+ cx: &mut TestAppContext,
+ ) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "partial", false))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some("Inline assistant response ended before completing `rewrite_section`")
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_when_interrupted_after_complete_rewrite(
+ cx: &mut TestAppContext,
+ ) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "replacement", true))
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::MaxTokens))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some("Inline assistant response was interrupted (MaxTokens)")
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_when_interrupted_after_failure_message(
+ cx: &mut TestAppContext,
+ ) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(failure_tool_use("The selection cannot be rewritten.", true))
+ .unwrap();
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::MaxTokens))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some("Inline assistant response was interrupted (MaxTokens)")
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_requires_failure_message_to_complete(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(failure_tool_use("Partial failure", false))
.unwrap();
events_tx
.unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::EndTurn))
@@ -1906,9 +2309,204 @@ mod tests {
drop(events_tx);
cx.run_until_parked();
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some(
+ "Inline assistant stopped before completing `rewrite_section` or \
+ `failure_message` (EndTurn)"
+ )
+ );
+ assert_eq!(
+ codegen.read_with(cx, |codegen, _cx| codegen.current_failure()),
+ None
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_rejects_failure_after_rewrite(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "replacement", true))
+ .unwrap();
+ events_tx
+ .unbounded_send(failure_tool_use("Cannot rewrite selection", true))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some(
+ "Inline assistant called `failure_message` after starting \
+ `rewrite_section`"
+ )
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_rejects_rewrite_after_failure(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(failure_tool_use("Cannot rewrite selection", true))
+ .unwrap();
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "replacement", true))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some("Inline assistant called `rewrite_section` after `failure_message`")
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_rejects_rewrite_after_partial_failure(cx: &mut TestAppContext) {
+ let (buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(failure_tool_use("Cannot rewrite", false))
+ .unwrap();
+ events_tx
+ .unbounded_send(rewrite_tool_use("tool_1", "replacement", true))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(
+ error.as_deref(),
+ Some("Inline assistant called `rewrite_section` after `failure_message`")
+ );
assert_eq!(
buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
- "longer replacement textshort"
+ ""
+ );
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_propagates_stream_error_before_rewrite(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion_results(&codegen, cx);
+
+ events_tx
+ .unbounded_send(Err(anyhow!("provider stream failed").into()))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(error.as_deref(), Some("provider stream failed"));
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_propagates_stream_error_after_rewrite(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion_results(&codegen, cx);
+
+ events_tx
+ .unbounded_send(Ok(rewrite_tool_use("tool_1", "replacement", true)))
+ .unwrap();
+ events_tx
+ .unbounded_send(Err(anyhow!("provider stream failed").into()))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert_eq!(error.as_deref(), Some("provider stream failed"));
+ }
+
+ #[gpui::test]
+ async fn test_tool_completion_errors_on_invalid_tool_input(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(LanguageModelCompletionEvent::ToolUse(
+ LanguageModelToolUse {
+ id: "tool_1".into(),
+ name: REWRITE_SECTION_TOOL_NAME.into(),
+ raw_input: r#"{"replacement_text":42}"#.into(),
+ input: language_model::LanguageModelToolUseInput::Json(
+ serde_json::json!({ "replacement_text": 42 }),
+ ),
+ is_input_complete: true,
+ thought_signature: None,
+ },
+ ))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+
+ let error = codegen.read_with(cx, |codegen, _cx| match &codegen.status {
+ CodegenStatus::Error(error) => Some(error.to_string()),
+ _ => None,
+ });
+ assert!(
+ error
+ .as_deref()
+ .is_some_and(|error| error.starts_with("invalid input for `rewrite_section` tool"))
+ );
+ }
+
+ #[gpui::test]
+ async fn test_start_clears_previous_failure(cx: &mut TestAppContext) {
+ let (_buffer, codegen) = new_tool_based_codegen(cx);
+ cx.update(|cx| AgentSettings::register(cx));
+ let events_tx = simulate_tool_based_completion(&codegen, cx);
+
+ events_tx
+ .unbounded_send(failure_tool_use("Cannot rewrite selection", true))
+ .unwrap();
+ drop(events_tx);
+ cx.run_until_parked();
+ assert_eq!(
+ codegen.read_with(cx, |codegen, _cx| codegen.current_failure()),
+ Some("Cannot rewrite selection".into())
+ );
+
+ codegen.update(cx, |codegen, cx| {
+ codegen
+ .start(
+ "Rewrite the selection".into(),
+ Task::ready(None).shared(),
+ Arc::new(FakeLanguageModel::default()),
+ cx,
+ )
+ .unwrap();
+ });
+
+ assert_eq!(
+ codegen.read_with(cx, |codegen, _cx| codegen.current_failure()),
+ None
);
}
@@ -1957,6 +2555,30 @@ mod tests {
cx.set_global(cx.update(SettingsStore::test));
}
+ fn new_tool_based_codegen(
+ cx: &mut TestAppContext,
+ ) -> (Entity<MultiBuffer>, Entity<CodegenAlternative>) {
+ init_test(cx);
+ let buffer = cx.new(|cx| Buffer::local("", cx));
+ let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
+ let range = buffer.read_with(cx, |buffer, cx| {
+ let snapshot = buffer.snapshot(cx);
+ snapshot.anchor_before(Point::new(0, 0))..snapshot.anchor_after(Point::new(0, 0))
+ });
+ let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
+ let codegen = cx.new(|cx| {
+ CodegenAlternative::new(
+ buffer.clone(),
+ range,
+ true,
+ prompt_builder,
+ Uuid::new_v4(),
+ cx,
+ )
+ });
+ (buffer, codegen)
+ }
+
fn simulate_response_stream(
codegen: &Entity<CodegenAlternative>,
cx: &mut TestAppContext,
@@ -1978,6 +2600,20 @@ mod tests {
chunks_tx
}
+ fn simulate_tool_based_completion_results(
+ codegen: &Entity<CodegenAlternative>,
+ cx: &mut TestAppContext,
+ ) -> mpsc::UnboundedSender<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>
+ {
+ let (events_tx, events_rx) = mpsc::unbounded();
+ let model = Arc::new(FakeLanguageModel::default());
+ codegen.update(cx, |codegen, cx| {
+ codegen.generation =
+ codegen.handle_completion(model, Task::ready(Ok(events_rx.boxed())), cx);
+ });
+ events_tx
+ }
+
fn simulate_tool_based_completion(
codegen: &Entity<CodegenAlternative>,
cx: &mut TestAppContext,
@@ -1995,6 +2631,22 @@ mod tests {
events_tx
}
+ fn failure_tool_use(message: &str, is_input_complete: bool) -> LanguageModelCompletionEvent {
+ let input = FailureMessageInput {
+ message: message.into(),
+ };
+ LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
+ id: "failure_tool".into(),
+ name: FAILURE_MESSAGE_TOOL_NAME.into(),
+ raw_input: serde_json::to_string(&input).unwrap(),
+ input: language_model::LanguageModelToolUseInput::Json(
+ serde_json::to_value(&input).unwrap(),
+ ),
+ is_input_complete,
+ thought_signature: None,
+ })
+ }
+
fn rewrite_tool_use(
id: &str,
replacement_text: &str,