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: Fix auto-compaction not repeating during long turns (#66215)

Smit Barmase2daea4d48862
diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs
index 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;