Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent: Fix auto-compaction not repeating during long turns (#66215)
Smit Barmase2daea4d48862
diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex 2760802e650..71c295546b5 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -1294,6 +1294,7 @@ pub struct Thread {title_generation_error: Option<SharedString>,pending_summary_generation: Option<Shared<Task<Option<SharedString>>>>,summary: Option<SharedString>,+ /// Remove only via `remove_messages_from`, which keeps `context_usage` in sync.messages: Vec<Arc<Message>>,// Message count cannot detect replacements in frozen history while a successor streams.retained_history_revision: usize,@@ -1309,6 +1310,9 @@ pub struct Thread {pending_message: Option<AgentMessage>,pub(crate) tools: BTreeMap<SharedString, Arc<dyn AnyAgentTool>>,request_token_usage: HashMap<ClientUserMessageId, language_model::TokenUsage>,+ /// Usage reported since the last summary. `request_token_usage` can't tell+ /// this apart from pre-summary usage within a turn.+ context_usage: Option<TokenUsage>,cumulative_token_usage: TokenUsage,/// The per-field maximum usage snapshot already added to/// `cumulative_token_usage` for the in-flight completion request. Reset at@@ -1461,6 +1465,7 @@ impl Thread {pending_message: None,tools: BTreeMap::default(),request_token_usage: HashMap::default(),+ context_usage: None,cumulative_token_usage: TokenUsage::default(),current_request_token_usage: TokenUsage::default(),pending_compaction_telemetry: None,@@ -1816,6 +1821,8 @@ impl Thread {watch::channel(Self::prompt_capabilities(model.as_model()));let action_log = cx.new(|_| ActionLog::new(project.clone()));+ let context_usage =+ context_usage_from_history(&db_thread.messages, &db_thread.request_token_usage);Self {id,@@ -1837,6 +1844,7 @@ impl Thread {pending_message: None,tools: BTreeMap::default(),request_token_usage: db_thread.request_token_usage.clone(),+ context_usage,cumulative_token_usage: db_thread.cumulative_token_usage,current_request_token_usage: TokenUsage::default(),pending_compaction_telemetry: None,@@ -2436,15 +2444,7 @@ impl Thread {fn update_token_usage(&mut self, update: language_model::TokenUsage, cx: &mut Context<Self>) {self.accumulate_token_usage(update);-- let Some(last_user_message) = self.last_user_message() else {- return;- };-- self.request_token_usage- .insert(last_user_message.id.clone(), update);- cx.emit(TokenUsageUpdated(self.latest_token_usage()));- cx.notify();+ self.record_request_usage(update, cx);}/// Records that the last request overflowed the model's context window so@@ -2457,17 +2457,23 @@ impl Thread {return;};let input_tokens = tokens.unwrap_or(0).max(model.max_token_count());- let Some(last_user_message) = self.last_user_message() else {- return;- };-- self.request_token_usage.insert(- last_user_message.id.clone(),+ self.record_request_usage(language_model::TokenUsage {input_tokens,..Default::default()},+ cx,);+ }++ fn record_request_usage(&mut self, usage: language_model::TokenUsage, cx: &mut Context<Self>) {+ self.context_usage = Some(usage);+ let Some(last_user_message) = self.last_user_message() else {+ return;+ };++ self.request_token_usage+ .insert(last_user_message.id.clone(), usage);cx.emit(TokenUsageUpdated(self.latest_token_usage()));cx.notify();}@@ -2488,7 +2494,15 @@ impl Thread {return Err(anyhow!("Message not found"));};- for message in self.messages.drain(position..) {+ self.remove_messages_from(position);+ self.clear_summary();+ cx.notify();+ Ok(())+ }++ fn remove_messages_from(&mut self, ix: usize) {+ let ix = ix.min(self.messages.len());+ for message in self.messages.drain(ix..) {match &*message {Message::User(message) => {self.request_token_usage.remove(&message.id);@@ -2496,9 +2510,7 @@ impl Thread {Message::Agent(_) | Message::Resume | Message::Compaction(_) => {}}}- self.clear_summary();- cx.notify();- Ok(())+ self.context_usage = context_usage_from_history(&self.messages, &self.request_token_usage);}pub fn latest_request_token_usage(&self) -> Option<language_model::TokenUsage> {@@ -2892,7 +2904,8 @@ impl Thread {match error.downcast::<CompletionError>() {Ok(CompletionError::Refusal) => {event_stream.send_stop(acp_v2::StopReason::Refusal);- _ = this.update(cx, |this, _| this.messages.truncate(message_ix));+ _ = this+ .update(cx, |this, _| this.remove_messages_from(message_ix));}Ok(CompletionError::MaxTokens) => {event_stream.send_stop(acp_v2::StopReason::MaxTokens);@@ -3490,6 +3503,7 @@ impl Thread {this.messages.push(compaction);}}+ this.context_usage = None;cx.notify();})?;@@ -4706,28 +4720,7 @@ impl Thread {let auto_compact = AgentSettings::get_global(cx).auto_compact;let max_input_tokens = self.input_token_capacity()?;- let (usage_ix, usage) = {- let this = &self;- this.messages- .iter()- .enumerate()- .rev()- .find_map(|(ix, message)| {- let Message::User(user_message) = &**message else {- return None;- };- this.request_token_usage- .get(&user_message.id)- .copied()- .map(|usage| (ix, usage))- })- }?;- if latest_compaction_message_ix_before(&self.messages, self.messages.len())- .is_some_and(|compaction_ix| compaction_ix > usage_ix)- {- return None;- }-+ let usage = self.context_usage?;let active_tokens = total_input_tokens(usage).saturating_add(usage.output_tokens);let compaction_threshold =auto_compact_threshold_token_count(auto_compact.threshold, max_input_tokens);@@ -4735,17 +4728,18 @@ impl Thread {return None;}- let insertion_ix = match self.messages.last() {- Some(message)- if matches!(- &**message,- Message::User(UserMessage { id, .. }) if !self.request_token_usage.contains_key(id)- ) =>- {- self.messages.len().saturating_sub(1)- }+ // Even with usage (reported before the stream failed), a trailing prompt has no reply yet, so keep it out of the summary.+ let insertion_ix = match self.messages.last().map(|message| &**message) {+ Some(Message::User(_)) => self.messages.len().saturating_sub(1),_ => self.messages.len(),};+ if insertion_ix == 0 {+ return None;+ }+ log::info!(+ "Auto-compacting thread {}: {active_tokens} tokens used, threshold is {compaction_threshold} of {max_input_tokens}",+ self.id+ );Some(insertion_ix)}@@ -5183,6 +5177,32 @@ fn latest_compaction_message_ix_before(messages: &[Arc<Message>], end_ix: usize).rposition(|message| matches!(&**message, Message::Compaction(_)))}+/// Only for rebuilding `Thread::context_usage`. Checking this before every+/// request limits auto-compaction to once per turn.+fn context_usage_from_history(+ messages: &[Arc<Message>],+ request_token_usage: &HashMap<ClientUserMessageId, TokenUsage>,+) -> Option<TokenUsage> {+ let (usage_ix, usage) = messages+ .iter()+ .enumerate()+ .rev()+ .find_map(|(ix, message)| {+ let Message::User(user_message) = &**message else {+ return None;+ };+ request_token_usage+ .get(&user_message.id)+ .map(|usage| (ix, *usage))+ })?;+ if latest_compaction_message_ix_before(messages, messages.len())+ .is_some_and(|compaction_ix| compaction_ix > usage_ix)+ {+ return None;+ }+ Some(usage)+}+fn retained_user_request_messages_before(messages: &[Arc<Message>],compaction_ix: usize,@@ -7187,10 +7207,11 @@ impl From<UserMessageContent> for acp_v2::ContentBlock {#[cfg(test)]mod tests {use super::*;+ use crate::tests::test_tools::EchoTool;use agent_client_protocol::schema::MaybeUndefined;use gpui::TestAppContext;- use language_model::LanguageModelToolUseId;use language_model::fake_provider::FakeLanguageModelProvider;+ use language_model::{LanguageModelProviderName, LanguageModelToolUseId};use serde_json::json;use settings::LanguageModelProviderSetting;use std::sync::Arc;@@ -7519,6 +7540,129 @@ mod tests {AgentSettings::override_global(settings, cx);}+ fn insert_request_token_usage(+ thread: &mut Thread,+ user_message_id: ClientUserMessageId,+ usage: TokenUsage,+ ) {+ thread.request_token_usage.insert(user_message_id, usage);+ thread.context_usage =+ context_usage_from_history(&thread.messages, &thread.request_token_usage);+ }++ fn enable_echo_tool(thread: &Entity<Thread>, cx: &mut TestAppContext) {+ cx.update(|cx| {+ let mut settings = AgentSettings::get_global(cx).clone();+ for profile in settings.profiles.values_mut() {+ profile+ .tools+ .insert(EchoTool::NAME.to_string().into(), true);+ }+ AgentSettings::override_global(settings, cx);+ thread.update(cx, |thread, _| thread.add_tool(EchoTool));+ });+ }++ fn finish_tool_round(+ fake: &FakeLanguageModelProvider,+ model: &LanguageModel,+ input_tokens: Option<u64>,+ cx: &mut TestAppContext,+ ) {+ if let Some(input_tokens) = input_tokens {+ fake.send_last_event(+ model,+ LanguageModelCompletionEvent::UsageUpdate(TokenUsage {+ input_tokens,+ ..Default::default()+ }),+ );+ }+ fake.send_last_event(+ model,+ LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {+ id: "echo".into(),+ name: EchoTool::NAME.into(),+ raw_input: r#"{"text":"tool output"}"#.to_string(),+ input: language_model::LanguageModelToolUseInput::Json(+ json!({"text": "tool output"}),+ ),+ is_input_complete: true,+ thought_signature: None,+ }),+ );+ fake.end_last(model);+ cx.run_until_parked();+ }++ fn finish_compaction(+ fake: &FakeLanguageModelProvider,+ model: &LanguageModel,+ summary: &str,+ cx: &mut TestAppContext,+ ) {+ assert_eq!(+ last_pending_intent(fake),+ Some(CompletionIntent::ThreadContextSummarization)+ );+ fake.send_last_text(model, summary);+ fake.end_last(model);+ cx.run_until_parked();+ }++ fn last_pending_intent(fake: &FakeLanguageModelProvider) -> Option<CompletionIntent> {+ fake.pending_completions()+ .last()+ .and_then(|request| request.intent)+ }++ fn fail_transiently_and_retry(+ fake: &FakeLanguageModelProvider,+ model: &LanguageModel,+ cx: &mut TestAppContext,+ ) {+ let retry_after = Duration::from_secs(3);+ fake.send_last_error(+ model,+ LanguageModelCompletionError::from_http_status(+ LanguageModelProviderName::new("test"),+ http_client::StatusCode::SERVICE_UNAVAILABLE,+ "overloaded".to_string(),+ Some(retry_after),+ ),+ );+ fake.end_last(model);+ cx.run_until_parked();+ cx.executor()+ .advance_clock(crate::maximum_retry_delay_with_jitter(retry_after));+ cx.run_until_parked();+ }++ async fn start_turn_and_compact(+ cx: &mut TestAppContext,+ ) -> (+ Entity<Thread>,+ Arc<FakeLanguageModelProvider>,+ LanguageModel,+ mpsc::UnboundedReceiver<Result<ThreadEvent>>,+ ) {+ let (thread, _event_stream, fake) = setup_thread_for_test(cx).await;+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| thread.set_model(model.clone(), cx));+ enable_echo_tool(&thread, cx);++ let events = thread+ .update(cx, |thread, cx| {+ thread.send(ClientUserMessageId::new(), vec!["prompt"], cx)+ })+ .unwrap();+ cx.run_until_parked();++ finish_tool_round(&fake, &model, Some(900_000), cx);+ finish_compaction(&fake, &model, "summary", cx);+ (thread, fake, model, events)+ }+fn set_registry_compaction_model(cx: &mut App, model: Option<LanguageModel>) {LanguageModelRegistry::global(cx).update(cx, |registry, cx| {registry.set_compaction_model(model, cx);@@ -7812,7 +7956,9 @@ mod tests {thread.messages.push(user_text_message(user_message_id.clone(), "below limit"));- thread.request_token_usage.insert(+ thread.messages.push(agent_text_message("answer"));+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 899_999,@@ -7822,7 +7968,8 @@ mod tests {assert_eq!(thread.compaction_message_target_ix(cx), None);- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 900_000,@@ -7830,7 +7977,7 @@ mod tests {},);- assert_eq!(thread.compaction_message_target_ix(cx), Some(1));+ assert_eq!(thread.compaction_message_target_ix(cx), Some(2));});});}@@ -7848,7 +7995,9 @@ mod tests {user_message_id.clone(),"near input limit",));- thread.request_token_usage.insert(+ thread.messages.push(agent_text_message("answer"));+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 871_199,@@ -7858,7 +8007,8 @@ mod tests {assert_eq!(thread.compaction_message_target_ix(cx), None);- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 871_200,@@ -7866,7 +8016,7 @@ mod tests {},);- assert_eq!(thread.compaction_message_target_ix(cx), Some(1));+ assert_eq!(thread.compaction_message_target_ix(cx), Some(2));set_auto_compact_settings(cx,@@ -7875,7 +8025,8 @@ mod tests {threshold: AutoCompactThreshold::TokensRemaining(20_000),},);- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 948_000,@@ -7885,7 +8036,8 @@ mod tests {assert_eq!(thread.compaction_message_target_ix(cx), None);- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 948_001,@@ -7893,7 +8045,7 @@ mod tests {},);- assert_eq!(thread.compaction_message_target_ix(cx), Some(1));+ assert_eq!(thread.compaction_message_target_ix(cx), Some(2));});});}@@ -7922,8 +8074,10 @@ mod tests {user_message_id.clone(),"near the independent input limit",));- for (input_tokens, expected_target) in [(80_999, None), (81_000, Some(1))] {- thread.request_token_usage.insert(+ thread.messages.push(agent_text_message("answer"));+ for (input_tokens, expected_target) in [(80_999, None), (81_000, Some(2))] {+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens,@@ -7958,7 +8112,9 @@ mod tests {thread.messages.push(user_text_message(user_message_id.clone(), "near limit"));- thread.request_token_usage.insert(+ thread.messages.push(agent_text_message("answer"));+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 960_000,@@ -7991,7 +8147,9 @@ mod tests {user_message_id.clone(),"fixed token limit",));- thread.request_token_usage.insert(+ thread.messages.push(agent_text_message("answer"));+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 99_999,@@ -8001,7 +8159,8 @@ mod tests {assert_eq!(thread.compaction_message_target_ix(cx), None);- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 100_000,@@ -8009,7 +8168,7 @@ mod tests {},);- assert_eq!(thread.compaction_message_target_ix(cx), Some(1));+ assert_eq!(thread.compaction_message_target_ix(cx), Some(2));set_auto_compact_settings(cx,@@ -8018,7 +8177,8 @@ mod tests {threshold: AutoCompactThreshold::TokensRemaining(20_000),},);- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 980_000,@@ -8028,7 +8188,8 @@ mod tests {assert_eq!(thread.compaction_message_target_ix(cx), None);- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: 980_001,@@ -8036,7 +8197,7 @@ mod tests {},);- assert_eq!(thread.compaction_message_target_ix(cx), Some(1));+ assert_eq!(thread.compaction_message_target_ix(cx), Some(2));});});}@@ -8057,7 +8218,9 @@ mod tests {thread.messages.push(user_text_message(user_message_id.clone(), "near limit"));- thread.request_token_usage.insert(+ thread.messages.push(agent_text_message("answer"));+ insert_request_token_usage(+ thread,user_message_id.clone(),language_model::TokenUsage {input_tokens: u64::MAX,@@ -8086,7 +8249,8 @@ mod tests {.messages.push(user_text_message(old_user_message_id.clone(), "old user"));thread.messages.push(agent_text_message("old assistant"));- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,old_user_message_id.clone(),language_model::TokenUsage {input_tokens: 960_000,@@ -8518,7 +8682,8 @@ mod tests {.messages.push(user_text_message(old_user_message_id.clone(), "old user"));thread.messages.push(agent_text_message("old assistant"));- thread.request_token_usage.insert(+ insert_request_token_usage(+ thread,old_user_message_id.clone(),TokenUsage {input_tokens: u64::MAX,@@ -8594,9 +8759,7 @@ mod tests {.messages.push(user_text_message(old_user_message_id.clone(), "old user"));thread.messages.push(agent_text_message("old assistant"));- thread- .request_token_usage- .insert(old_user_message_id.clone(), prior_usage);+ insert_request_token_usage(thread, old_user_message_id.clone(), prior_usage);thread.cumulative_token_usage = prior_usage;thread.current_request_token_usage = prior_usage;});@@ -8668,6 +8831,233 @@ mod tests {});}+ #[gpui::test]+ async fn test_auto_compaction_runs_again_later_in_the_same_turn(cx: &mut TestAppContext) {+ let (_thread, fake, model, _events) = start_turn_and_compact(cx).await;++ finish_tool_round(&fake, &model, None, cx);+ assert_eq!(+ last_pending_intent(&fake),+ Some(CompletionIntent::ToolResults)+ );++ finish_tool_round(&fake, &model, Some(900_000), cx);+ finish_compaction(&fake, &model, "second summary", cx);+ assert_eq!(+ last_pending_intent(&fake),+ Some(CompletionIntent::ToolResults)+ );+ }++ #[gpui::test]+ async fn test_partial_reply_after_compaction_does_not_compact_again(cx: &mut TestAppContext) {+ let (_thread, fake, model, _events) = start_turn_and_compact(cx).await;++ fake.send_last_text(&model, "partial reply");+ fail_transiently_and_retry(&fake, &model, cx);++ assert_eq!(+ last_pending_intent(&fake),+ Some(CompletionIntent::UserPrompt)+ );+ }++ #[gpui::test]+ async fn test_overflow_after_compaction_compacts_next_prompt(cx: &mut TestAppContext) {+ let (thread, fake, model, _events) = start_turn_and_compact(cx).await;++ fake.send_last_error(+ &model,+ LanguageModelCompletionError::from_http_status(+ LanguageModelProviderName::new("test"),+ http_client::StatusCode::PAYLOAD_TOO_LARGE,+ "prompt is too long".to_string(),+ None,+ ),+ );+ fake.end_last(&model);+ cx.run_until_parked();+ assert_eq!(fake.pending_completions(), Vec::new());++ let _events = thread+ .update(cx, |thread, cx| {+ thread.send(ClientUserMessageId::new(), vec!["next prompt"], cx)+ })+ .unwrap();+ cx.run_until_parked();++ assert_eq!(+ last_pending_intent(&fake),+ Some(CompletionIntent::ThreadContextSummarization)+ );+ }++ #[gpui::test]+ async fn test_compaction_on_retry_inserts_summary_before_unanswered_prompt(+ cx: &mut TestAppContext,+ ) {+ let (thread, _event_stream, fake) = setup_thread_for_test(cx).await;+ let model = fake.model("fake");+ thread.update(cx, |thread, cx| {+ thread.set_model(model.clone(), cx);+ thread+ .messages+ .push(user_text_message(ClientUserMessageId::new(), "old user"));+ thread.messages.push(agent_text_message("old assistant"));+ });++ let _events = thread+ .update(cx, |thread, cx| {+ thread.send(ClientUserMessageId::new(), vec!["new prompt"], cx)+ })+ .unwrap();+ cx.run_until_parked();++ fake.send_last_event(+ &model,+ LanguageModelCompletionEvent::UsageUpdate(TokenUsage {+ input_tokens: 950_000,+ ..Default::default()+ }),+ );+ fail_transiently_and_retry(&fake, &model, cx);++ let compaction_request = fake.pending_completions().pop().unwrap();+ assert_eq!(+ request_texts_after_system(&compaction_request.messages),+ vec![+ "old user".to_string(),+ "old assistant".to_string(),+ COMPACTION_PROMPT.to_string(),+ ]+ );+ finish_compaction(&fake, &model, "summary", cx);++ let final_request = fake.pending_completions().pop().unwrap();+ assert_eq!(+ request_texts_after_system(&final_request.messages),+ vec![+ "old user".to_string(),+ summary_request_text("summary"),+ "new prompt".to_string(),+ ]+ );+ }++ #[gpui::test]+ async fn test_truncate_recomputes_context_usage(cx: &mut TestAppContext) {+ let (thread, _event_stream, fake) = setup_thread_for_test(cx).await;+ let model = fake.model("fake");+ let first_user_message_id = ClientUserMessageId::new();+ let second_user_message_id = ClientUserMessageId::new();+ let third_user_message_id = ClientUserMessageId::new();+ let usage = |input_tokens| TokenUsage {+ input_tokens,+ ..Default::default()+ };++ thread.update(cx, |thread, cx| {+ thread.set_model(model.clone(), cx);+ thread.messages.extend([+ user_text_message(first_user_message_id.clone(), "first"),+ agent_text_message("first answer"),+ summary_compaction("summary"),+ user_text_message(second_user_message_id.clone(), "second"),+ agent_text_message("second answer"),+ user_text_message(third_user_message_id.clone(), "third"),+ agent_text_message("third answer"),+ ]);+ insert_request_token_usage(thread, first_user_message_id.clone(), usage(900_000));+ insert_request_token_usage(thread, second_user_message_id.clone(), usage(200_000));+ insert_request_token_usage(thread, third_user_message_id.clone(), usage(300_000));+ assert_eq!(thread.context_usage, Some(usage(300_000)));++ thread.truncate(third_user_message_id, cx).unwrap();+ assert_eq!(thread.context_usage, Some(usage(200_000)));+ assert_eq!(+ thread.tokens_before_message(&second_user_message_id),+ Some(900_000)+ );++ thread.truncate(second_user_message_id, cx).unwrap();+ assert_eq!(thread.context_usage, None);+ });+ }++ #[gpui::test]+ async fn test_refusal_after_compaction_compacts_next_prompt(cx: &mut TestAppContext) {+ let (thread, _event_stream, fake) = setup_thread_for_test(cx).await;+ let model = fake.model("fake");+ let old_user_message_id = ClientUserMessageId::new();+ thread.update(cx, |thread, cx| {+ thread.set_model(model.clone(), cx);+ thread+ .messages+ .push(user_text_message(old_user_message_id.clone(), "old user"));+ thread.messages.push(agent_text_message("old assistant"));+ insert_request_token_usage(+ thread,+ old_user_message_id,+ TokenUsage {+ input_tokens: 900_000,+ ..Default::default()+ },+ );+ });++ let _events = thread+ .update(cx, |thread, cx| {+ thread.send(ClientUserMessageId::new(), vec!["refused prompt"], cx)+ })+ .unwrap();+ cx.run_until_parked();+ finish_compaction(&fake, &model, "summary", cx);++ fake.send_last_event(+ &model,+ LanguageModelCompletionEvent::Stop(StopReason::Refusal),+ );+ fake.end_last(&model);+ cx.run_until_parked();+ thread.read_with(cx, |thread, _cx| assert_eq!(thread.messages.len(), 2));++ let _events = thread+ .update(cx, |thread, cx| {+ thread.send(ClientUserMessageId::new(), vec!["next prompt"], cx)+ })+ .unwrap();+ cx.run_until_parked();++ assert_eq!(+ last_pending_intent(&fake),+ Some(CompletionIntent::ThreadContextSummarization)+ );+ }++ #[gpui::test]+ async fn test_auto_compaction_skips_when_only_the_prompt_remains(cx: &mut TestAppContext) {+ let (thread, _event_stream, fake) = setup_thread_for_test(cx).await;+ let model = fake.model("fake");+ let user_message_id = ClientUserMessageId::new();++ thread.update(cx, |thread, cx| {+ thread.set_model(model.clone(), cx);+ thread+ .messages+ .push(user_text_message(user_message_id.clone(), "huge prompt"));+ insert_request_token_usage(+ thread,+ user_message_id,+ TokenUsage {+ input_tokens: 950_000,+ ..Default::default()+ },+ );++ assert_eq!(thread.compaction_message_target_ix(cx), None);+ });+ }+#[gpui::test]async fn test_replay_emits_context_compaction(cx: &mut TestAppContext) {let (thread, _event_stream, _) = setup_thread_for_test(cx).await;